Merge pull request #73 from bnb-chain/develop

chore: prepare for release v0.0.7

Author: joey0612

crates/engine/tree/src/tree/metrics.rs

@@ -155,6 +155,8 @@ pub(crate) struct EngineMetrics {
     pub(crate) block_insert_total_duration: Histogram,
     /// Block insert throughput in mgas/s
     pub(crate) block_insert_mgasps: Gauge,
+    /// Block insertion delay: the difference between current timestamp and block header timestamp (in nanoseconds)
+    pub(crate) block_insert_timestamp_delay: Histogram,
 }
 
 /// Metrics for non-execution related block validation.

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

@@ -4,7 +4,7 @@ use crate::{EthMessage, EthVersion, NetworkPrimitives};
 use alloc::{sync::Arc, vec::Vec};
 use alloy_primitives::{
     map::{HashMap, HashSet},
-    Bytes, TxHash, B256, U128,
+    Bytes, TxHash, B256, U128, U256,
 };
 use alloy_rlp::{
     Decodable, Encodable, RlpDecodable, RlpDecodableWrapper, RlpEncodable, RlpEncodableWrapper,
@@ -73,6 +73,9 @@ pub trait NewBlockPayload:
 
     /// Returns a reference to the block.
     fn block(&self) -> &Self::Block;
+    
+    /// Returns the total difficulty if available
+    fn td(&self) -> Option<U256>;
 }
 
 /// A new block with the current total difficulty, which includes the difficulty of the returned
@@ -93,6 +96,10 @@ impl<B: Block + 'static> NewBlockPayload for NewBlock<B> {
     fn block(&self) -> &Self::Block {
         &self.block
     }
+    
+    fn td(&self) -> Option<U256> {
+        Some(U256::from(self.td))
+    }
 }
 
 generate_tests!(#[rlp, 25] NewBlock<reth_ethereum_primitives::Block>, EthNewBlockTests);

crates/net/eth-wire-types/src/broadcast.rs

@@ -23,6 +23,7 @@ pub mod noop;
 pub mod test_utils;
 use test_utils::PeersHandleProvider;
 
+use alloy_primitives::{B256, U256};
 pub use alloy_rpc_types_admin::EthProtocolInfo;
 pub use reth_network_p2p::{BlockClient, HeadersClient};
 pub use reth_network_types::{PeerKind, Reputation, ReputationChangeKind};
@@ -238,12 +239,18 @@ pub struct PeerInfo {
     pub direction: Direction,
     /// The negotiated eth version.
     pub eth_version: EthVersion,
-    /// The Status message the peer sent for the `eth` handshake
+    /// The Status message the peer sent for the `eth` handshake (snapshot at connection time)
     pub status: Arc<UnifiedStatus>,
     /// The timestamp when the session to that peer has been established.
     pub session_established: Instant,
     /// The peer's connection kind
     pub kind: PeerKind,
+    /// Real-time tracked best block hash of the peer
+    pub best_hash: B256,
+    /// Real-time tracked best block number of the peer
+    pub best_number: Option<u64>,
+    /// Real-time tracked total difficulty of the peer (None in PoS)
+    pub best_td: Option<U256>,
 }
 
 /// The direction of the connection.

crates/net/network-api/src/lib.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use reth_net_banlist::BanList;
-use reth_network_peers::{NodeRecord, TrustedPeer};
+use reth_network_peers::{NodeRecord, PeerId, TrustedPeer};
 use tracing::info;
 
 use crate::{BackoffKind, ReputationChangeWeights};
@@ -166,6 +166,9 @@ pub struct PeersConfig {
     /// This acts as an IP based rate limit.
     #[cfg_attr(feature = "serde", serde(default, with = "humantime_serde"))]
     pub incoming_ip_throttle_duration: Duration,
+
+    /// The node ids of the proxyed nodes.
+    pub proxyed_node_ids: Vec<PeerId>,
 }
 
 impl Default for PeersConfig {
@@ -184,6 +187,7 @@ impl Default for PeersConfig {
             basic_nodes: Default::default(),
             max_backoff_count: 5,
             incoming_ip_throttle_duration: INBOUND_IP_THROTTLE_DURATION,
+            proxyed_node_ids: Vec::new(),
         }
     }
 }

crates/net/network-types/src/peers/config.rs

@@ -220,6 +220,8 @@ pub struct NetworkConfigBuilder<N: NetworkPrimitives = EthNetworkPrimitives> {
     /// The Ethereum P2P handshake, see also:
     /// <https://github.com/ethereum/devp2p/blob/master/rlpx.md#initial-handshake>.
     handshake: Arc<dyn EthRlpxHandshake>,
+    /// The node ids of the proxyed nodes.
+    proxyed_node_ids: Vec<PeerId>,
 }
 
 impl NetworkConfigBuilder<EthNetworkPrimitives> {
@@ -260,6 +262,7 @@ impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
             transactions_manager_config: Default::default(),
             nat: None,
             handshake: Arc::new(EthHandshake::default()),
+            proxyed_node_ids: Vec::new(),
         }
     }
 
@@ -467,6 +470,14 @@ impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
         self.boot_nodes.iter()
     }
 
+    /// Sets the proxied peer IDs.
+    ///
+    /// These peer IDs will be treated specially in the network layer.
+    pub fn proxied_peers(mut self, peer_ids: Vec<PeerId>) -> Self {
+        self.proxyed_node_ids = peer_ids;
+        self
+    }
+
     /// Disable the DNS discovery.
     pub fn disable_dns_discovery(mut self) -> Self {
         self.dns_discovery_config = None;
@@ -606,6 +617,7 @@ impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
             transactions_manager_config,
             nat,
             handshake,
+            proxyed_node_ids,
         } = self;
 
         let head = head.unwrap_or_else(|| Head {
@@ -651,6 +663,10 @@ impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
             }
         }
 
+        // Set proxyed_node_ids in peers_config
+        let mut peers_config = peers_config.unwrap_or_default();
+        peers_config.proxyed_node_ids = proxyed_node_ids;
+
         NetworkConfig {
             client,
             secret_key,
@@ -660,7 +676,7 @@ impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
             discovery_v5_config: discovery_v5_builder.map(|builder| builder.build()),
             discovery_v4_addr: discovery_addr.unwrap_or(DEFAULT_DISCOVERY_ADDRESS),
             listener_addr,
-            peers_config: peers_config.unwrap_or_default(),
+            peers_config,
             sessions_config: sessions_config.unwrap_or_default(),
             chain_id,
             block_import: block_import.unwrap_or_else(|| Box::<ProofOfStakeBlockImport>::default()),

crates/net/network/src/config.rs

@@ -126,6 +126,11 @@ impl<N: NetworkPrimitives> StateFetcher<N> {
         false
     }
 
+    /// Gets the peer's best block number
+    pub(crate) fn get_peer_best_number(&self, peer_id: &PeerId) -> Option<u64> {
+        self.peers.get(peer_id).map(|peer| peer.best_number)
+    }
+
     /// Invoked when an active session is about to be disconnected.
     pub(crate) fn on_pending_disconnect(&mut self, peer_id: &PeerId) {
         if let Some(peer) = self.peers.get_mut(peer_id) {

crates/net/network/src/fetch/mod.rs

@@ -605,7 +605,17 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
             }
             PeerMessage::NewBlock(block) => {
                 self.within_pow_or_disconnect(peer_id, move |this| {
-                    this.swarm.state_mut().on_new_block(peer_id, block.hash);
+                    // Extract TD from the NewBlock message
+                    let td = block.td();
+
+                    // Update the session's current TD (important for BSC and other chains)
+                    if let Some(session) = this.swarm.sessions().active_sessions().get(&peer_id) {
+                        session.update_td(td);
+                    }
+
+                    // Update NetworkState's ActivePeer TD
+                    this.swarm.state_mut().on_new_block_with_td(peer_id, block.hash, td);
+
                     // start block import process
                     this.block_import.on_new_block(peer_id, NewBlockEvent::Block(block));
                 });
@@ -641,13 +651,15 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
             NetworkHandleMessage::DiscoveryListener(tx) => {
                 self.swarm.state_mut().discovery_mut().add_listener(tx);
             }
-            NetworkHandleMessage::AnnounceBlock(block, hash) => {
+            NetworkHandleMessage::AnnounceBlock(block, hash, total_difficulty) => {
                 if self.handle.mode().is_stake() {
                     // See [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675#devp2p)
                     warn!(target: "net", "Peer performed block propagation, but it is not supported in proof of stake (EIP-3675)");
-                    return
+                    return;
                 }
-                let msg = NewBlockMessage { hash, block: Arc::new(block) };
+                // Include the total_difficulty when announcing our own block
+                // This is essential for BSC and other chains that rely on TD
+                let msg = NewBlockMessage { hash, block: Arc::new(block), td: total_difficulty };
                 self.swarm.state_mut().announce_new_block(msg);
             }
             NetworkHandleMessage::EthRequest { peer_id, request } => {
@@ -989,11 +1001,20 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
             .active_sessions()
             .iter()
             .filter_map(|(&peer_id, session)| {
-                self.swarm
-                    .state()
-                    .peers()
-                    .peer_by_id(peer_id)
-                    .map(|(record, kind)| session.peer_info(&record, kind))
+                let (record, kind) = self.swarm.state().peers().peer_by_id(peer_id)?;
+
+                // Get real-time block info from NetworkState
+                let (best_hash, best_number, best_td) =
+                    self.swarm.state().get_peer_best_block(&peer_id).unwrap_or_else(|| {
+                        // Fallback to status from handshake if no real-time data
+                        (
+                            session.status.blockhash,
+                            session.status.latest_block,
+                            session.status.total_difficulty,
+                        )
+                    });
+
+                Some(session.peer_info(&record, kind, best_hash, best_number, best_td))
             })
             .collect()
     }
@@ -1002,13 +1023,21 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
     ///
     /// Returns `None` if there's no active session to the peer.
     fn get_peer_info_by_id(&self, peer_id: PeerId) -> Option<PeerInfo> {
-        self.swarm.sessions().active_sessions().get(&peer_id).and_then(|session| {
-            self.swarm
-                .state()
-                .peers()
-                .peer_by_id(peer_id)
-                .map(|(record, kind)| session.peer_info(&record, kind))
-        })
+        let session = self.swarm.sessions().active_sessions().get(&peer_id)?;
+        let (record, kind) = self.swarm.state().peers().peer_by_id(peer_id)?;
+
+        // Get real-time block info from NetworkState
+        let (best_hash, best_number, best_td) =
+            self.swarm.state().get_peer_best_block(&peer_id).unwrap_or_else(|| {
+                // Fallback to status from handshake if no real-time data
+                (
+                    session.status.blockhash,
+                    session.status.latest_block,
+                    session.status.total_difficulty,
+                )
+            });
+
+        Some(session.peer_info(&record, kind, best_hash, best_number, best_td))
     }
 
     /// Returns [`PeerInfo`] for a given peers.
@@ -1142,7 +1171,7 @@ impl<N: NetworkPrimitives> Future for NetworkManager<N> {
         if maybe_more_handle_messages || maybe_more_swarm_events {
             // make sure we're woken up again
             cx.waker().wake_by_ref();
-            return Poll::Pending
+            return Poll::Pending;
         }
 
         this.update_poll_metrics(start, poll_durations);

crates/net/network/src/manager.rs

@@ -30,6 +30,8 @@ pub struct NewBlockMessage<P = NewBlock<reth_ethereum_primitives::Block>> {
     pub hash: B256,
     /// Raw received message
     pub block: Arc<P>,
+    /// Total difficulty (extracted from the NewBlock message for BSC and other chains)
+    pub td: Option<alloy_primitives::U256>,
 }
 
 // === impl NewBlockMessage ===
@@ -39,6 +41,11 @@ impl<P: NewBlockPayload> NewBlockMessage<P> {
     pub fn number(&self) -> u64 {
         self.block.block().header().number()
     }
+
+    /// Returns the total difficulty if available
+    pub fn td(&self) -> Option<alloy_primitives::U256> {
+        self.td
+    }
 }
 
 /// All Bi-directional eth-message variants that can be sent to a session or received from a

crates/net/network/src/message.rs

@@ -116,8 +116,15 @@ impl<N: NetworkPrimitives> NetworkHandle<N> {
     /// Caution: in `PoS` this is a noop because new blocks are no longer announced over devp2p.
     /// Instead they are sent to the node by CL and can be requested over devp2p.
     /// Broadcasting new blocks is considered a protocol violation.
-    pub fn announce_block(&self, block: N::NewBlockPayload, hash: B256) {
-        self.send_message(NetworkHandleMessage::AnnounceBlock(block, hash))
+    ///
+    /// For BSC and other PoW-based chains, the total_difficulty parameter is essential.
+    pub fn announce_block(
+        &self,
+        block: N::NewBlockPayload,
+        hash: B256,
+        total_difficulty: Option<alloy_primitives::U256>,
+    ) {
+        self.send_message(NetworkHandleMessage::AnnounceBlock(block, hash, total_difficulty))
     }
 
     /// Sends a [`PeerRequest`] to the given peer's session.
@@ -395,7 +402,7 @@ impl<N: NetworkPrimitives> SyncStateProvider for NetworkHandle<N> {
     // used to guard the txpool
     fn is_initially_syncing(&self) -> bool {
         if self.inner.initial_sync_done.load(Ordering::Relaxed) {
-            return false
+            return false;
         }
         self.inner.is_syncing.load(Ordering::Relaxed)
     }
@@ -484,7 +491,7 @@ pub(crate) enum NetworkHandleMessage<N: NetworkPrimitives = EthNetworkPrimitives
     /// Disconnects a connection to a peer if it exists, optionally providing a disconnect reason.
     DisconnectPeer(PeerId, Option<DisconnectReason>),
     /// Broadcasts an event to announce a new block to all nodes.
-    AnnounceBlock(N::NewBlockPayload, B256),
+    AnnounceBlock(N::NewBlockPayload, B256, Option<alloy_primitives::U256>),
     /// Sends a list of transactions to the given peer.
     SendTransaction {
         /// The ID of the peer to which the transactions are sent.