style: apply cargo fmt formatting fixes

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

Author: jeremymanning

src/cli/admin.rs

@@ -49,7 +49,8 @@ pub fn execute(cmd: &AdminCommand) -> String {
             )
         }
         AdminCommand::Resume => {
-            "Resume requested. Requires OnCallResponder role and active admin service connection.".into()
+            "Resume requested. Requires OnCallResponder role and active admin service connection."
+                .into()
         }
         AdminCommand::Ban { subject_id, reason } => {
             format!(

src/cli/donor.rs

@@ -47,10 +47,8 @@ pub enum DonorCommand {
 pub fn execute(cmd: &DonorCommand) -> String {
     match cmd {
         DonorCommand::Join { consent } => {
-            let classes: Vec<AcceptableUseClass> = consent
-                .split(',')
-                .filter_map(|s| parse_use_class(s.trim()))
-                .collect();
+            let classes: Vec<AcceptableUseClass> =
+                consent.split(',').filter_map(|s| parse_use_class(s.trim())).collect();
 
             if classes.is_empty() {
                 return "Error: no valid consent classes provided. Valid classes: scientific, public-good-ml, rendering, indexing, self-improvement, general".into();
@@ -72,12 +70,8 @@ pub fn execute(cmd: &DonorCommand) -> String {
         DonorCommand::Status => {
             "Donor status: agent daemon not running. Start with `worldcompute donor join`.".into()
         }
-        DonorCommand::Pause => {
-            "Pause: agent daemon not running. Nothing to pause.".into()
-        }
-        DonorCommand::Resume => {
-            "Resume: agent daemon not running. Nothing to resume.".into()
-        }
+        DonorCommand::Pause => "Pause: agent daemon not running. Nothing to pause.".into(),
+        DonorCommand::Resume => "Resume: agent daemon not running. Nothing to resume.".into(),
         DonorCommand::Leave => {
             "Leave: agent daemon not running. No cluster state to clean up.".into()
         }

src/cli/governance.rs

@@ -60,7 +60,9 @@ pub fn execute(cmd: &GovernanceCommand) -> String {
                 proposal_type_parsed,
                 "cli-user",
             ) {
-                Ok(id) => format!("Proposal submitted.\n  ID: {id}\n  Title: {title}\n  Type: {proposal_type}"),
+                Ok(id) => format!(
+                    "Proposal submitted.\n  ID: {id}\n  Title: {title}\n  Type: {proposal_type}"
+                ),
                 Err(e) => format!("Error submitting proposal: {e}"),
             }
         }
@@ -73,7 +75,8 @@ pub fn execute(cmd: &GovernanceCommand) -> String {
             } else {
                 let mut output = format!("Proposals ({}):\n", proposals.len());
                 for p in &proposals {
-                    output.push_str(&format!("  {} — {} [{:?}]\n", p.proposal_id, p.title, p.state));
+                    output
+                        .push_str(&format!("  {} — {} [{:?}]\n", p.proposal_id, p.title, p.state));
                 }
                 output
             }
@@ -83,7 +86,9 @@ pub fn execute(cmd: &GovernanceCommand) -> String {
                 "yes" => "Yes",
                 "no" => "No",
                 "abstain" => "Abstain",
-                _ => return format!("Error: invalid vote choice '{choice}'. Use: yes, no, abstain"),
+                _ => {
+                    return format!("Error: invalid vote choice '{choice}'. Use: yes, no, abstain")
+                }
             };
             format!("Vote '{vote_choice}' registered for proposal {proposal_id} (awaiting governance service connection).")
         }

src/cli/submitter.rs

@@ -42,22 +42,20 @@ pub enum JobCommand {
 /// Execute a job CLI command. Returns a human-readable status string.
 pub fn execute(cmd: &JobCommand) -> String {
     match cmd {
-        JobCommand::Submit { manifest_path } => {
-            match std::fs::read_to_string(manifest_path) {
-                Ok(content) => {
-                    match serde_json::from_str::<crate::scheduler::manifest::JobManifest>(&content) {
-                        Ok(manifest) => {
-                            format!(
+        JobCommand::Submit { manifest_path } => match std::fs::read_to_string(manifest_path) {
+            Ok(content) => {
+                match serde_json::from_str::<crate::scheduler::manifest::JobManifest>(&content) {
+                    Ok(manifest) => {
+                        format!(
                                 "Job validated.\n  Name: {}\n  Workload: {:?}\n  Inputs: {}\n  Use classes: {:?}\n  Submitted (awaiting coordinator connection).",
                                 manifest.name, manifest.workload_type, manifest.inputs.len(), manifest.acceptable_use_classes
                             )
-                        }
-                        Err(e) => format!("Error: invalid manifest JSON: {e}"),
                     }
+                    Err(e) => format!("Error: invalid manifest JSON: {e}"),
                 }
-                Err(e) => format!("Error: cannot read manifest file '{manifest_path}': {e}"),
             }
-        }
+            Err(e) => format!("Error: cannot read manifest file '{manifest_path}': {e}"),
+        },
         JobCommand::Status { job_id } => {
             format!("Job {job_id}: no coordinator connection. Start a donor node first.")
         }

src/identity/oauth2.rs

@@ -103,11 +103,7 @@ impl OAuth2ProviderConfig {
         let token_url = std::env::var(format!("OAUTH2_{prefix}_TOKEN_URL"))
             .unwrap_or_else(|_| provider.default_token_url().to_string());
 
-        let scopes = provider
-            .default_scopes()
-            .into_iter()
-            .map(String::from)
-            .collect();
+        let scopes = provider.default_scopes().into_iter().map(String::from).collect();
 
         Some(Self {
             provider,
@@ -125,8 +121,7 @@ impl OAuth2ProviderConfig {
         let client = BasicClient::new(
             ClientId::new(self.client_id.clone()),
             Some(ClientSecret::new(self.client_secret.clone())),
-            AuthUrl::new(self.auth_url.clone())
-                .map_err(|e| format!("Invalid auth URL: {e}"))?,
+            AuthUrl::new(self.auth_url.clone()).map_err(|e| format!("Invalid auth URL: {e}"))?,
             Some(
                 TokenUrl::new(self.token_url.clone())
                     .map_err(|e| format!("Invalid token URL: {e}"))?,
@@ -144,10 +139,7 @@ impl OAuth2ProviderConfig {
 #[derive(Debug, Clone)]
 pub enum OAuth2Result {
     /// Successfully verified — provider confirmed the account.
-    Verified {
-        provider: OAuth2Provider,
-        account_id: String,
-    },
+    Verified { provider: OAuth2Provider, account_id: String },
     /// Verification failed (e.g., invalid token, denied).
     Failed(String),
     /// Provider is unavailable (credentials missing or service unreachable).
@@ -187,11 +179,7 @@ pub fn generate_auth_url(
 /// This function performs the full OAuth2 authorization code exchange using
 /// the `oauth2` crate, then queries the provider's user-info endpoint to
 /// obtain the account identifier.
-pub fn exchange_code(
-    provider: OAuth2Provider,
-    redirect_uri: &str,
-    code: &str,
-) -> OAuth2Result {
+pub fn exchange_code(provider: OAuth2Provider, redirect_uri: &str, code: &str) -> OAuth2Result {
     let config = match OAuth2ProviderConfig::from_env(provider, redirect_uri) {
         Some(c) => c,
         None => {
@@ -211,9 +199,8 @@ pub fn exchange_code(
 
     // Exchange code for token using the oauth2 crate's built-in blocking HTTP client
     let http_client = oauth2::reqwest::http_client;
-    let token_result = client
-        .exchange_code(oauth2::AuthorizationCode::new(code.to_string()))
-        .request(http_client);
+    let token_result =
+        client.exchange_code(oauth2::AuthorizationCode::new(code.to_string())).request(http_client);
 
     let token_response = match token_result {
         Ok(t) => t,
@@ -224,10 +211,7 @@ pub fn exchange_code(
 
     // Fetch user info from provider-specific endpoint
     match fetch_account_id(provider, &access_token) {
-        Ok(account_id) => OAuth2Result::Verified {
-            provider,
-            account_id,
-        },
+        Ok(account_id) => OAuth2Result::Verified { provider, account_id },
         Err(e) => OAuth2Result::Failed(format!("Failed to fetch user info: {e}")),
     }
 }
@@ -238,15 +222,9 @@ fn fetch_account_id(provider: OAuth2Provider, access_token: &str) -> Result<Stri
 
     let (url, id_field) = match provider {
         OAuth2Provider::GitHub => ("https://api.github.com/user", "id"),
-        OAuth2Provider::Google => (
-            "https://www.googleapis.com/oauth2/v2/userinfo",
-            "id",
-        ),
+        OAuth2Provider::Google => ("https://www.googleapis.com/oauth2/v2/userinfo", "id"),
         OAuth2Provider::Twitter => ("https://api.twitter.com/2/users/me", "id"),
-        OAuth2Provider::Email => (
-            "https://www.googleapis.com/oauth2/v2/userinfo",
-            "email",
-        ),
+        OAuth2Provider::Email => ("https://www.googleapis.com/oauth2/v2/userinfo", "email"),
     };
 
     let response = http_client
@@ -258,22 +236,15 @@ fn fetch_account_id(provider: OAuth2Provider, access_token: &str) -> Result<Stri
         .map_err(|e| format!("HTTP request failed: {e}"))?;
 
     if !response.status().is_success() {
-        return Err(format!(
-            "Provider returned HTTP {}",
-            response.status()
-        ));
+        return Err(format!("Provider returned HTTP {}", response.status()));
     }
 
-    let body: serde_json::Value = response
-        .json()
-        .map_err(|e| format!("Failed to parse response: {e}"))?;
+    let body: serde_json::Value =
+        response.json().map_err(|e| format!("Failed to parse response: {e}"))?;
 
     // Twitter nests user data under "data"
-    let user_data = if provider == OAuth2Provider::Twitter {
-        body.get("data").unwrap_or(&body)
-    } else {
-        &body
-    };
+    let user_data =
+        if provider == OAuth2Provider::Twitter { body.get("data").unwrap_or(&body) } else { &body };
 
     user_data
         .get(id_field)
@@ -324,9 +295,7 @@ pub fn verify_oauth2(provider: OAuth2Provider, redirect_uri: &str) -> OAuth2Resu
                     // Return as "Failed" with the auth URL — the caller needs to
                     // redirect the user and then call exchange_code() with the code.
                     // In a non-interactive context, we cannot complete the flow.
-                    OAuth2Result::Failed(format!(
-                        "Authorization required. Visit: {url}"
-                    ))
+                    OAuth2Result::Failed(format!("Authorization required. Visit: {url}"))
                 }
             }
         }
@@ -348,10 +317,8 @@ mod tests {
     #[test]
     fn config_from_env_returns_none_when_missing() {
         // With no env vars set, config should be None
-        let config = OAuth2ProviderConfig::from_env(
-            OAuth2Provider::GitHub,
-            "https://localhost/callback",
-        );
+        let config =
+            OAuth2ProviderConfig::from_env(OAuth2Provider::GitHub, "https://localhost/callback");
         // This will be None unless someone has OAUTH2_GITHUB_CLIENT_ID set
         if std::env::var("OAUTH2_GITHUB_CLIENT_ID").is_err() {
             assert!(config.is_none());
@@ -425,11 +392,7 @@ mod tests {
     #[test]
     fn exchange_code_returns_unavailable_without_credentials() {
         if std::env::var("OAUTH2_GITHUB_CLIENT_ID").is_err() {
-            match exchange_code(
-                OAuth2Provider::GitHub,
-                "https://localhost/callback",
-                "fake-code",
-            ) {
+            match exchange_code(OAuth2Provider::GitHub, "https://localhost/callback", "fake-code") {
                 OAuth2Result::ProviderUnavailable(msg) => {
                     assert!(msg.contains("credentials not configured"));
                 }
@@ -441,10 +404,7 @@ mod tests {
     #[test]
     fn generate_auth_url_returns_error_without_credentials() {
         if std::env::var("OAUTH2_GITHUB_CLIENT_ID").is_err() {
-            let result = generate_auth_url(
-                OAuth2Provider::GitHub,
-                "https://localhost/callback",
-            );
+            let result = generate_auth_url(OAuth2Provider::GitHub, "https://localhost/callback");
             assert!(result.is_err());
             assert!(result.unwrap_err().contains("credentials not configured"));
         }

src/identity/personhood.rs

@@ -67,8 +67,8 @@ pub fn brightid_link_url(context_id: &str) -> String {
 /// In production, it should be called at enrollment time and
 /// re-verified at trust score recalculation intervals.
 pub fn verify_personhood(context_id: &str) -> PersonhoodResult {
-    let base_url = std::env::var("BRIGHTID_NODE_URL")
-        .unwrap_or_else(|_| BRIGHTID_NODE_URL.to_string());
+    let base_url =
+        std::env::var("BRIGHTID_NODE_URL").unwrap_or_else(|_| BRIGHTID_NODE_URL.to_string());
     let url = format!("{base_url}/verifications/{BRIGHTID_CONTEXT}/{context_id}");
 
     // Use a blocking HTTP client for simplicity.
@@ -134,14 +134,11 @@ fn ureq_get_brightid(url: &str) -> Result<BrightIdVerification, String> {
         return Err(format!("BrightID returned status {status}"));
     }
 
-    let api_response: BrightIdApiResponse = response
-        .json()
-        .map_err(|e| format!("BrightID response parse failed: {e}"))?;
+    let api_response: BrightIdApiResponse =
+        response.json().map_err(|e| format!("BrightID response parse failed: {e}"))?;
 
     if let Some(true) = api_response.error {
-        return Err(
-            api_response.error_message.unwrap_or_else(|| "Unknown BrightID error".into())
-        );
+        return Err(api_response.error_message.unwrap_or_else(|| "Unknown BrightID error".into()));
     }
 
     api_response.data.ok_or_else(|| "BrightID response missing data field".into())

src/identity/phone.rs

@@ -39,19 +39,12 @@ impl SmsProviderConfig {
         let account_sid = std::env::var("TWILIO_ACCOUNT_SID").ok()?;
         let auth_token = std::env::var("TWILIO_AUTH_TOKEN").ok()?;
         let verify_service_sid = std::env::var("TWILIO_VERIFY_SID").ok()?;
-        Some(Self {
-            account_sid,
-            auth_token,
-            verify_service_sid,
-        })
+        Some(Self { account_sid, auth_token, verify_service_sid })
     }
 
     /// Twilio Verify API base URL for this service.
     fn verifications_url(&self) -> String {
-        format!(
-            "https://verify.twilio.com/v2/Services/{}/Verifications",
-            self.verify_service_sid
-        )
+        format!("https://verify.twilio.com/v2/Services/{}/Verifications", self.verify_service_sid)
     }
 
     /// Twilio Verify check URL for this service.
@@ -87,14 +80,11 @@ pub fn send_verification_code(phone_number: &str) -> Result<String, String> {
     if !response.status().is_success() {
         let status = response.status();
         let body = response.text().unwrap_or_default();
-        return Err(format!(
-            "Twilio API returned HTTP {status}: {body}"
-        ));
+        return Err(format!("Twilio API returned HTTP {status}: {body}"));
     }
 
-    let body: serde_json::Value = response
-        .json()
-        .map_err(|e| format!("Failed to parse Twilio response: {e}"))?;
+    let body: serde_json::Value =
+        response.json().map_err(|e| format!("Failed to parse Twilio response: {e}"))?;
 
     body.get("sid")
         .and_then(|v| v.as_str())
@@ -129,9 +119,7 @@ pub fn verify_code(phone_number: &str, code: &str) -> PhoneResult {
     {
         Ok(r) => r,
         Err(e) => {
-            return PhoneResult::ProviderUnavailable(format!(
-                "Failed to reach Twilio API: {e}"
-            ));
+            return PhoneResult::ProviderUnavailable(format!("Failed to reach Twilio API: {e}"));
         }
     };
 
@@ -156,10 +144,7 @@ pub fn verify_code(phone_number: &str, code: &str) -> PhoneResult {
         }
     };
 
-    let status = body
-        .get("status")
-        .and_then(|v| v.as_str())
-        .unwrap_or("unknown");
+    let status = body.get("status").and_then(|v| v.as_str()).unwrap_or("unknown");
 
     match status {
         "approved" => {

src/ledger/transparency.rs

@@ -5,10 +5,10 @@
 //! placeholder so the rest of the system can be wired up without a live
 //! Rekor endpoint.
 
-use base64::Engine;
 use crate::error::{ErrorCode, WcError, WcResult};
 use crate::ledger::entry::MerkleRoot;
 use crate::types::Timestamp;
+use base64::Engine;
 use sha2::{Digest, Sha256};
 use std::collections::HashMap;
 
@@ -71,12 +71,8 @@ pub fn anchor_merkle_root(root: &MerkleRoot) -> WcResult<MerkleRootAnchor> {
     {
         Ok(resp) if resp.status().is_success() => {
             // Rekor returns { "<uuid>": { ... } }
-            let parsed: HashMap<String, serde_json::Value> =
-                resp.json().unwrap_or_default();
-            parsed
-                .into_keys()
-                .next()
-                .unwrap_or_else(|| offline_entry_id(&root.root_hash))
+            let parsed: HashMap<String, serde_json::Value> = resp.json().unwrap_or_default();
+            parsed.into_keys().next().unwrap_or_else(|| offline_entry_id(&root.root_hash))
         }
         _ => {
             // Network error or non-success status — fall back to offline ID.
@@ -125,10 +121,7 @@ pub fn verify_anchor(anchor: &MerkleRootAnchor) -> WcResult<bool> {
 
     // Validate that the entry UUID is a valid hex string (Rekor UUIDs and
     // our offline IDs are both hex-encoded).
-    let is_valid_hex = anchor
-        .rekor_entry_id
-        .chars()
-        .all(|c| c.is_ascii_hexdigit());
+    let is_valid_hex = anchor.rekor_entry_id.chars().all(|c| c.is_ascii_hexdigit());
 
     if !is_valid_hex {
         return Err(WcError::new(