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

@@ -43,13 +43,14 @@ prometheus-client = "0.21.0"
 unused_port = { workspace = true }
 delay_map = { workspace = true }
 void = "1"
-libp2p-quic= { version = "0.9.2", features=["tokio"]}
+# TODO: remove when importable via libp2p main crate.
+libp2p-upnp = { version = "0.1.0", features = ["tokio"] }
 libp2p-mplex = "0.40.0"
 
 [dependencies.libp2p]
 version = "0.52"
 default-features = false
-features = ["identify", "yamux", "noise", "gossipsub", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa"]
+features = ["identify", "yamux", "noise", "gossipsub", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa", "quic"]
 
 [dev-dependencies]
 slog-term = { workspace = true }

beacon_node/lighthouse_network/src/service/behaviour.rs

@@ -6,6 +6,7 @@ use crate::types::SnappyTransform;
 use libp2p::gossipsub;
 use libp2p::identify;
 use libp2p::swarm::NetworkBehaviour;
+use libp2p_upnp::tokio::Behaviour as Upnp;
 use types::EthSpec;
 
 use super::api_types::RequestId;
@@ -34,4 +35,7 @@ where
     pub identify: identify::Behaviour,
     /// The peer manager that keeps track of peer's reputation and status.
     pub peer_manager: PeerManager<TSpec>,
+
+    /// Libp2p UPnP port mapping.
+    pub upnp: Upnp,
 }

beacon_node/lighthouse_network/src/service/mod.rs

@@ -29,10 +29,10 @@ use libp2p::gossipsub::{
     self, IdentTopic as Topic, MessageAcceptance, MessageAuthenticity, MessageId, PublishError,
     TopicScoreParams,
 };
-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 libp2p_upnp;
 use slog::{crit, debug, info, o, trace, warn};
 use std::path::PathBuf;
 use std::pin::Pin;
@@ -362,6 +362,7 @@ impl<AppReqId: ReqId, TSpec: EthSpec> Network<AppReqId, TSpec> {
                 identify,
                 peer_manager,
                 connection_limits,
+                upnp: Default::default(),
             }
         };
 
@@ -1516,6 +1517,47 @@ impl<AppReqId: ReqId, TSpec: EthSpec> Network<AppReqId, TSpec> {
         }
     }
 
+    fn parse_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.
@@ -1538,6 +1580,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.parse_upnp_event(e);
+                        None
+                    }
                     BehaviourEvent::ConnectionLimits(le) => void::unreachable(le),
                 },
                 SwarmEvent::ConnectionEstablished { .. } => None,

beacon_node/lighthouse_network/src/service/utils.rs

@@ -10,7 +10,6 @@ use libp2p::core::{multiaddr::Multiaddr, muxing::StreamMuxerBox, transport::Boxe
 use libp2p::gossipsub;
 use libp2p::identity::{secp256k1, Keypair};
 use libp2p::{core, noise, yamux, PeerId, Transport, TransportExt};
-use libp2p_quic;
 use prometheus_client::registry::Registry;
 use slog::{debug, warn};
 use ssz::Decode;
@@ -69,9 +68,9 @@ pub fn build_transport(
     let (transport, bandwidth) = if quic_support {
         // Enables Quic
         // The default quic configuration suits us for now.
-        let quic_config = libp2p_quic::Config::new(&local_private_key);
+        let quic_config = libp2p::quic::Config::new(&local_private_key);
         let (quic, quic_bandwidth) =
-            libp2p_quic::tokio::Transport::new(quic_config).with_bandwidth_logging();
+            libp2p::quic::tokio::Transport::new(quic_config).with_bandwidth_logging();
         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 = "0.12.1"
+igd-next = "0.14.2"
 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 }