refactor(p2p): remove fragile FromStr parsing for signaling types

Remove FromStr implementations for SignalingMethod and
HttpSignalingInfo that used fragile slash-delimited string
parsing. These are no longer reachable from user input after
the legacy address format removal, and were only used by
custom Serialize/Deserialize impls.

Switch to derived Serialize/Deserialize for SignalingMethod,
HttpSignalingInfo, PathPrefix, and ProxyScheme.

Author: iostat

crates/p2p/src/webrtc/mod.rs

@@ -18,9 +18,7 @@ pub use signal::{
 };
 
 mod signaling_method;
-pub use signaling_method::{
-    HttpSignalingInfo, PathPrefix, ProxyScheme, SignalingMethod, SignalingMethodParseError,
-};
+pub use signaling_method::{HttpSignalingInfo, PathPrefix, ProxyScheme, SignalingMethod};
 
 mod connection_auth;
 pub use connection_auth::{ConnectionAuth, ConnectionAuthEncrypted};

crates/p2p/src/webrtc/signaling_method/http.rs

@@ -30,15 +30,13 @@
 //! method variant. HTTPS is recommended for production environments to
 //! protect signaling data and prevent tampering during transmission.
 
-use std::{fmt, str::FromStr};
+use std::fmt;
 
 use binprot_derive::{BinProtRead, BinProtWrite};
 use serde::{Deserialize, Serialize};
 
 use crate::webrtc::Host;
 
-use super::SignalingMethodParseError;
-
 /// HTTP signaling server connection information.
 ///
 /// `HttpSignalingInfo` encapsulates the network location information needed
@@ -74,7 +72,9 @@ use super::SignalingMethodParseError;
 ///     port: 443,
 /// };
 /// ```
-#[derive(BinProtWrite, BinProtRead, Eq, PartialEq, Ord, PartialOrd, Debug, Clone)]
+#[derive(
+    BinProtWrite, BinProtRead, Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Serialize, Deserialize,
+)]
 pub struct HttpSignalingInfo {
     /// The host address for the HTTP signaling server.
     ///
@@ -129,276 +129,3 @@ impl From<([u8; 4], u16)> for HttpSignalingInfo {
         }
     }
 }
-
-impl FromStr for HttpSignalingInfo {
-    type Err = SignalingMethodParseError;
-
-    /// Parses a string representation into HTTP signaling info.
-    ///
-    /// This method parses path-like strings that contain host and port
-    /// information separated by forward slashes. The expected format is
-    /// `{host}/{port}` or `/{host}/{port}`.
-    ///
-    /// # Format
-    ///
-    /// - Input: `{host}/{port}` (leading slash optional)
-    /// - Host: Domain name, IPv4, IPv6, or multiaddr format
-    /// - Port: 16-bit unsigned integer (0-65535)
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use mina::signaling_method::HttpSignalingInfo;
-    ///
-    /// // Domain and port
-    /// let info: HttpSignalingInfo = "signal.example.com/443".parse()?;
-    ///
-    /// // IPv4 and port
-    /// let info: HttpSignalingInfo = "192.168.1.100/8080".parse()?;
-    ///
-    /// // With leading slash
-    /// let info: HttpSignalingInfo = "/localhost/8080".parse()?;
-    /// ```
-    ///
-    /// # Errors
-    ///
-    /// Returns [`SignalingMethodParseError`] for:
-    /// - Missing host or port components
-    /// - Invalid host format (not a valid hostname, IP, or multiaddr)
-    /// - Invalid port number (not a valid 16-bit unsigned integer)
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut iter = s.split('/').filter(|v| !v.trim().is_empty());
-        let host_str = iter
-            .next()
-            .ok_or(SignalingMethodParseError::NotEnoughArgs)?;
-        let host = Host::from_str(host_str)
-            .map_err(|err| SignalingMethodParseError::HostParseError(err.to_string()))?;
-
-        let port = iter
-            .next()
-            .ok_or(SignalingMethodParseError::NotEnoughArgs)?
-            .parse::<u16>()
-            .map_err(|err| SignalingMethodParseError::PortParseError(err.to_string()))?;
-
-        Ok(Self { host, port })
-    }
-}
-
-impl Serialize for HttpSignalingInfo {
-    /// Serializes the HTTP signaling info as a string.
-    ///
-    /// This uses the `Display` implementation to convert the signaling
-    /// info to its string representation for serialization. The output
-    /// format is `/{host}/{port}`.
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
-impl<'de> serde::Deserialize<'de> for HttpSignalingInfo {
-    /// Deserializes HTTP signaling info from a string.
-    ///
-    /// This uses the [`FromStr`] implementation to parse the string
-    /// representation back into an [`HttpSignalingInfo`] instance.
-    /// The expected format is `{host}/{port}` or `/{host}/{port}`.
-    ///
-    /// # Errors
-    ///
-    /// Returns a deserialization error if the string cannot be parsed
-    /// as valid HTTP signaling info (invalid host, port, or format).
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let s: String = Deserialize::deserialize(deserializer)?;
-        s.parse().map_err(serde::de::Error::custom)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    //! Unit tests for HttpSignalingInfo parsing
-    //!
-    //! Run these tests with:
-    //! ```bash
-    //! cargo test -p p2p signaling_method::http::tests
-    //! ```
-
-    use super::*;
-    use crate::webrtc::Host;
-    use std::net::Ipv4Addr;
-
-    #[test]
-    fn test_from_str_valid_domain_and_port() {
-        let info: HttpSignalingInfo = "example.com/8080".parse().unwrap();
-        assert_eq!(info.host, Host::Domain("example.com".to_string()));
-        assert_eq!(info.port, 8080);
-    }
-
-    #[test]
-    fn test_from_str_valid_domain_and_port_with_leading_slash() {
-        let info: HttpSignalingInfo = "/example.com/8080".parse().unwrap();
-        assert_eq!(info.host, Host::Domain("example.com".to_string()));
-        assert_eq!(info.port, 8080);
-    }
-
-    #[test]
-    fn test_from_str_valid_ipv4_and_port() {
-        let info: HttpSignalingInfo = "192.168.1.1/443".parse().unwrap();
-        assert_eq!(info.host, Host::Ipv4(Ipv4Addr::new(192, 168, 1, 1)));
-        assert_eq!(info.port, 443);
-    }
-
-    #[test]
-    fn test_from_str_valid_ipv6_and_port() {
-        let info: HttpSignalingInfo = "[::1]/8080".parse().unwrap();
-        assert!(matches!(info.host, Host::Ipv6(_)));
-        assert_eq!(info.port, 8080);
-    }
-
-    #[test]
-    fn test_from_str_valid_localhost_and_standard_ports() {
-        let info: HttpSignalingInfo = "localhost/80".parse().unwrap();
-        assert_eq!(info.host, Host::Domain("localhost".to_string()));
-        assert_eq!(info.port, 80);
-
-        let info: HttpSignalingInfo = "localhost/443".parse().unwrap();
-        assert_eq!(info.host, Host::Domain("localhost".to_string()));
-        assert_eq!(info.port, 443);
-    }
-
-    #[test]
-    fn test_from_str_valid_high_port_number() {
-        let info: HttpSignalingInfo = "example.com/65535".parse().unwrap();
-        assert_eq!(info.host, Host::Domain("example.com".to_string()));
-        assert_eq!(info.port, 65535);
-    }
-
-    #[test]
-    fn test_from_str_missing_host() {
-        let result: Result<HttpSignalingInfo, _> = "/8080".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::NotEnoughArgs
-        ));
-    }
-
-    #[test]
-    fn test_from_str_missing_port() {
-        let result: Result<HttpSignalingInfo, _> = "example.com".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::NotEnoughArgs
-        ));
-    }
-
-    #[test]
-    fn test_from_str_empty_string() {
-        let result: Result<HttpSignalingInfo, _> = "".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::NotEnoughArgs
-        ));
-    }
-
-    #[test]
-    fn test_from_str_only_slashes() {
-        let result: Result<HttpSignalingInfo, _> = "///".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::NotEnoughArgs
-        ));
-    }
-
-    #[test]
-    fn test_from_str_invalid_port_not_number() {
-        let result: Result<HttpSignalingInfo, _> = "example.com/abc".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::PortParseError(_)
-        ));
-    }
-
-    #[test]
-    fn test_from_str_invalid_port_too_large() {
-        let result: Result<HttpSignalingInfo, _> = "example.com/99999".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::PortParseError(_)
-        ));
-    }
-
-    #[test]
-    fn test_from_str_invalid_port_negative() {
-        let result: Result<HttpSignalingInfo, _> = "example.com/-1".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::PortParseError(_)
-        ));
-    }
-
-    #[test]
-    fn test_from_str_invalid_host_empty() {
-        let result: Result<HttpSignalingInfo, _> = "/8080".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::NotEnoughArgs
-        ));
-    }
-
-    #[test]
-    fn test_from_str_extra_components_ignored() {
-        // Should only use first two non-empty components
-        let info: HttpSignalingInfo = "example.com/8080/extra/stuff".parse().unwrap();
-        assert_eq!(info.host, Host::Domain("example.com".to_string()));
-        assert_eq!(info.port, 8080);
-    }
-
-    #[test]
-    fn test_from_str_whitespace_in_components() {
-        // Components with whitespace should be trimmed by the split filter
-        let result: Result<HttpSignalingInfo, _> = "   /  /8080".parse();
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            SignalingMethodParseError::NotEnoughArgs
-        ));
-    }
-
-    #[test]
-    fn test_roundtrip_display_and_from_str() {
-        let original = HttpSignalingInfo {
-            host: Host::Domain("signal.example.com".to_string()),
-            port: 443,
-        };
-
-        let serialized = original.to_string();
-        let deserialized: HttpSignalingInfo = serialized.parse().unwrap();
-
-        assert_eq!(original, deserialized);
-    }
-
-    #[test]
-    fn test_roundtrip_ipv4() {
-        let original = HttpSignalingInfo {
-            host: Host::Ipv4(Ipv4Addr::new(127, 0, 0, 1)),
-            port: 8080,
-        };
-
-        let serialized = original.to_string();
-        let deserialized: HttpSignalingInfo = serialized.parse().unwrap();
-
-        assert_eq!(original, deserialized);
-    }
-}