Merge rust-bitcoin#5289: p2p: introduce consensus_encoding to the p2p package

4671923 p2p: add consensus_encoding to v1 network message (Nick Johnson)
213b85b p2p: remove io::Error from exposed API (Nick Johnson)
4c249f7 p2p: add consensus_encoding impls to CommandString (Nick Johnson)
6d95f4e p2p: add FeeFilter wrapper with consensus_encoding (Nick Johnson)

Pull request description:

  These commits are not perfectly related, some are kind of standalone, but they are all a part of the larger migration discussed in rust-bitcoin#5331 to drop the `bitcoin` and `io` dependencies in the `p2p` package.
  
  The final commit shows the new `consensus_encoding` interface for an external caller which is nice to lock in with the handshake example. I think this is ready as-is and I (or others) can follow up with the remaining work since p2p hasn't been released yet. This should allow us to drop `bitcoin` and `io`.
  
  1. BIP-152 addressed by rustaceanrob in rust-bitcoin#5333.
  2. BIP-158.
  3. Some dangling deps on the `BlockExt` in `bitcoin` which might just have to be re-implemented in p2p if not primitives worthy.
  4. Convert all the old encoders/decoders in `p2p` to `consensus_encoding` versions.


ACKs for top commit:
  apoelstra:
    ACK 4671923; successfully ran local tests


Tree-SHA512: c99662ff0d3672e041e86fe303e1627456e495a94959a345af850d8af698233fa9ca7676ad141825be5598f440408e2a24eefe3a2f78661c90bdf5c2673befb5

Author: apoelstra

Cargo-minimal.lock

@@ -123,6 +123,7 @@ version = "0.1.0"
 dependencies = [
  "arbitrary",
  "bitcoin",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
  "bitcoin-io",
  "bitcoin-units",

Cargo-recent.lock

@@ -122,6 +122,7 @@ version = "0.1.0"
 dependencies = [
  "arbitrary",
  "bitcoin",
+ "bitcoin-consensus-encoding",
  "bitcoin-internals",
  "bitcoin-io",
  "bitcoin-units",

p2p/Cargo.toml

@@ -14,11 +14,12 @@ exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["hashes/std", "hex/std", "internals/std", "io/std", "units/std", "bitcoin/std"]
+std = ["encoding/std", "hashes/std", "hex/std", "internals/std", "io/std", "units/std", "bitcoin/std"]
 arbitrary = ["dep:arbitrary", "bitcoin/arbitrary"]
 
 [dependencies]
 bitcoin = { path = "../bitcoin/", default-features = false }
+encoding = { package = "bitcoin-consensus-encoding", version = "1.0.0-rc.1", path = "../consensus_encoding", default-features = false }
 hashes = { package = "bitcoin_hashes", version = "0.18.0", path = "../hashes", default-features = false }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false }
 internals = { package = "bitcoin-internals", path = "../internals", default-features = false }

p2p/examples/handshake.rs

@@ -1,9 +1,8 @@
-use std::io::{BufReader, Write};
+use std::io::BufReader;
 use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, TcpStream};
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{env, process};
 
-use bitcoin::consensus::{encode, Decodable};
 use bitcoin_p2p_messages::message_network::{ClientSoftwareVersion, UserAgent, UserAgentVersion};
 use bitcoin_p2p_messages::{
     self, address, message, message_network, Magic, ProtocolVersion, ServiceFlags,
@@ -36,15 +35,17 @@ fn main() {
 
     if let Ok(mut stream) = TcpStream::connect(address) {
         // Send the message
-        let _ = stream.write_all(encode::serialize(&first_message).as_slice());
+        encoding::encode_to_writer(&first_message, &mut stream).unwrap();
         println!("Sent version message");
 
         // Setup StreamReader
         let read_stream = stream.try_clone().unwrap();
         let mut stream_reader = BufReader::new(read_stream);
         loop {
             // Loop and retrieve new messages
-            let reply = message::RawNetworkMessage::consensus_decode(&mut stream_reader).unwrap();
+            let reply =
+                encoding::decode_from_read::<message::RawNetworkMessage, _>(&mut stream_reader)
+                    .unwrap();
             match reply.payload() {
                 message::NetworkMessage::Version(_) => {
                     println!("Received version message: {:?}", reply.payload());
@@ -54,7 +55,7 @@ fn main() {
                         message::NetworkMessage::Verack,
                     );
 
-                    let _ = stream.write_all(encode::serialize(&second_message).as_slice());
+                    encoding::encode_to_writer(&second_message, &mut stream).unwrap();
                     println!("Sent verack message");
                 }
                 message::NetworkMessage::Verack => {

p2p/src/address.rs

@@ -47,12 +47,14 @@ impl Address {
     }
 
     /// Extracts socket address from an [Address] message.
-    /// This will return [io::Error] [io::ErrorKind::AddrNotAvailable]
-    /// if the message contains a Tor address.
-    pub fn socket_addr(&self) -> Result<SocketAddr, io::Error> {
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the message contains a Tor V2 onion address.
+    pub fn socket_addr(&self) -> Result<SocketAddr, UnroutableAddressError> {
         let addr = &self.address;
         if addr[0..3] == ONION {
-            return Err(io::Error::from(io::ErrorKind::AddrNotAvailable));
+            return Err(UnroutableAddressError::TorV2);
         }
         let ipv6 =
             Ipv6Addr::new(addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]);
@@ -126,7 +128,9 @@ impl fmt::Debug for Address {
 impl ToSocketAddrs for Address {
     type Iter = iter::Once<SocketAddr>;
     fn to_socket_addrs(&self) -> Result<Self::Iter, std::io::Error> {
-        Ok(iter::once(self.socket_addr()?))
+        self.socket_addr()
+            .map(iter::once)
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))
     }
 }
 
@@ -148,16 +152,16 @@ pub enum AddrV2 {
 }
 
 impl TryFrom<AddrV2> for IpAddr {
-    type Error = AddrV2ToIpAddrError;
+    type Error = UnroutableAddressError;
 
     fn try_from(addr: AddrV2) -> Result<Self, Self::Error> {
         match addr {
             AddrV2::Ipv4(ip) => Ok(Self::V4(ip)),
             AddrV2::Ipv6(ip) => Ok(Self::V6(ip)),
-            AddrV2::Cjdns(_) => Err(AddrV2ToIpAddrError::Cjdns),
-            AddrV2::TorV3(_) => Err(AddrV2ToIpAddrError::TorV3),
-            AddrV2::I2p(_) => Err(AddrV2ToIpAddrError::I2p),
-            AddrV2::Unknown(_, _) => Err(AddrV2ToIpAddrError::Unknown),
+            AddrV2::Cjdns(_) => Err(UnroutableAddressError::Cjdns),
+            AddrV2::TorV3(_) => Err(UnroutableAddressError::TorV3),
+            AddrV2::I2p(_) => Err(UnroutableAddressError::I2p),
+            AddrV2::Unknown(_, _) => Err(UnroutableAddressError::Unknown),
         }
     }
 }
@@ -202,11 +206,15 @@ impl From<IpAddr> for AddrV2 {
 }
 
 impl From<Ipv4Addr> for AddrV2 {
-    fn from(addr: Ipv4Addr) -> Self { Self::Ipv4(addr) }
+    fn from(addr: Ipv4Addr) -> Self {
+        Self::Ipv4(addr)
+    }
 }
 
 impl From<Ipv6Addr> for AddrV2 {
-    fn from(addr: Ipv6Addr) -> Self { Self::Ipv6(addr) }
+    fn from(addr: Ipv6Addr) -> Self {
+        Self::Ipv6(addr)
+    }
 }
 
 impl Encodable for AddrV2 {
@@ -317,13 +325,19 @@ pub struct AddrV2Message {
 
 impl AddrV2Message {
     /// Extracts socket address from an [AddrV2Message] message.
-    /// This will return [io::Error] [io::ErrorKind::AddrNotAvailable]
-    /// if the address type can't be converted into a [SocketAddr].
-    pub fn socket_addr(&self) -> Result<SocketAddr, io::Error> {
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the address type cannot be converted to a socket address
+    /// (e.g. Tor, I2P, CJDNS addresses).
+    pub fn socket_addr(&self) -> Result<SocketAddr, UnroutableAddressError> {
         match self.addr {
             AddrV2::Ipv4(addr) => Ok(SocketAddr::V4(SocketAddrV4::new(addr, self.port))),
             AddrV2::Ipv6(addr) => Ok(SocketAddr::V6(SocketAddrV6::new(addr, self.port, 0, 0))),
-            _ => Err(io::Error::from(io::ErrorKind::AddrNotAvailable)),
+            AddrV2::TorV3(_) => Err(UnroutableAddressError::TorV3),
+            AddrV2::I2p(_) => Err(UnroutableAddressError::I2p),
+            AddrV2::Cjdns(_) => Err(UnroutableAddressError::Cjdns),
+            AddrV2::Unknown(_, _) => Err(UnroutableAddressError::Unknown),
         }
     }
 }
@@ -356,10 +370,46 @@ impl Decodable for AddrV2Message {
 impl ToSocketAddrs for AddrV2Message {
     type Iter = iter::Once<SocketAddr>;
     fn to_socket_addrs(&self) -> Result<Self::Iter, std::io::Error> {
-        Ok(iter::once(self.socket_addr()?))
+        self.socket_addr()
+            .map(iter::once)
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))
     }
 }
 
+/// Error returned when an address cannot be converted to an IP-based address.
+///
+/// Addresses like Tor, I2P, and CJDNS use different routing mechanisms
+/// and cannot be represented as standard IP addresses or socket addresses.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum UnroutableAddressError {
+    /// Tor V2 onion address.
+    TorV2,
+    /// Tor V3 onion address.
+    TorV3,
+    /// I2P address.
+    I2p,
+    /// CJDNS address.
+    Cjdns,
+    /// Unknown address type.
+    Unknown,
+}
+
+impl fmt::Display for UnroutableAddressError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::TorV2 => write!(f, "Tor v2 addresses cannot be converted to IP addresses"),
+            Self::TorV3 => write!(f, "Tor v3 addresses cannot be converted to IP addresses"),
+            Self::I2p => write!(f, "I2P addresses cannot be converted to IP addresses"),
+            Self::Cjdns => write!(f, "CJDNS addresses cannot be converted to IP addresses"),
+            Self::Unknown => write!(f, "unknown address type cannot be converted to IP addresses"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnroutableAddressError {}
+
 /// Error types for [`AddrV2`] to [`IpAddr`] conversion.
 #[derive(Debug, PartialEq, Eq)]
 pub enum AddrV2ToIpAddrError {
@@ -794,7 +844,7 @@ mod test {
         let result = IpAddr::try_from(addr);
 
         assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), AddrV2ToIpAddrError::Cjdns);
+        assert_eq!(result.unwrap_err(), UnroutableAddressError::Cjdns);
     }
 
     #[test]
@@ -803,7 +853,7 @@ mod test {
         let result = IpAddr::try_from(addr);
 
         assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), AddrV2ToIpAddrError::TorV3);
+        assert_eq!(result.unwrap_err(), UnroutableAddressError::TorV3);
     }
 
     #[test]
@@ -812,7 +862,7 @@ mod test {
         let result = IpAddr::try_from(addr);
 
         assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), AddrV2ToIpAddrError::I2p);
+        assert_eq!(result.unwrap_err(), UnroutableAddressError::I2p);
     }
 
     #[test]
@@ -821,7 +871,7 @@ mod test {
         let result = IpAddr::try_from(addr);
 
         assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), AddrV2ToIpAddrError::Unknown);
+        assert_eq!(result.unwrap_err(), UnroutableAddressError::Unknown);
     }
 
     #[test]