[Merged by Bors] - Add Experimental QUIC support

beacon_node/lighthouse_network/Cargo.toml

@@ -44,11 +44,12 @@ prometheus-client = "0.21.0"
 unused_port = { path = "../../common/unused_port" }
 delay_map = "0.3.0"
 void = "1"
+libp2p-quic= { version = "0.9.0-alpha", features=["tokio"]}
 
 [dependencies.libp2p]
 version = "0.52"
 default-features = false
-features = ["websocket", "identify", "yamux", "noise", "gossipsub", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa"]
+features = ["identify", "yamux", "noise", "gossipsub", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa"]
 
 [dev-dependencies]
 slog-term = "2.6.0"

beacon_node/lighthouse_network/src/config.rs

@@ -58,9 +58,12 @@ pub struct Config {
     /// that no discovery address has been set in the CLI args.
     pub enr_address: (Option<Ipv4Addr>, Option<Ipv6Addr>),
 
-    /// The udp4 port to broadcast to peers in order to reach back for discovery.
+    /// The udp port to broadcast to peers in order to reach back for discovery.
     pub enr_udp4_port: Option<u16>,
 
+    /// The UDP port to broadcast to peers in order to reach back for quic libp2p services.
+    pub enr_quic4_port: Option<u16>,
+
     /// The tcp4 port to broadcast to peers in order to reach back for libp2p services.
     pub enr_tcp4_port: Option<u16>,
 
@@ -70,6 +73,9 @@ pub struct Config {
     /// The tcp6 port to broadcast to peers in order to reach back for libp2p services.
     pub enr_tcp6_port: Option<u16>,
 
+    /// The UDP port to broadcast to peers in order to reach back for quic libp2p services.
+    pub enr_quic6_port: Option<u16>,
+
     /// Target number of connected peers.
     pub target_peers: usize,
 
@@ -102,6 +108,9 @@ pub struct Config {
     /// Disables the discovery protocol from starting.
     pub disable_discovery: bool,
 
+    /// Disables quic support.
+    pub disable_quic_support: bool,
+
     /// Attempt to construct external port mappings with UPnP.
     pub upnp_enabled: bool,
 
@@ -149,57 +158,76 @@ impl Config {
     /// Sets the listening address to use an ipv4 address. The discv5 ip_mode and table filter are
     /// adjusted accordingly to ensure addresses that are present in the enr are globally
     /// reachable.
-    pub fn set_ipv4_listening_address(&mut self, addr: Ipv4Addr, tcp_port: u16, udp_port: u16) {
+    pub fn set_ipv4_listening_address(
+        &mut self,
+        addr: Ipv4Addr,
+        tcp_port: u16,
+        disc_port: u16,
+        quic_port: u16,
+    ) {
         self.listen_addresses = ListenAddress::V4(ListenAddr {
             addr,
-            udp_port,
+            disc_port,
+            quic_port,
             tcp_port,
         });
-        self.discv5_config.listen_config = discv5::ListenConfig::from_ip(addr.into(), udp_port);
+        self.discv5_config.listen_config = discv5::ListenConfig::from_ip(addr.into(), disc_port);
         self.discv5_config.table_filter = |enr| enr.ip4().as_ref().map_or(false, is_global_ipv4)
     }
 
     /// Sets the listening address to use an ipv6 address. The discv5 ip_mode and table filter is
     /// adjusted accordingly to ensure addresses that are present in the enr are globally
     /// reachable.
-    pub fn set_ipv6_listening_address(&mut self, addr: Ipv6Addr, tcp_port: u16, udp_port: u16) {
+    pub fn set_ipv6_listening_address(
+        &mut self,
+        addr: Ipv6Addr,
+        tcp_port: u16,
+        disc_port: u16,
+        quic_port: u16,
+    ) {
         self.listen_addresses = ListenAddress::V6(ListenAddr {
             addr,
-            udp_port,
+            disc_port,
+            quic_port,
             tcp_port,
         });
 
-        self.discv5_config.listen_config = discv5::ListenConfig::from_ip(addr.into(), udp_port);
+        self.discv5_config.listen_config = discv5::ListenConfig::from_ip(addr.into(), disc_port);
         self.discv5_config.table_filter = |enr| enr.ip6().as_ref().map_or(false, is_global_ipv6)
     }
 
     /// Sets the listening address to use both an ipv4 and ipv6 address. The discv5 ip_mode and
     /// table filter is adjusted accordingly to ensure addresses that are present in the enr are
     /// globally reachable.
+    #[allow(clippy::too_many_arguments)]
     pub fn set_ipv4_ipv6_listening_addresses(
         &mut self,
         v4_addr: Ipv4Addr,
         tcp4_port: u16,
-        udp4_port: u16,
+        disc4_port: u16,
+        quic4_port: u16,
         v6_addr: Ipv6Addr,
         tcp6_port: u16,
-        udp6_port: u16,
+        disc6_port: u16,
+        quic6_port: u16,
     ) {
         self.listen_addresses = ListenAddress::DualStack(
             ListenAddr {
                 addr: v4_addr,
-                udp_port: udp4_port,
+                disc_port: disc4_port,
+                quic_port: quic4_port,
                 tcp_port: tcp4_port,
             },
             ListenAddr {
                 addr: v6_addr,
-                udp_port: udp6_port,
+                disc_port: disc6_port,
+                quic_port: quic6_port,
                 tcp_port: tcp6_port,
             },
         );
         self.discv5_config.listen_config = discv5::ListenConfig::default()
-            .with_ipv4(v4_addr, udp4_port)
-            .with_ipv6(v6_addr, udp6_port);
+            .with_ipv4(v4_addr, disc4_port)
+            .with_ipv6(v6_addr, disc6_port);
 
         self.discv5_config.table_filter = |enr| match (&enr.ip4(), &enr.ip6()) {
             (None, None) => false,
@@ -213,27 +241,32 @@ impl Config {
         match listen_addr {
             ListenAddress::V4(ListenAddr {
                 addr,
-                udp_port,
+                disc_port,
+                quic_port,
                 tcp_port,
-            }) => self.set_ipv4_listening_address(addr, tcp_port, udp_port),
+            }) => self.set_ipv4_listening_address(addr, tcp_port, disc_port, quic_port),
             ListenAddress::V6(ListenAddr {
                 addr,
-                udp_port,
+                disc_port,
+                quic_port,
                 tcp_port,
-            }) => self.set_ipv6_listening_address(addr, tcp_port, udp_port),
+            }) => self.set_ipv6_listening_address(addr, tcp_port, disc_port, quic_port),
             ListenAddress::DualStack(
                 ListenAddr {
                     addr: ip4addr,
-                    udp_port: udp4_port,
+                    disc_port: disc4_port,
+                    quic_port: quic4_port,
                     tcp_port: tcp4_port,
                 },
                 ListenAddr {
                     addr: ip6addr,
-                    udp_port: udp6_port,
+                    disc_port: disc6_port,
+                    quic_port: quic6_port,
                     tcp_port: tcp6_port,
                 },
             ) => self.set_ipv4_ipv6_listening_addresses(
-                ip4addr, tcp4_port, udp4_port, ip6addr, tcp6_port, udp6_port,
+                ip4addr, tcp4_port, disc4_port, quic4_port, ip6addr, tcp6_port, disc6_port,
+                quic6_port,
             ),
         }
     }
@@ -272,7 +305,8 @@ impl Default for Config {
         );
         let listen_addresses = ListenAddress::V4(ListenAddr {
             addr: Ipv4Addr::UNSPECIFIED,
-            udp_port: 9000,
+            disc_port: 9000,
+            quic_port: 9001,
             tcp_port: 9000,
         });
 
@@ -305,10 +339,11 @@ impl Default for Config {
             network_dir,
             listen_addresses,
             enr_address: (None, None),
-
             enr_udp4_port: None,
+            enr_quic4_port: None,
             enr_tcp4_port: None,
             enr_udp6_port: None,
+            enr_quic6_port: None,
             enr_tcp6_port: None,
             target_peers: 50,
             gs_config,
@@ -320,6 +355,7 @@ impl Default for Config {
             disable_peer_scoring: false,
             client_version: lighthouse_version::version_with_platform(),
             disable_discovery: false,
+            disable_quic_support: false,
             upnp_enabled: true,
             network_load: 3,
             private: false,

beacon_node/lighthouse_network/src/discovery/enr.rs

@@ -17,6 +17,8 @@ use std::path::Path;
 use std::str::FromStr;
 use types::{EnrForkId, EthSpec};
 
+use super::enr_ext::{EnrExt, QUIC6_ENR_KEY, QUIC_ENR_KEY};
+
 /// The ENR field specifying the fork id.
 pub const ETH2_ENR_KEY: &str = "eth2";
 /// The ENR field specifying the attestation subnet bitfield.
@@ -142,7 +144,7 @@ pub fn build_or_load_enr<T: EthSpec>(
 
 pub fn create_enr_builder_from_config<T: EnrKey>(
     config: &NetworkConfig,
-    enable_tcp: bool,
+    enable_libp2p: bool,
 ) -> EnrBuilder<T> {
     let mut builder = EnrBuilder::new("v4");
     let (maybe_ipv4_address, maybe_ipv6_address) = &config.enr_address;
@@ -163,7 +165,27 @@ pub fn create_enr_builder_from_config<T: EnrKey>(
         builder.udp6(udp6_port);
     }
 
-    if enable_tcp {
+    // Add QUIC fields to the ENR.
+    // If `enable_libp2p` is disabled, then we should not support QUIC in the ENR either.
+    if enable_libp2p && !config.disable_quic_support {
+        // If we are listening on ipv4, add the quic ipv4 port
+        if let Some(quic4_port) = config
+            .enr_quic4_port
+            .or_else(|| config.listen_addrs().v4().map(|v4_addr| v4_addr.quic_port))
+        {
+            builder.add_value(QUIC_ENR_KEY, &quic4_port);
+        }
+
+        // If we are listening on ipv6, add the quic ipv6 port
+        if let Some(quic6_port) = config
+            .enr_quic6_port
+            .or_else(|| config.listen_addrs().v6().map(|v6_addr| v6_addr.quic_port))
+        {
+            builder.add_value(QUIC6_ENR_KEY, &quic6_port);
+        }
+    }
+
+    if enable_libp2p {
         // If the ENR port is not set, and we are listening over that ip version, use the listening port instead.
         let tcp4_port = config
             .enr_tcp4_port
@@ -218,6 +240,9 @@ fn compare_enr(local_enr: &Enr, disk_enr: &Enr) -> bool {
         // tcp ports must match
         && local_enr.tcp4() == disk_enr.tcp4()
         && local_enr.tcp6() == disk_enr.tcp6()
+        // quic ports must match
+        && local_enr.quic() == disk_enr.quic()
+        && local_enr.quic6() == disk_enr.quic6()
         // must match on the same fork
         && local_enr.get(ETH2_ENR_KEY) == disk_enr.get(ETH2_ENR_KEY)
         // take preference over disk udp port if one is not specified

beacon_node/lighthouse_network/src/discovery/enr_ext.rs

@@ -6,12 +6,15 @@ use libp2p::core::multiaddr::Protocol;
 use libp2p::identity::{ed25519, secp256k1, KeyType, Keypair, PublicKey};
 use tiny_keccak::{Hasher, Keccak};
 
+pub const QUIC_ENR_KEY: &str = "quic";
+pub const QUIC6_ENR_KEY: &str = "quic6";
+
 /// Extend ENR for libp2p types.
 pub trait EnrExt {
     /// The libp2p `PeerId` for the record.
     fn peer_id(&self) -> PeerId;
 
-    /// Returns a list of multiaddrs if the ENR has an `ip` and either a `tcp` or `udp` key **or** an `ip6` and either a `tcp6` or `udp6`.
+    /// Returns a list of multiaddrs if the ENR has an `ip` and one of [`tcp`,`udp`,`quic`] key **or** an `ip6` and one of [`tcp6`,`udp6`,`quic6`].
     /// The vector remains empty if these fields are not defined.
     fn multiaddr(&self) -> Vec<Multiaddr>;
 
@@ -26,6 +29,15 @@ pub trait EnrExt {
 
     /// Returns any multiaddrs that contain the TCP protocol.
     fn multiaddr_tcp(&self) -> Vec<Multiaddr>;
+
+    /// Returns any QUIC multiaddrs that are registered in this ENR.
+    fn multiaddr_quic(&self) -> Vec<Multiaddr>;
+
+    /// Returns the quic port if one is set.
+    fn quic(&self) -> Option<u16>;
+
+    /// Returns the quic6 port if one is set.
+    fn quic6(&self) -> Option<u16>;
 }
 
 /// Extend ENR CombinedPublicKey for libp2p types.
@@ -49,6 +61,16 @@ impl EnrExt for Enr {
         self.public_key().as_peer_id()
     }
 
+    /// Returns the quic port if one is set.
+    fn quic(&self) -> Option<u16> {
+        self.get_decodable(QUIC_ENR_KEY).and_then(Result::ok)
+    }
+
+    /// Returns the quic6 port if one is set.
+    fn quic6(&self) -> Option<u16> {
+        self.get_decodable(QUIC6_ENR_KEY).and_then(Result::ok)
+    }
+
     /// Returns a list of multiaddrs if the ENR has an `ip` and either a `tcp` or `udp` key **or** an `ip6` and either a `tcp6` or `udp6`.
     /// The vector remains empty if these fields are not defined.
     fn multiaddr(&self) -> Vec<Multiaddr> {
@@ -59,6 +81,12 @@ impl EnrExt for Enr {
                 multiaddr.push(Protocol::Udp(udp));
                 multiaddrs.push(multiaddr);
             }
+            if let Some(quic) = self.quic() {
+                let mut multiaddr: Multiaddr = ip.into();
+                multiaddr.push(Protocol::Udp(quic));
+                multiaddr.push(Protocol::QuicV1);
+                multiaddrs.push(multiaddr);
+            }
 
             if let Some(tcp) = self.tcp4() {
                 let mut multiaddr: Multiaddr = ip.into();
@@ -73,6 +101,13 @@ impl EnrExt for Enr {
                 multiaddrs.push(multiaddr);
             }
 
+            if let Some(quic6) = self.quic6() {
+                let mut multiaddr: Multiaddr = ip6.into();
+                multiaddr.push(Protocol::Udp(quic6));
+                multiaddr.push(Protocol::QuicV1);
+                multiaddrs.push(multiaddr);
+            }
+
             if let Some(tcp6) = self.tcp6() {
                 let mut multiaddr: Multiaddr = ip6.into();
                 multiaddr.push(Protocol::Tcp(tcp6));
@@ -174,6 +209,31 @@ impl EnrExt for Enr {
         multiaddrs
     }
 
+    /// Returns a list of multiaddrs if the ENR has an `ip` and a `quic` key **or** an `ip6` and a `quic6`.
+    /// The vector remains empty if these fields are not defined.
+    fn multiaddr_quic(&self) -> Vec<Multiaddr> {
+        let mut multiaddrs: Vec<Multiaddr> = Vec::new();
+        // Check for quic first as it is less likely
+        if let Some(quic_port) = self.quic() {
+            if let Some(ip) = self.ip4() {
+                let mut multiaddr: Multiaddr = ip.into();
+                multiaddr.push(Protocol::Udp(quic_port));
+                multiaddr.push(Protocol::QuicV1);
+                multiaddrs.push(multiaddr);
+            }
+        }
+
+        if let Some(quic6_port) = self.quic6() {
+            if let Some(ip6) = self.ip6() {
+                let mut multiaddr: Multiaddr = ip6.into();
+                multiaddr.push(Protocol::Udp(quic6_port));
+                multiaddr.push(Protocol::QuicV1);
+                multiaddrs.push(multiaddr);
+            }
+        }
+        multiaddrs
+    }
+
     /// Returns a list of multiaddrs if the ENR has an `ip` and either a `tcp` or `udp` key **or** an `ip6` and either a `tcp6` or `udp6`.
     /// The vector remains empty if these fields are not defined.
     fn multiaddr_tcp(&self) -> Vec<Multiaddr> {