style: cargo fmt for v1.7.99-alpha release gate

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

core/archipelago/src/swarm/iroh_provider.rs

@@ -120,7 +120,8 @@ impl IrohProvider {
         // The event sender gates each request through the ecash `streaming` layer
         // — free by default, paid only if the operator priced `content-download`
         // (Networking Profits → Settings). It also hard-disables peer writes.
-        let event_sender = super::paid::gated_event_sender(data_dir.to_path_buf(), (*store).clone());
+        let event_sender =
+            super::paid::gated_event_sender(data_dir.to_path_buf(), (*store).clone());
         let blobs = BlobsProtocol::new(&store, Some(event_sender));
         // Shape-A paid negotiation rides a second ALPN on the same endpoint so a
         // downloader can pay (open a session) before the blob-GET above serves it.

core/archipelago/src/swarm/mod.rs

@@ -108,7 +108,9 @@ pub async fn init(
         if enabled {
             warn!("swarm: swarm_enabled set but binary built without the `iroh-swarm` feature — staying origin-only");
         }
-        let _ = RUNTIME.set(SwarmRuntime { providers: Vec::new() });
+        let _ = RUNTIME.set(SwarmRuntime {
+            providers: Vec::new(),
+        });
         return Ok(());
     }
 
@@ -123,13 +125,10 @@ pub async fn init(
             return Ok(());
         }
 
-        let discovery: Arc<dyn iroh_provider::ProviderDiscovery> =
-            Arc::new(iroh_provider::NostrSeedDiscovery::new(
-                relays.to_vec(),
-                tor_proxy.map(str::to_string),
-            ));
-        let provider =
-            Arc::new(iroh_provider::IrohProvider::new(data_dir, Some(discovery)).await?);
+        let discovery: Arc<dyn iroh_provider::ProviderDiscovery> = Arc::new(
+            iroh_provider::NostrSeedDiscovery::new(relays.to_vec(), tor_proxy.map(str::to_string)),
+        );
+        let provider = Arc::new(iroh_provider::IrohProvider::new(data_dir, Some(discovery)).await?);
         info!(
             "swarm: iroh provider active (endpoint {}) — swarm-assist enabled, origin always wins",
             provider.endpoint_id()
@@ -231,7 +230,10 @@ where
         }
     }
 
-    debug!("swarm: no provider served {} — falling back to origin", digest);
+    debug!(
+        "swarm: no provider served {} — falling back to origin",
+        digest
+    );
     origin().await?;
     Ok(FetchSource::Origin)
 }
@@ -248,7 +250,11 @@ mod tests {
     use std::sync::atomic::{AtomicBool, Ordering};
 
     fn digest_of(bytes: &[u8]) -> ContentDigest {
-        ContentDigest::parse(&format!("blake3:{}", crate::content_hash::blake3_hex(bytes))).unwrap()
+        ContentDigest::parse(&format!(
+            "blake3:{}",
+            crate::content_hash::blake3_hex(bytes)
+        ))
+        .unwrap()
     }
 
     /// Provider that writes a fixed payload (which may or may not match).
@@ -295,7 +301,10 @@ mod tests {
         .await
         .unwrap();
         assert_eq!(src, FetchSource::Swarm);
-        assert!(!origin_ran.load(Ordering::SeqCst), "origin must not run on swarm hit");
+        assert!(
+            !origin_ran.load(Ordering::SeqCst),
+            "origin must not run on swarm hit"
+        );
         assert_eq!(tokio::fs::read(&dest).await.unwrap(), content);
     }
 
@@ -316,7 +325,11 @@ mod tests {
         })
         .await
         .unwrap();
-        assert_eq!(src, FetchSource::Origin, "tampered swarm bytes must not be accepted");
+        assert_eq!(
+            src,
+            FetchSource::Origin,
+            "tampered swarm bytes must not be accepted"
+        );
         assert_eq!(tokio::fs::read(&dest).await.unwrap(), content);
     }
 
@@ -343,8 +356,14 @@ mod tests {
         let content = b"second wins".to_vec();
         let digest = digest_of(&content);
         let providers = vec![
-            arc(FixedProvider { name: "miss", payload: None }),
-            arc(FixedProvider { name: "hit", payload: Some(content.clone()) }),
+            arc(FixedProvider {
+                name: "miss",
+                payload: None,
+            }),
+            arc(FixedProvider {
+                name: "hit",
+                payload: Some(content.clone()),
+            }),
         ];
         let src = fetch_content_addressed(&digest, &providers, &dest, || async {
             tokio::fs::write(&dest, b"origin").await?;

core/archipelago/src/swarm/paid_alpn.rs

@@ -166,7 +166,9 @@ impl ProtocolHandler for PaidBlobsProtocol {
                 },
             };
             let bytes = serde_json::to_vec(&response).map_err(AcceptError::from_err)?;
-            send.write_all(&bytes).await.map_err(AcceptError::from_err)?;
+            send.write_all(&bytes)
+                .await
+                .map_err(AcceptError::from_err)?;
             send.finish().map_err(AcceptError::from_err)?;
         }
         Ok(())
@@ -192,7 +194,9 @@ pub async fn negotiate_access(
     match negotiate_inner(endpoint, data_dir, peer, blake3_hex, policy).await {
         Ok(proceed) => proceed,
         Err(e) => {
-            tracing::debug!("paid-alpn: negotiation with {peer} failed ({e}) — proceeding (gate decides)");
+            tracing::debug!(
+                "paid-alpn: negotiation with {peer} failed ({e}) — proceeding (gate decides)"
+            );
             true
         }
     }
@@ -265,7 +269,10 @@ mod tests {
             token: None,
         };
         let json = serde_json::to_string(&req).unwrap();
-        assert!(!json.contains("token"), "absent token must be omitted: {json}");
+        assert!(
+            !json.contains("token"),
+            "absent token must be omitted: {json}"
+        );
         let back: PaidRequest = serde_json::from_str(&json).unwrap();
         assert_eq!(back.want, "abcd");
         assert!(back.token.is_none());
@@ -277,7 +284,8 @@ mod tests {
             want: "ff".into(),
             token: Some("cashuAbc".into()),
         };
-        let back: PaidRequest = serde_json::from_str(&serde_json::to_string(&req).unwrap()).unwrap();
+        let back: PaidRequest =
+            serde_json::from_str(&serde_json::to_string(&req).unwrap()).unwrap();
         assert_eq!(back.token.as_deref(), Some("cashuAbc"));
     }
 

core/archipelago/src/swarm/payment.rs

@@ -88,7 +88,8 @@ pub async fn auto_pay_token(
         return Ok(None);
     }
 
-    match ecash::build_payment_token(data_dir, accepted_mints, price_sats, policy.max_fee_sats).await
+    match ecash::build_payment_token(data_dir, accepted_mints, price_sats, policy.max_fee_sats)
+        .await
     {
         Ok(token) => Ok(Some(token)),
         Err(e) => {

core/archipelago/src/swarm/seed_advert.rs

@@ -191,7 +191,10 @@ mod tests {
         let hash = "b".repeat(64);
         let json = serde_json::to_string(&advertisement_filter(&hash)).unwrap();
         assert!(json.contains(&hash), "filter must target the hash d-tag");
-        assert!(json.contains("30081"), "filter must constrain the seed kind");
+        assert!(
+            json.contains("30081"),
+            "filter must constrain the seed kind"
+        );
     }
 
     #[test]
@@ -212,10 +215,19 @@ mod tests {
         let a = Keys::generate();
         let b = Keys::generate();
         let hash = "d".repeat(64);
-        let e1 = advertisement_builder(&hash, "endpoint-A").sign_with_keys(&a).unwrap();
-        let e2 = advertisement_builder(&hash, "endpoint-A").sign_with_keys(&b).unwrap();
-        let e3 = advertisement_builder(&hash, "endpoint-B").sign_with_keys(&b).unwrap();
+        let e1 = advertisement_builder(&hash, "endpoint-A")
+            .sign_with_keys(&a)
+            .unwrap();
+        let e2 = advertisement_builder(&hash, "endpoint-A")
+            .sign_with_keys(&b)
+            .unwrap();
+        let e3 = advertisement_builder(&hash, "endpoint-B")
+            .sign_with_keys(&b)
+            .unwrap();
         let ids = endpoint_ids_from_events([&e1, &e2, &e3]);
-        assert_eq!(ids, vec!["endpoint-A".to_string(), "endpoint-B".to_string()]);
+        assert_eq!(
+            ids,
+            vec!["endpoint-A".to_string(), "endpoint-B".to_string()]
+        );
     }
 }