node/log_entry_sync/src/sync_manager/log_entry_fetcher.rs

@@ -662,7 +662,6 @@ async fn check_watch_process(
                     "get block hash for block {} from RPC, assume there is no org",
                     *progress - 1
                 );
-                let hash = loop {
                 match provider.get_block(*progress - 1).await {
                     Ok(Some(v)) => {
                         break v.hash.expect("parent block hash expect exist");
@@ -671,17 +670,11 @@ async fn check_watch_process(
                         panic!("parent block {} expect exist", *progress - 1);
                     }
                     Err(e) => {
-                            if e.to_string().contains("server is too busy") {
-                                warn!("server busy, wait for parent block {}", *progress - 1);
-                            } else {
                         panic!("parent block {} expect exist, error {}", *progress - 1, e);
                     }
                 }
             }
         };
-                break hash;
-            }
-        };
     }
 
     progress_reset_history.retain(|k, _| k + 1000 >= *progress);

node/router/src/lib.rs

@@ -10,7 +10,7 @@ mod service;
 use duration_str::deserialize_duration;
 use network::Multiaddr;
 use serde::Deserialize;
-use std::{net::IpAddr, time::Duration};
+use std::time::Duration;
 
 pub use crate::service::RouterService;
 
@@ -26,7 +26,6 @@ pub struct Config {
     pub libp2p_nodes: Vec<Multiaddr>,
     pub private_ip_enabled: bool,
     pub check_announced_ip: bool,
-    pub public_address: Option<IpAddr>,
 
     // batcher
     /// Timeout to publish messages in batch
@@ -48,7 +47,6 @@ impl Default for Config {
             libp2p_nodes: vec![],
             private_ip_enabled: false,
             check_announced_ip: false,
-            public_address: None,
 
             batcher_timeout: Duration::from_secs(1),
             batcher_file_capacity: 1,

node/router/src/libp2p_event_handler.rs

@@ -348,26 +348,17 @@ impl Libp2pEventHandler {
         }
     }
 
-    async fn construct_announced_ip(&self) -> Option<Multiaddr> {
+    async fn get_listen_addr_or_add(&self) -> Option<Multiaddr> {
-        // public address configured
-        if let Some(ip) = self.config.public_address {
-            let mut addr = Multiaddr::empty();
-            addr.push(ip.into());
-            addr.push(Protocol::Tcp(self.network_globals.listen_port_tcp()));
-            return Some(addr);
-        }
-
-        // public listen address
         if let Some(addr) = self.get_listen_addr() {
             return Some(addr);
         }
 
-        // auto detect public IP address
         let ipv4_addr = public_ip::addr_v4().await?;
 
         let mut addr = Multiaddr::empty();
         addr.push(Protocol::Ip4(ipv4_addr));
         addr.push(Protocol::Tcp(self.network_globals.listen_port_tcp()));
+        addr.push(Protocol::P2p(self.network_globals.local_peer_id().into()));
 
         self.network_globals
             .listen_multiaddrs
@@ -429,7 +420,7 @@ impl Libp2pEventHandler {
 
         let peer_id = *self.network_globals.peer_id.read();
 
-        let addr = self.construct_announced_ip().await?;
+        let addr = self.get_listen_addr_or_add().await?;
 
         let timestamp = timestamp_now();
         let shard_config = self.store.get_store().get_shard_config();
@@ -461,7 +452,7 @@ impl Libp2pEventHandler {
         shard_config: ShardConfig,
     ) -> Option<PubsubMessage> {
         let peer_id = *self.network_globals.peer_id.read();
-        let addr = self.construct_announced_ip().await?;
+        let addr = self.get_listen_addr_or_add().await?;
         let timestamp = timestamp_now();
 
         let msg = AnnounceShardConfig {
@@ -537,7 +528,7 @@ impl Libp2pEventHandler {
         index_end: u64,
     ) -> Option<PubsubMessage> {
         let peer_id = *self.network_globals.peer_id.read();
-        let addr = self.construct_announced_ip().await?;
+        let addr = self.get_listen_addr_or_add().await?;
         let timestamp = timestamp_now();
 
         let msg = AnnounceChunks {

node/src/config/convert.rs

@@ -200,13 +200,6 @@ impl ZgsConfig {
     pub fn router_config(&self, network_config: &NetworkConfig) -> Result<router::Config, String> {
         let mut router_config = self.router.clone();
         router_config.libp2p_nodes = network_config.libp2p_nodes.to_vec();
-
-        if router_config.public_address.is_none() {
-            if let Some(addr) = &self.network_enr_address {
-                router_config.public_address = Some(addr.parse().unwrap());
-            }
-        }
-
         Ok(router_config)
     }