feat(gui): circuit connections

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+- GUI: Support outbound connections to makers through libp2p circuit relays.
+
 ## [4.14.0] - 2026-08-22
 
 - ASB: The `get-swaps` RPC response now includes the Bitcoin redeem address for each swap.

src-gui/src/utils/parseUtils.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { isValidMultiAddressWithPeerId } from "./parseUtils";
+
+describe("isValidMultiAddressWithPeerId", () => {
+  it("accepts a circuit relay address with relay and destination peer IDs", () => {
+    const address =
+      "/dns4/relay.example/tcp/443/wss/p2p/12D3KooWGRvf7qVQDrNR5nfYD6rKrbgeTi9x8RrbdxbmsPvxL4mw/p2p-circuit/p2p/12D3KooWMc39w7bZz4RLmJKuUiK9YkbKoEHACZWcL71XNns5dPuD";
+
+    expect(isValidMultiAddressWithPeerId(address)).toBe(true);
+  });
+
+  it("rejects a circuit relay address without a destination peer ID", () => {
+    const address =
+      "/dns4/relay.example/tcp/443/wss/p2p/12D3KooWGRvf7qVQDrNR5nfYD6rKrbgeTi9x8RrbdxbmsPvxL4mw/p2p-circuit";
+
+    expect(isValidMultiAddressWithPeerId(address)).toBe(false);
+  });
+});

src-gui/src/utils/parseUtils.ts

@@ -51,8 +51,9 @@ export function isValidMultiAddressWithPeerId(
   try {
     const multiAddress = new Multiaddr(multiAddressStr);
     const peerId = multiAddress.getPeerId();
+    const protocols = multiAddress.protoNames();
 
-    return peerId !== null;
+    return peerId !== null && protocols[protocols.length - 1] === "p2p";
   } catch {
     return false;
   }

swap-p2p/Cargo.toml

@@ -14,7 +14,7 @@ swap-serde = { path = "../swap-serde" }
 
 # Networking
 async-trait = { workspace = true, optional = true }
-libp2p = { workspace = true, features = ["serde", "request-response", "rendezvous", "cbor", "json", "ping", "identify"] }
+libp2p = { workspace = true, features = ["serde", "request-response", "rendezvous", "cbor", "json", "ping", "identify", "relay"] }
 
 # Metrics
 prometheus-client = "0.22"

swap-p2p/src/out_event/bob.rs

@@ -4,7 +4,7 @@ use libp2p::{
         InboundFailure, InboundRequestId, OutboundFailure, OutboundRequestId, ResponseChannel,
     },
 };
-use libp2p::{identify, ping};
+use libp2p::{identify, ping, relay};
 
 use crate::observe;
 use crate::protocols::{
@@ -103,6 +103,12 @@ impl From<identify::Event> for OutEvent {
     }
 }
 
+impl From<relay::client::Event> for OutEvent {
+    fn from(_: relay::client::Event) -> Self {
+        OutEvent::Other
+    }
+}
+
 impl From<rendezvous::discovery::Event> for OutEvent {
     fn from(event: rendezvous::discovery::Event) -> Self {
         OutEvent::Discovery(event)

swap/Cargo.toml

@@ -29,7 +29,7 @@ tor-llcrypto = { workspace = true }
 tor-rtcompat = { workspace = true, features = ["tokio"] }
 
 # LibP2P
-libp2p = { workspace = true, features = ["tcp", "yamux", "dns", "noise", "request-response", "ping", "rendezvous", "identify", "macros", "cbor", "json", "tokio", "serde", "rsa", "websocket", "metrics"] }
+libp2p = { workspace = true, features = ["tcp", "yamux", "dns", "noise", "request-response", "ping", "rendezvous", "identify", "macros", "cbor", "json", "tokio", "serde", "rsa", "websocket", "metrics", "relay"] }
 libp2p-tor = { path = "../libp2p-tor", features = ["listen-onion-service"] }
 
 # Error handling

swap/src/cli/api.rs

@@ -835,21 +835,20 @@ mod builder {
                 let rendezvous_peer_ids: Vec<PeerId> =
                     rendezvous_points.iter().map(|(p, _)| *p).collect();
 
-                let behaviour = crate::cli::Behaviour::new(
-                    env_config,
-                    wallet.clone(),
-                    seed.derive_libp2p_identity(),
-                    namespace,
-                    rendezvous_peer_ids.clone(),
-                    db.clone(),
-                );
-
-                let (mut swarm, tor_priority_tracker) = crate::network::swarm::cli(
-                    seed.derive_libp2p_identity(),
-                    tor_client_for_swarm,
-                    behaviour,
-                )
-                .await?;
+                let identity = seed.derive_libp2p_identity();
+                let (mut swarm, tor_priority_tracker) =
+                    crate::network::swarm::cli(identity.clone(), tor_client_for_swarm, |relay| {
+                        crate::cli::Behaviour::new(
+                            env_config,
+                            wallet.clone(),
+                            identity,
+                            relay,
+                            namespace,
+                            rendezvous_peer_ids.clone(),
+                            db.clone(),
+                        )
+                    })
+                    .await?;
 
                 if let Some(tor_priority_tracker) = &tor_priority_tracker {
                     for peer_id in &rendezvous_peer_ids {

swap/src/cli/behaviour.rs

@@ -8,7 +8,7 @@ use crate::network::{
 use anyhow::Result;
 use bitcoin_wallet::BitcoinWallet;
 use libp2p::swarm::NetworkBehaviour;
-use libp2p::{PeerId, identify, identity, ping};
+use libp2p::{PeerId, identify, identity, ping, relay};
 use std::sync::Arc;
 use std::time::Duration;
 use swap_env::env;
@@ -25,6 +25,9 @@ const MAX_REDIAL_INTERVAL: Duration = Duration::from_secs(30);
 #[behaviour(to_swarm = "OutEvent")]
 #[allow(missing_debug_implementations)]
 pub struct Behaviour {
+    /// Enables outbound connections through circuit relays.
+    relay: relay::client::Behaviour,
+
     /// Fetch a quote from a specific peer, usually before starting a swap
     pub direct_quote: quote::Behaviour,
     /// Periodically request quotes from any peers that might offer them
@@ -57,6 +60,7 @@ impl Behaviour {
         env_config: env::Config,
         bitcoin_wallet: Arc<dyn BitcoinWallet>,
         identity: identity::Keypair,
+        relay: relay::client::Behaviour,
         namespace: XmrBtcNamespace,
         rendezvous_nodes: Vec<PeerId>,
         wormhole_store: Arc<dyn wormhole::WormholeStore + Send + Sync>,
@@ -67,6 +71,7 @@ impl Behaviour {
         let pingConfig = ping::Config::new().with_timeout(Duration::from_secs(60));
 
         Self {
+            relay,
             direct_quote: quote::bob(),
             quotes: quotes_cached::Behaviour::new(identifyConfig),
 

swap/src/network/swarm.rs

@@ -9,7 +9,7 @@ use libp2p::connection_limits::ConnectionLimits;
 use libp2p::core::muxing::StreamMuxerBox;
 use libp2p::metrics::{BandwidthTransport, Registry};
 use libp2p::swarm::NetworkBehaviour;
-use libp2p::{Multiaddr, Swarm, identity};
+use libp2p::{Multiaddr, Swarm, identity, noise, relay, yamux};
 use libp2p::{PeerId, SwarmBuilder};
 use libp2p_tor::TorDialPriorityTracker;
 use std::fmt::Debug;
@@ -132,20 +132,22 @@ where
     Ok((swarm, onion_addresses, onion_service_handle))
 }
 
-pub async fn cli<T>(
+pub async fn cli<T, B>(
     identity: identity::Keypair,
     maybe_tor_client: Option<Arc<TorClient<TokioRustlsRuntime>>>,
-    behaviour: T,
+    build_behaviour: B,
 ) -> Result<(Swarm<T>, Option<TorDialPriorityTracker>)>
 where
     T: NetworkBehaviour,
+    B: FnOnce(relay::client::Behaviour) -> T,
 {
     let (transport, tor_priority_tracker) = cli::transport::new(&identity, maybe_tor_client)?;
 
     let swarm = SwarmBuilder::with_existing_identity(identity)
         .with_tokio()
         .with_other_transport(|_| transport)?
-        .with_behaviour(|_| behaviour)?
+        .with_relay_client(noise::Config::new, yamux::Config::default)?
+        .with_behaviour(|_, relay| build_behaviour(relay))?
         .with_swarm_config(|cfg| cfg.with_idle_connection_timeout(IDLE_CONNECTION_TIMEOUT))
         .build();
 

swap/tests/harness/mod.rs

@@ -771,16 +771,18 @@ impl BobParams {
     ) -> Result<(cli::EventLoop, cli::EventLoopHandle)> {
         let identity = self.seed.derive_libp2p_identity();
 
-        let behaviour = cli::Behaviour::new(
-            self.env_config,
-            self.bitcoin_wallet.clone(),
-            identity.clone(),
-            XmrBtcNamespace::Testnet,
-            Vec::new(),
-            db.clone(),
-        );
-        let (mut swarm, tor_priority_tracker) =
-            swarm::cli(identity.clone(), None, behaviour).await?;
+        let (mut swarm, tor_priority_tracker) = swarm::cli(identity.clone(), None, |relay| {
+            cli::Behaviour::new(
+                self.env_config,
+                self.bitcoin_wallet.clone(),
+                identity,
+                relay,
+                XmrBtcNamespace::Testnet,
+                Vec::new(),
+                db.clone(),
+            )
+        })
+        .await?;
         swarm.add_peer_address(self.alice_peer_id, self.alice_address.clone());
 
         cli::EventLoop::new(swarm, db.clone(), None, tor_priority_tracker)