fix: eth66 serve signature

crates/chainspec/src/spec.rs

@@ -2530,13 +2530,15 @@ Post-merge hard forks (timestamp based):
                 update_fraction: 3338477,
                 min_blob_fee: BLOB_TX_MIN_BLOB_GASPRICE,
                 max_blobs_per_tx: 6,
+                blob_base_cost: 0,
             },
             prague: BlobParams {
                 target_blob_count: 3,
                 max_blob_count: 6,
                 update_fraction: 3338477,
                 min_blob_fee: BLOB_TX_MIN_BLOB_GASPRICE,
                 max_blobs_per_tx: 6,
+                blob_base_cost: 0,
             },
             ..Default::default()
         };

crates/ethereum/node/src/node.rs

@@ -510,7 +510,7 @@ where
         pool: Pool,
     ) -> eyre::Result<Self::Network> {
         let network = ctx.network_builder().await?;
-        let handle = ctx.start_network(network, pool);
+        let handle = ctx.start_network(network, pool, None);
         info!(target: "reth::cli", enode=%handle.local_node_record(), "P2P networking initialized");
         Ok(handle)
     }

crates/net/network/src/builder.rs

@@ -9,6 +9,7 @@ use crate::{
         policy::NetworkPolicies,
         TransactionPropagationPolicy, TransactionsManager, TransactionsManagerConfig,
     },
+    transform::header::HeaderTransform,
     NetworkHandle, NetworkManager,
 };
 use reth_eth_wire::{EthNetworkPrimitives, NetworkPrimitives};
@@ -63,12 +64,13 @@ impl<Tx, Eth, N: NetworkPrimitives> NetworkBuilder<Tx, Eth, N> {
     pub fn request_handler<Client>(
         self,
         client: Client,
+        request_header_transform: Option<Box<dyn HeaderTransform<N::BlockHeader>>>,
     ) -> NetworkBuilder<Tx, EthRequestHandler<Client, N>, N> {
         let Self { mut network, transactions, .. } = self;
         let (tx, rx) = mpsc::channel(ETH_REQUEST_CHANNEL_CAPACITY);
         network.set_eth_request_handler(tx);
         let peers = network.handle().peers_handle().clone();
-        let request_handler = EthRequestHandler::new(client, peers, rx);
+        let request_handler = EthRequestHandler::new(client, peers, rx, request_header_transform);
         NetworkBuilder { network, request_handler, transactions }
     }
 

crates/net/network/src/config.rs

@@ -169,7 +169,7 @@ where
         let client = self.client.clone();
         let (handle, network, _txpool, eth) = NetworkManager::builder::<C>(self)
             .await?
-            .request_handler::<C>(client)
+            .request_handler::<C>(client, None)
             .split_with_handle();
 
         tokio::task::spawn(network);

crates/net/network/src/eth_requests.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     budget::DEFAULT_BUDGET_TRY_DRAIN_DOWNLOADERS, metered_poll_nested_stream_with_budget,
-    metrics::EthRequestHandlerMetrics,
+    metrics::EthRequestHandlerMetrics, transform::header::HeaderTransform,
 };
 use alloy_consensus::{BlockHeader, ReceiptWithBloom};
 use alloy_eips::BlockHashOrNumber;
@@ -61,18 +61,26 @@ pub struct EthRequestHandler<C, N: NetworkPrimitives = EthNetworkPrimitives> {
     peers: PeersHandle,
     /// Incoming request from the [`NetworkManager`](crate::NetworkManager).
     incoming_requests: ReceiverStream<IncomingEthRequest<N>>,
+    /// The header transform to apply to the headers before sending to peers.
+    header_transform: Option<Box<dyn HeaderTransform<N::BlockHeader>>>,
     /// Metrics for the eth request handler.
     metrics: EthRequestHandlerMetrics,
 }
 
 // === impl EthRequestHandler ===
 impl<C, N: NetworkPrimitives> EthRequestHandler<C, N> {
     /// Create a new instance
-    pub fn new(client: C, peers: PeersHandle, incoming: Receiver<IncomingEthRequest<N>>) -> Self {
+    pub fn new(
+        client: C,
+        peers: PeersHandle,
+        incoming: Receiver<IncomingEthRequest<N>>,
+        header_transform: Option<Box<dyn HeaderTransform<N::BlockHeader>>>,
+    ) -> Self {
         Self {
             client,
             peers,
             incoming_requests: ReceiverStream::new(incoming),
+            header_transform,
             metrics: Default::default(),
         }
     }
@@ -81,7 +89,7 @@ impl<C, N: NetworkPrimitives> EthRequestHandler<C, N> {
 impl<C, N> EthRequestHandler<C, N>
 where
     N: NetworkPrimitives,
-    C: BlockReader,
+    C: BlockReader<Header = N::BlockHeader>,
 {
     /// Returns the list of requested headers
     fn get_headers_response(&self, request: GetBlockHeaders) -> Vec<C::Header> {
@@ -144,6 +152,11 @@ where
             }
         }
 
+        // TODO: remove this once we deprecated l2geth
+        if let Some(ref header_transform) = self.header_transform {
+            headers = headers.into_iter().map(|h| header_transform.map(h)).collect()
+        }
+
         headers
     }
 

crates/net/network/src/lib.rs

@@ -98,7 +98,7 @@
 //!         .await
 //!         .unwrap()
 //!         .transactions(pool, transactions_manager_config)
-//!         .request_handler(client)
+//!         .request_handler(client, None)
 //!         .split_with_handle();
 //! }
 //! ```

crates/net/network/src/manager.rs

@@ -380,7 +380,7 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
     ///         .await
     ///         .unwrap()
     ///         .transactions(pool, transactions_manager_config)
-    ///         .request_handler(client)
+    ///         .request_handler(client, None)
     ///         .split_with_handle();
     /// }
     /// ```

crates/net/network/src/test_utils/testnet.rs

@@ -469,7 +469,7 @@ where
         let (tx, rx) = channel(ETH_REQUEST_CHANNEL_CAPACITY);
         self.network.set_eth_request_handler(tx);
         let peers = self.network.peers_handle();
-        let request_handler = EthRequestHandler::new(self.client.clone(), peers, rx);
+        let request_handler = EthRequestHandler::new(self.client.clone(), peers, rx, None);
         self.request_handler = Some(request_handler);
     }
 

crates/net/network/tests/it/connect.rs

@@ -234,7 +234,7 @@ async fn test_connect_with_builder() {
         .await
         .unwrap()
         .into_builder()
-        .request_handler(client)
+        .request_handler(client, None)
         .split_with_handle();
 
     let mut events = handle.event_listener();
@@ -271,7 +271,7 @@ async fn test_connect_to_trusted_peer() {
         .await
         .unwrap()
         .into_builder()
-        .request_handler(client)
+        .request_handler(client, None)
         .transactions(testing_pool(), transactions_manager_config)
         .split_with_handle();
 

crates/node/builder/src/builder/mod.rs

@@ -17,6 +17,7 @@ use reth_db_api::{database::Database, database_metrics::DatabaseMetrics};
 use reth_exex::ExExContext;
 use reth_network::{
     transactions::{TransactionPropagationPolicy, TransactionsManagerConfig},
+    transform::header::HeaderTransform,
     NetworkBuilder, NetworkConfig, NetworkConfigBuilder, NetworkHandle, NetworkManager,
     NetworkPrimitives,
 };
@@ -789,6 +790,7 @@ impl<Node: FullNodeTypes> BuilderContext<Node> {
         &self,
         builder: NetworkBuilder<(), (), N>,
         pool: Pool,
+        request_transform: Option<Box<dyn HeaderTransform<N::BlockHeader>>>,
     ) -> NetworkHandle<N>
     where
         N: NetworkPrimitives,
@@ -806,6 +808,7 @@ impl<Node: FullNodeTypes> BuilderContext<Node> {
             pool,
             self.config().network.transactions_manager_config(),
             self.config().network.tx_propagation_policy,
+            request_transform,
         )
     }
 
@@ -821,6 +824,7 @@ impl<Node: FullNodeTypes> BuilderContext<Node> {
         pool: Pool,
         tx_config: TransactionsManagerConfig,
         propagation_policy: Policy,
+        request_transform: Option<Box<dyn HeaderTransform<N::BlockHeader>>>,
     ) -> NetworkHandle<N>
     where
         N: NetworkPrimitives,
@@ -836,7 +840,7 @@ impl<Node: FullNodeTypes> BuilderContext<Node> {
     {
         let (handle, network, txpool, eth) = builder
             .transactions_with_policy(pool, tx_config, propagation_policy)
-            .request_handler(self.provider().clone())
+            .request_handler(self.provider().clone(), request_transform)
             .split_with_handle();
 
         self.executor.spawn_critical("p2p txpool", Box::pin(txpool));

crates/optimism/node/src/node.rs

@@ -1136,7 +1136,7 @@ where
     ) -> eyre::Result<Self::Network> {
         let network_config = self.network_config(ctx)?;
         let network = NetworkManager::builder(network_config).await?;
-        let handle = ctx.start_network(network, pool);
+        let handle = ctx.start_network(network, pool, None);
         info!(target: "reth::cli", enode=%handle.local_node_record(), "P2P networking initialized");
 
         Ok(handle)

crates/scroll/node/src/builder/network.rs

@@ -2,20 +2,16 @@ use reth_eth_wire_types::BasicNetworkPrimitives;
 use reth_network::{
     config::NetworkMode,
     protocol::{RlpxSubProtocol, RlpxSubProtocols},
-    transform::header::HeaderTransform,
     NetworkConfig, NetworkHandle, NetworkManager, PeersInfo,
 };
 use reth_node_api::TxTy;
 use reth_node_builder::{components::NetworkBuilder, BuilderContext, FullNodeTypes};
 use reth_node_types::NodeTypes;
-use reth_primitives_traits::BlockHeader;
 use reth_scroll_chainspec::ScrollChainSpec;
 use reth_scroll_primitives::ScrollPrimitives;
 use reth_tracing::tracing::info;
 use reth_transaction_pool::{PoolTransaction, TransactionPool};
-use scroll_alloy_hardforks::ScrollHardforks;
 use std::fmt::Debug;
-
 /// The network builder for Scroll.
 #[derive(Debug, Default)]
 pub struct ScrollNetworkBuilder {
@@ -55,21 +51,16 @@ where
         ctx: &BuilderContext<Node>,
         pool: Pool,
     ) -> eyre::Result<Self::Network> {
-        // get the header transform.
-        let chain_spec = ctx.chain_spec();
-        let transform = ScrollHeaderTransform { chain_spec };
-
         // set the network mode to work.
         let config = ctx.network_config()?;
         let config = NetworkConfig {
             network_mode: NetworkMode::Work,
-            header_transform: Box::new(transform),
             extra_protocols: self.scroll_sub_protocols,
             ..config
         };
 
         let network = NetworkManager::builder(config).await?;
-        let handle = ctx.start_network(network, pool);
+        let handle = ctx.start_network(network, pool, None);
         info!(target: "reth::cli", enode=%handle.local_node_record(), "P2P networking initialized");
         Ok(handle)
     }
@@ -78,34 +69,3 @@ where
 /// Network primitive types used by Scroll networks.
 pub type ScrollNetworkPrimitives =
     BasicNetworkPrimitives<ScrollPrimitives, scroll_alloy_consensus::ScrollPooledTransaction>;
-
-/// An implementation of a [`HeaderTransform`] for Scroll.
-#[derive(Debug, Clone)]
-#[non_exhaustive]
-pub struct ScrollHeaderTransform<ChainSpec> {
-    chain_spec: ChainSpec,
-}
-
-impl<ChainSpec: ScrollHardforks + Debug + Send + Sync + 'static> ScrollHeaderTransform<ChainSpec> {
-    /// Returns a new instance of the [`ScrollHeaderTransform`] from the provider chain spec.
-    pub const fn new(chain_spec: ChainSpec) -> Self {
-        Self { chain_spec }
-    }
-
-    /// Returns a new [`ScrollHeaderTransform`] as a [`HeaderTransform`] trait object.
-    pub fn boxed<H: BlockHeader>(chain_spec: ChainSpec) -> Box<dyn HeaderTransform<H>> {
-        Box::new(Self { chain_spec })
-    }
-}
-
-impl<H: BlockHeader, ChainSpec: ScrollHardforks + Debug + Send + Sync> HeaderTransform<H>
-    for ScrollHeaderTransform<ChainSpec>
-{
-    fn map(&self, mut header: H) -> H {
-        if self.chain_spec.is_euclid_v2_active_at_timestamp(header.timestamp()) {
-            // clear the extra data field.
-            *header.extra_data_mut() = Default::default()
-        }
-        header
-    }
-}

crates/scroll/node/src/lib.rs

@@ -8,7 +8,7 @@ pub use builder::{
     consensus::ScrollConsensusBuilder,
     engine::{ScrollEngineValidator, ScrollEngineValidatorBuilder},
     execution::ScrollExecutorBuilder,
-    network::{ScrollHeaderTransform, ScrollNetworkBuilder, ScrollNetworkPrimitives},
+    network::{ScrollNetworkBuilder, ScrollNetworkPrimitives},
     payload::ScrollPayloadBuilderBuilder,
     pool::ScrollPoolBuilder,
 };