feat(networking): Implement support for UPnP

anchor/client/src/cli.rs

@@ -281,6 +281,14 @@ pub struct Node {
     )]
     pub use_zero_ports: bool,
 
+    #[clap(
+        long,
+        help = "Disables UPnP support. Setting this will prevent Anchor \
+            from attempting to automatically establish external port mappings.",
+        default_value = "false"
+    )]
+    pub disable_upnp: bool,
+
     // Prometheus metrics HTTP server related arguments
     #[clap(
         long,

anchor/client/src/config.rs

@@ -183,6 +183,9 @@ pub fn from_cli(cli_args: &Node, global_config: GlobalConfig) -> Result<Config,
 
     config.network.subscribe_all_subnets = cli_args.subscribe_all_subnets;
 
+    // If the flag was set (true), it means we disable upnp so upnp_enabled should be false
+    config.network.upnp_enabled = !cli_args.disable_upnp;
+
     // Network related - set peer scoring configuration
     config.network.disable_gossipsub_peer_scoring = cli_args.disable_gossipsub_peer_scoring;
     config.network.disable_gossipsub_topic_scoring = cli_args.disable_gossipsub_topic_scoring;

anchor/network/Cargo.toml

@@ -24,6 +24,7 @@ libp2p = { workspace = true, default-features = false, features = [
   "quic",
   "ping",
   "request-response",
+  "upnp",
   "dns",
 ] }
 message_receiver = { workspace = true }

anchor/network/src/behaviour.rs

@@ -2,7 +2,11 @@ use std::time::Duration;
 
 use discv5::enr::k256::sha2::{Digest, Sha256};
 use gossipsub::{ConfigBuilderError, MessageAuthenticity, ValidationMode};
-use libp2p::{identify, ping, swarm::NetworkBehaviour};
+use libp2p::{
+    identify, ping,
+    swarm::{NetworkBehaviour, behaviour::toggle::Toggle},
+    upnp::tokio::Behaviour as Upnp,
+};
 use prometheus_client::registry::Registry;
 use thiserror::Error;
 use types::{ChainSpec, EthSpec};
@@ -44,6 +48,8 @@ pub struct AnchorBehaviour {
     /// Anchor peer manager, wrapping libp2p behaviours with minimal added logic for peer
     /// selection.
     pub peer_manager: PeerManager,
+    /// Libp2p UPnP port mapping.
+    pub upnp: Toggle<Upnp>,
 
     pub handshake: handshake::Behaviour,
 }
@@ -136,13 +142,20 @@ impl AnchorBehaviour {
 
         let handshake = handshake::create_behaviour(local_keypair);
 
+        let upnp = Toggle::from(
+            network_config
+                .upnp_enabled
+                .then(libp2p::upnp::tokio::Behaviour::default),
+        );
+
         Ok(AnchorBehaviour {
             identify,
             ping: ping::Behaviour::default(),
             gossipsub,
             discovery,
             peer_manager,
             handshake,
+            upnp,
         })
     }
 }

anchor/network/src/config.rs

@@ -77,6 +77,9 @@ pub struct Config {
     /// Target number of connected peers.
     pub target_peers: usize,
 
+    /// Attempt to construct external port mappings with UPnP.
+    pub upnp_enabled: bool,
+
     pub domain_type: DomainType,
 }
 
@@ -109,6 +112,7 @@ impl Config {
             disable_quic_support: false,
             subscribe_all_subnets: false,
             domain_type: DomainType::default(),
+            upnp_enabled: true,
         }
     }
 }

anchor/network/src/network.rs

@@ -214,6 +214,44 @@ impl<R: MessageReceiver> Network<R> {
                                     self.handle_handshake_result(result);
                                 }
                             }
+                            AnchorBehaviourEvent::Upnp(upnp_event) => {
+                                match upnp_event {
+                                    libp2p::upnp::Event::NewExternalAddr(addr) => {
+                                        info!(%addr, "UPnP route established");
+                                        let mut iter = addr.iter();
+                                        let is_ipv6 = {
+                                            let addr = iter.next();
+                                            matches!(addr, Some(Protocol::Ip6(_)))
+                                        };
+                                        match iter.next() {
+                                            Some(Protocol::Udp(udp_port)) => match iter.next() {
+                                                Some(Protocol::QuicV1) => {
+                                                    if let Err(e) =
+                                                        self.discovery().try_update_port(false, is_ipv6, udp_port)
+                                                    {
+                                                        warn!(error = e, "Failed to update ENR");
+                                                    }
+                                                }
+                                                _ => {
+                                                    trace!(%addr, "UPnP address mapped multiaddr from unknown transport");
+                                                }
+                                            },
+                                            Some(Protocol::Tcp(tcp_port)) => {
+                                                if let Err(e) = self.discovery().try_update_port(true, is_ipv6, tcp_port) {
+                                                    warn!(error = e, "Failed to update ENR");
+                                                }
+                                            }
+                                            _ => {
+                                                trace!(%addr, "UPnP address mapped multiaddr from unknown transport");
+                                            }
+                                        }
+
+                                    },
+                                    libp2p::upnp::Event::ExpiredExternalAddr(_) => {},
+                                    libp2p::upnp::Event::GatewayNotFound => info!("UPnP not available."),
+                                    libp2p::upnp::Event::NonRoutableGateway => info!("UPnP is available but gateway is not exposed to public network"),
+                                }
+                            }
                             AnchorBehaviourEvent::PeerManager(peer_manager::Event::Heartbeat(heartbeat)) => {
                                 if let Some(actions) = heartbeat.connect_actions {
                                     self.handle_connect_actions(actions);