remove nat module and use libp2p upnp

Cargo.toml

@@ -94,6 +94,7 @@ resolver = "2"
 edition = "2021"
 
 [workspace.dependencies]
+anyhow = "1"
 arbitrary = { version = "1", features = ["derive"] }
 bincode = "1"
 bitvec = "1"

beacon_node/lighthouse_network/Cargo.toml

@@ -64,7 +64,7 @@ quick-protobuf-codec = "0.3"
 [dependencies.libp2p]
 version = "0.53"
 default-features = false
-features = ["identify", "yamux", "noise", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa", "metrics", "quic"]
+features = ["identify", "yamux", "noise", "gossipsub", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa", "metrics", "quic", "upnp"]
 
 [dev-dependencies]
 slog-term = { workspace = true }

beacon_node/lighthouse_network/src/service/behaviour.rs

@@ -6,6 +6,7 @@ use crate::types::SnappyTransform;
 use crate::gossipsub;
 use libp2p::identify;
 use libp2p::swarm::NetworkBehaviour;
+use libp2p::upnp::tokio::Behaviour as Upnp;
 use types::EthSpec;
 
 use super::api_types::RequestId;
@@ -32,6 +33,8 @@ where
     // NOTE: The id protocol is used for initial interop. This will be removed by mainnet.
     /// Provides IP addresses and peer information.
     pub identify: identify::Behaviour,
+    /// Libp2p UPnP port mapping.
+    pub upnp: Upnp,
     /// The routing pub-sub mechanism for eth2.
     pub gossipsub: Gossipsub,
 }

beacon_node/lighthouse_network/src/service/mod.rs

@@ -28,10 +28,9 @@ use crate::{error, metrics, Enr, NetworkGlobals, PubsubMessage, TopicHash};
 use api_types::{PeerRequestId, Request, RequestId, Response};
 use futures::stream::StreamExt;
 use gossipsub_scoring_parameters::{lighthouse_gossip_thresholds, PeerScoreSettings};
-use libp2p::multiaddr::{Multiaddr, Protocol as MProtocol};
+use libp2p::multiaddr::{self, Multiaddr, Protocol as MProtocol};
 use libp2p::swarm::{Swarm, SwarmEvent};
-use libp2p::PeerId;
-use libp2p::{identify, SwarmBuilder};
+use libp2p::{identify, PeerId, SwarmBuilder};
 use slog::{crit, debug, info, o, trace, warn};
 use std::path::PathBuf;
 use std::pin::Pin;
@@ -363,6 +362,7 @@ impl<AppReqId: ReqId, TSpec: EthSpec> Network<AppReqId, TSpec> {
                 identify,
                 peer_manager,
                 connection_limits,
+                upnp: Default::default(),
             }
         };
 
@@ -1584,6 +1584,47 @@ impl<AppReqId: ReqId, TSpec: EthSpec> Network<AppReqId, TSpec> {
         }
     }
 
+    fn inject_upnp_event(&mut self, event: libp2p::upnp::Event) {
+        match event {
+            libp2p::upnp::Event::NewExternalAddr(addr) => {
+                info!(self.log, "UPnP route established"; "addr" => %addr);
+                let mut iter = addr.iter();
+                // Skip Ip address.
+                iter.next();
+                match iter.next() {
+                    Some(multiaddr::Protocol::Udp(udp_port)) => match iter.next() {
+                        Some(multiaddr::Protocol::QuicV1) => {
+                            if let Err(e) = self.discovery_mut().update_enr_quic_port(udp_port) {
+                                warn!(self.log, "Failed to update ENR"; "error" => e);
+                            }
+                        }
+                        _ => {
+                            trace!(self.log, "UPnP address mapped multiaddr from unknown transport"; "addr" => %addr)
+                        }
+                    },
+                    Some(multiaddr::Protocol::Tcp(tcp_port)) => {
+                        if let Err(e) = self.discovery_mut().update_enr_tcp_port(tcp_port) {
+                            warn!(self.log, "Failed to update ENR"; "error" => e);
+                        }
+                    }
+                    _ => {
+                        trace!(self.log, "UPnP address mapped multiaddr from unknown transport"; "addr" => %addr);
+                    }
+                }
+            }
+            libp2p::upnp::Event::ExpiredExternalAddr(_) => {}
+            libp2p::upnp::Event::GatewayNotFound => {
+                info!(self.log, "UPnP not available");
+            }
+            libp2p::upnp::Event::NonRoutableGateway => {
+                info!(
+                    self.log,
+                    "UPnP is available but gateway is not exposed to public network"
+                );
+            }
+        }
+    }
+
     /* Networking polling */
 
     /// Poll the p2p networking stack.
@@ -1606,6 +1647,10 @@ impl<AppReqId: ReqId, TSpec: EthSpec> Network<AppReqId, TSpec> {
                     }
                     BehaviourEvent::Identify(ie) => self.inject_identify_event(ie),
                     BehaviourEvent::PeerManager(pe) => self.inject_pm_event(pe),
+                    BehaviourEvent::Upnp(e) => {
+                        self.inject_upnp_event(e);
+                        None
+                    }
                     BehaviourEvent::ConnectionLimits(le) => void::unreachable(le),
                 },
                 SwarmEvent::ConnectionEstablished { .. } => None,

beacon_node/lighthouse_network/src/service/utils.rs

@@ -8,7 +8,6 @@ use crate::{GossipTopic, NetworkConfig};
 use futures::future::Either;
 use libp2p::core::{multiaddr::Multiaddr, muxing::StreamMuxerBox, transport::Boxed};
 use libp2p::identity::{secp256k1, Keypair};
-use libp2p::quic;
 use libp2p::{core, noise, yamux, PeerId, Transport};
 use prometheus_client::registry::Registry;
 use slog::{debug, warn};
@@ -63,8 +62,8 @@ pub fn build_transport(
     let transport = if quic_support {
         // Enables Quic
         // The default quic configuration suits us for now.
-        let quic_config = quic::Config::new(&local_private_key);
-        let quic = quic::tokio::Transport::new(quic_config);
+        let quic_config = libp2p::quic::Config::new(&local_private_key);
+        let quic = libp2p::quic::tokio::Transport::new(quic_config);
         let transport = tcp
             .or_transport(quic)
             .map(|either_output, _| match either_output {

beacon_node/network/Cargo.toml

@@ -14,6 +14,7 @@ slog-async = { workspace = true }
 eth2 = { workspace = true }
 
 [dependencies]
+anyhow = { workspace = true }
 beacon_chain = { workspace = true }
 store = { workspace = true }
 lighthouse_network = { workspace = true }
@@ -35,11 +36,10 @@ lazy_static = { workspace = true }
 lighthouse_metrics = { workspace = true }
 logging = { workspace = true }
 task_executor = { workspace = true }
-igd-next = "0.14.3"
+igd-next = "0.14"
 itertools = { workspace = true }
 num_cpus = { workspace = true }
 lru_cache = { workspace = true }
-if-addrs = "0.6.4"
 lru = { workspace = true }
 strum = { workspace = true }
 tokio-util = { workspace = true }
@@ -56,4 +56,4 @@ environment = { workspace = true }
 # NOTE: This can be run via cargo build --bin lighthouse --features network/disable-backfill
 disable-backfill = []
 fork_from_env = ["beacon_chain/fork_from_env"]
-portable = ["beacon_chain/portable"]
+portable = ["beacon_chain/portable"]