lib: remove arti dependency in favor of tor proxy

Author: rustaceanrob

Cargo.lock

@@ -31,18 +31,10 @@ tokio = { version = "1", default-features = false, features = [
 
 # Optional dependencies
 rusqlite = { version = "0.31.0", features = ["bundled"], optional = true }
-arti-client = { version = "0.21.0", features = [
-    "rustls",
-    "tokio",
-    "onion-service-client",
-    "experimental-api",
-], default-features = false, optional = true }
-tor-rtcompat = { version = "0.21.0", features = ["tokio"], optional = true }
 
 [features]
 default = ["database"]
 database = ["rusqlite"]
-tor = ["arti-client", "tor-rtcompat"]
 filter-control = []
 
 [dev-dependencies]
@@ -73,11 +65,6 @@ path = "example/testnet4.rs"
 name = "rescan"
 path = "example/rescan.rs"
 
-[[example]]
-name = "tor"
-path = "example/tor.rs"
-required-features = ["tor"]
-
 [[example]]
 name = "managed"
 path = "example/managed.rs"

Cargo.toml

@@ -11,11 +11,12 @@ use crate::db::error::SqlInitializationError;
 #[cfg(feature = "database")]
 use crate::db::sqlite::{headers::SqliteHeaderDb, peers::SqlitePeerDb};
 use crate::network::dns::{DnsResolver, DNS_RESOLVER_PORT};
+use crate::network::ConnectionType;
 use crate::{
     chain::checkpoints::HeaderCheckpoint,
     db::traits::{HeaderStore, PeerStore},
 };
-use crate::{ConnectionType, FilterSyncPolicy, LogLevel, PeerStoreSizeConfig, TrustedPeer};
+use crate::{FilterSyncPolicy, LogLevel, PeerStoreSizeConfig, TrustedPeer};
 
 #[cfg(feature = "database")]
 /// The default node returned from the [`NodeBuilder`](crate::core).
@@ -149,12 +150,6 @@ impl NodeBuilder {
         self
     }
 
-    /// Set the desired communication channel. Either directly over TCP or over the Tor network.
-    pub fn connection_type(mut self, connection_type: ConnectionType) -> Self {
-        self.config.connection_type = connection_type;
-        self
-    }
-
     /// Set the time duration a peer has to respond to a message from the local node.
     ///
     /// ## Note
@@ -193,6 +188,15 @@ impl NodeBuilder {
         self
     }
 
+    /// Route network traffic through a Tor daemon using a Socks5 proxy. Currently, proxies
+    /// must be reachable by IP address.
+    pub fn socks5_proxy(mut self, proxy: impl Into<SocketAddr>) -> Self {
+        let ip_addr = proxy.into();
+        let connection = ConnectionType::Socks5Proxy(ip_addr);
+        self.config.connection_type = connection;
+        self
+    }
+
     /// Stop the node from downloading and checking compact block filters until an explicit command by the client is made.
     /// This is only useful if the scripts to check for may not be known do to some expensive computation, like in a silent
     /// payments context.

example/tor.rs

@@ -3,7 +3,8 @@ use std::{collections::HashSet, path::PathBuf, time::Duration};
 use bitcoin::ScriptBuf;
 
 use crate::{
-    chain::checkpoints::HeaderCheckpoint, network::dns::DnsResolver, ConnectionType,
+    chain::checkpoints::HeaderCheckpoint,
+    network::{dns::DnsResolver, ConnectionType},
     FilterSyncPolicy, LogLevel, PeerStoreSizeConfig, TrustedPeer,
 };
 

src/builder.rs

@@ -116,11 +116,6 @@ use std::collections::HashSet;
 
 use std::net::{IpAddr, SocketAddr};
 
-#[cfg(feature = "tor")]
-pub use arti_client::{TorClient, TorClientConfig};
-#[cfg(feature = "tor")]
-use tor_rtcompat::PreferredRuntime;
-
 // Re-exports
 #[doc(inline)]
 pub use chain::checkpoints::{
@@ -320,21 +315,6 @@ impl TrustedPeer {
         }
     }
 
-    /// Create a new peer from a TorV3 service and port.
-    #[cfg(feature = "tor")]
-    pub fn new_from_tor_v3(
-        public_key: [u8; 32],
-        port: Option<u16>,
-        services: ServiceFlags,
-    ) -> Self {
-        let address = AddrV2::TorV3(public_key);
-        Self {
-            address,
-            port,
-            known_services: services,
-        }
-    }
-
     /// Create a new trusted peer using the default port for the network.
     pub fn from_ip(ip_addr: impl Into<IpAddr>) -> Self {
         let address = match ip_addr.into() {
@@ -362,17 +342,6 @@ impl TrustedPeer {
         }
     }
 
-    /// Create a new peer from a TorV3 service.
-    #[cfg(feature = "tor")]
-    pub fn from_tor_v3(public_key: [u8; 32]) -> Self {
-        let address = AddrV2::TorV3(public_key);
-        Self {
-            address,
-            port: None,
-            known_services: ServiceFlags::NONE,
-        }
-    }
-
     /// The IP address of the trusted peer.
     pub fn address(&self) -> AddrV2 {
         self.address.clone()
@@ -422,18 +391,6 @@ impl From<SocketAddr> for TrustedPeer {
     }
 }
 
-/// How to connect to peers on the peer-to-peer network
-#[derive(Default, Clone)]
-#[non_exhaustive]
-pub enum ConnectionType {
-    /// Version one peer-to-peer connections
-    #[default]
-    ClearNet,
-    /// Connect to peers over Tor
-    #[cfg(feature = "tor")]
-    Tor(TorClient<PreferredRuntime>),
-}
-
 /// Configure how many peers will be stored.
 #[derive(Debug, Default, Clone)]
 pub enum PeerStoreSizeConfig {

src/config.rs

@@ -1,10 +1,21 @@
+use std::{
+    net::{IpAddr, SocketAddr},
+    time::Duration,
+};
+
 use bitcoin::{
     consensus::Decodable,
     io::Read,
-    p2p::{message::CommandString, Magic},
+    p2p::{address::AddrV2, message::CommandString, Magic},
 };
-use std::time::Duration;
-use tokio::time::Instant;
+use tokio::{
+    io::{AsyncRead, AsyncWrite},
+    net::TcpStream,
+    sync::Mutex,
+    time::Instant,
+};
+
+use error::PeerError;
 
 pub(crate) mod counter;
 pub(crate) mod dns;
@@ -16,14 +27,17 @@ pub(crate) mod peer;
 pub(crate) mod peer_map;
 #[allow(dead_code)]
 pub(crate) mod reader;
-#[cfg(feature = "tor")]
-pub(crate) mod tor;
+pub(crate) mod socks;
 pub(crate) mod traits;
 
 pub const PROTOCOL_VERSION: u32 = 70016;
 pub const KYOTO_VERSION: &str = "0.8.0";
 pub const RUST_BITCOIN_VERSION: &str = "0.32.4";
 const THIRTY_MINS: u64 = 60 * 30;
+const CONNECTION_TIMEOUT: u64 = 2;
+
+pub(crate) type StreamReader = Mutex<Box<dyn AsyncRead + Send + Unpin>>;
+pub(crate) type StreamWriter = Mutex<Box<dyn AsyncWrite + Send + Unpin>>;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub(crate) struct PeerId(pub(crate) u32);
@@ -86,6 +100,47 @@ impl LastBlockMonitor {
     }
 }
 
+#[derive(Debug, Clone, Copy, Default)]
+pub(crate) enum ConnectionType {
+    #[default]
+    ClearNet,
+    Socks5Proxy(SocketAddr),
+}
+
+impl ConnectionType {
+    pub(crate) fn can_connect(&self, addr: &AddrV2) -> bool {
+        match &self {
+            Self::ClearNet => matches!(addr, AddrV2::Ipv4(_) | AddrV2::Ipv6(_)),
+            Self::Socks5Proxy(_) => matches!(addr, AddrV2::Ipv4(_) | AddrV2::Ipv6(_)),
+        }
+    }
+
+    pub(crate) async fn connect(
+        &self,
+        addr: AddrV2,
+        port: u16,
+    ) -> Result<(StreamReader, StreamWriter), PeerError> {
+        let socket_addr = match addr {
+            AddrV2::Ipv4(ip) => IpAddr::V4(ip),
+            AddrV2::Ipv6(ip) => IpAddr::V6(ip),
+            _ => return Err(PeerError::UnreachableSocketAddr),
+        };
+        let timeout = tokio::time::timeout(
+            Duration::from_secs(CONNECTION_TIMEOUT),
+            TcpStream::connect((socket_addr, port)),
+        )
+        .await
+        .map_err(|_| PeerError::ConnectionFailed)?;
+        match timeout {
+            Ok(stream) => {
+                let (reader, writer) = stream.into_split();
+                Ok((Mutex::new(Box::new(reader)), Mutex::new(Box::new(writer))))
+            }
+            Err(_) => Err(PeerError::ConnectionFailed),
+        }
+    }
+}
+
 pub(crate) struct V1Header {
     magic: Magic,
     _command: CommandString,

src/lib.rs

@@ -8,8 +8,8 @@ use tokio::io::AsyncReadExt;
 use crate::prelude::FutureResult;
 
 use super::error::PeerReadError;
-use super::traits::{MessageParser, StreamReader};
 use super::V1Header;
+use super::{traits::MessageParser, StreamReader};
 
 const MAX_MESSAGE_BYTES: u32 = 1024 * 1024 * 32;