Fix AlbyInfoResponse structure and handle missing nodeAlias

Co-authored-by: ntheile <1273575+ntheile@users.noreply.github.com>

Author: Copilot

crates/lni/alby/api.rs

@@ -107,41 +107,29 @@ pub async fn get_info(config: AlbyConfig) -> Result<NodeInfo, ApiError> {
         reason: e.to_string(),
     })?;
 
-    // Get balance from Alby Hub API
+    // Get balance from Alby Hub API (this is optional, as balance might not be available)
     let balance_response = client
         .get(&format!("{}/balances", get_base_url(&config)))
         .send()
-        .await
-        .map_err(|e| ApiError::Http {
-            reason: e.to_string(),
-        })?;
-
-    if !balance_response.status().is_success() {
-        let status = balance_response.status();
-        let error_text = balance_response.text().await.unwrap_or_default();
-        return Err(ApiError::Http {
-            reason: format!("HTTP {} - {}", status, error_text),
-        });
-    }
-
-    let balances: AlbyBalancesResponse = balance_response.json().await.map_err(|e| ApiError::Json {
-        reason: e.to_string(),
-    })?;
+        .await;
 
-    // Convert Alby balance to msat (assuming it's in sats)
-    let balance_msat = balances.balances
-        .iter()
-        .find(|b| b.currency == "btc" || b.currency == "sats")
-        .map(|b| b.balance * 1000)
-        .unwrap_or(0);
+    let balance_msat = match balance_response {
+        Ok(response) if response.status().is_success() => {
+            match response.json::<AlbyBalancesResponse>().await {
+                Ok(balances) => balances.balance.unwrap_or(0) * 1000, // Convert sats to msats
+                Err(_) => 0, // If parsing fails, default to 0
+            }
+        }
+        _ => 0, // If request fails, default to 0
+    };
 
     Ok(NodeInfo {
-        alias: info.alias,
-        color: info.color,
-        pubkey: info.pubkey,
+        alias: info.node_alias.unwrap_or_else(|| "Alby Hub".to_string()),
+        color: "".to_string(), // Alby Hub doesn't provide color
+        pubkey: "".to_string(), // Alby Hub doesn't provide pubkey in info endpoint
         network: info.network,
-        block_height: info.block_height,
-        block_hash: info.block_hash,
+        block_height: 0, // Alby Hub doesn't provide block height in info endpoint
+        block_hash: "".to_string(), // Alby Hub doesn't provide block hash in info endpoint
         send_balance_msat: balance_msat,
         receive_balance_msat: 0, // Alby Hub doesn't distinguish send/receive balance
         ..Default::default()

crates/lni/alby/types.rs

@@ -2,24 +2,59 @@ use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
 pub struct AlbyInfoResponse {
-    pub alias: String,
-    pub color: String,
-    pub pubkey: String,
-    pub network: String,
-    pub block_height: i64,
-    pub block_hash: String,
+    #[serde(rename = "backendType")]
+    pub backend_type: String,
+    #[serde(rename = "setupCompleted")]
+    pub setup_completed: bool,
+    #[serde(rename = "oauthRedirect")]
+    pub oauth_redirect: bool,
+    pub running: bool,
+    pub unlocked: bool,
+    #[serde(rename = "albyAuthUrl")]
+    pub alby_auth_url: String,
+    #[serde(rename = "nextBackupReminder")]
+    pub next_backup_reminder: String,
+    #[serde(rename = "albyUserIdentifier")]
+    pub alby_user_identifier: String,
+    #[serde(rename = "albyAccountConnected")]
+    pub alby_account_connected: bool,
     pub version: String,
+    pub network: String,
+    #[serde(rename = "enableAdvancedSetup")]
+    pub enable_advanced_setup: bool,
+    #[serde(rename = "ldkVssEnabled")]
+    pub ldk_vss_enabled: bool,
+    #[serde(rename = "vssSupported")]
+    pub vss_supported: bool,
+    #[serde(rename = "startupState")]
+    pub startup_state: String,
+    #[serde(rename = "startupError")]
+    pub startup_error: String,
+    #[serde(rename = "startupErrorTime")]
+    pub startup_error_time: String,
+    #[serde(rename = "autoUnlockPasswordSupported")]
+    pub auto_unlock_password_supported: bool,
+    #[serde(rename = "autoUnlockPasswordEnabled")]
+    pub auto_unlock_password_enabled: bool,
+    pub currency: String,
+    pub relay: String,
+    #[serde(rename = "nodeAlias")]
+    pub node_alias: Option<String>, // This can be empty/missing, so using Option
+    #[serde(rename = "mempoolUrl")]
+    pub mempool_url: String,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct AlbyBalance {
     pub balance: i64,
-    pub currency: String,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct AlbyBalancesResponse {
-    pub balances: Vec<AlbyBalance>,
+    #[serde(rename = "balance")]
+    pub balance: Option<i64>,
+    #[serde(rename = "unit")]
+    pub unit: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]