feat(static): get first token image if no contract img (#398)

* feat(static): get first token image if no contract img

* fmt

* fix; static

Author: Larkooo

crates/server/src/handlers/static.rs

@@ -377,6 +377,36 @@ impl StaticHandler {
         Ok(query_result.0)
     }
 
+    async fn get_first_token_metadata(
+        &self,
+        contract_address: &str,
+    ) -> Result<(serde_json::Value, String)> {
+        // Find tokens with this contract address that have non-empty metadata
+        let pattern = format!("{}:%", contract_address);
+        let query_str = format!(
+            "SELECT metadata, id FROM {TOKENS_TABLE} WHERE id LIKE ? AND metadata != '' ORDER BY id LIMIT 100"
+        );
+        let query_results = sqlx::query_as::<_, (String, String)>(&query_str)
+            .bind(&pattern)
+            .fetch_all(&self.pool)
+            .await
+            .context("Failed to find any tokens for contract address")?;
+
+        // Try to find a token with valid metadata that contains an image field
+        for (metadata_str, token_id) in query_results {
+            if let Ok(metadata) = serde_json::from_str::<serde_json::Value>(&metadata_str) {
+                if metadata.get("image").is_some() {
+                    return Ok((metadata, token_id));
+                }
+            }
+        }
+
+        Err(anyhow::anyhow!(
+            "No tokens found with valid image metadata for contract address: {}",
+            contract_address
+        ))
+    }
+
     async fn check_if_image_outdated(
         &self,
         token_image_dir: &Utf8PathBuf,
@@ -506,16 +536,80 @@ impl StaticHandler {
         token_id: &str,
         db_timestamp: Option<&str>,
     ) -> anyhow::Result<String> {
+        let is_contract = !token_id.contains(':');
+
         // For both tokens and contracts, we can use the same query since contract address is the ID for contracts
         let query_str = format!("SELECT metadata FROM {TOKENS_TABLE} WHERE id = ?");
         let query_result = sqlx::query_as::<_, (String,)>(&query_str)
             .bind(token_id)
             .fetch_one(&self.pool)
-            .await
-            .context("Failed to fetch metadata from database")?;
+            .await;
+
+        // Try to get metadata and image_uri, with fallback for contracts
+        let metadata = match query_result {
+            Ok(result) => {
+                // Check if metadata is empty or whitespace-only
+                let metadata_str = result.0.trim();
+                if metadata_str.is_empty() {
+                    if is_contract {
+                        // Fallback: try to find first token with this contract address
+                        debug!(target: LOG_TARGET, contract_address = %token_id, "Empty metadata for contract, searching for first token");
+                        let (fallback_metadata, fallback_token_id) =
+                            self.get_first_token_metadata(token_id).await?;
+                        debug!(target: LOG_TARGET, contract_address = %token_id, fallback_token = %fallback_token_id, "Using fallback token image");
+                        fallback_metadata
+                    } else {
+                        return Err(anyhow::anyhow!("Empty metadata for token"));
+                    }
+                } else {
+                    // Try to parse the metadata
+                    match serde_json::from_str::<serde_json::Value>(metadata_str) {
+                        Ok(metadata) => {
+                            // Check if image field exists
+                            if metadata.get("image").is_some() {
+                                metadata
+                            } else if is_contract {
+                                // Fallback: try to find first token with this contract address
+                                debug!(target: LOG_TARGET, contract_address = %token_id, "No image found in contract metadata, searching for first token");
+                                let (fallback_metadata, fallback_token_id) =
+                                    self.get_first_token_metadata(token_id).await?;
+                                debug!(target: LOG_TARGET, contract_address = %token_id, fallback_token = %fallback_token_id, "Using fallback token image");
+                                fallback_metadata
+                            } else {
+                                return Err(anyhow::anyhow!("Image URL not found in metadata"));
+                            }
+                        }
+                        Err(e) => {
+                            if is_contract {
+                                // Fallback: try to find first token with this contract address
+                                debug!(target: LOG_TARGET, contract_address = %token_id, error = ?e, "Failed to parse contract metadata, searching for first token");
+                                let (fallback_metadata, fallback_token_id) =
+                                    self.get_first_token_metadata(token_id).await?;
+                                debug!(target: LOG_TARGET, contract_address = %token_id, fallback_token = %fallback_token_id, "Using fallback token image");
+                                fallback_metadata
+                            } else {
+                                return Err(anyhow::anyhow!("Failed to parse metadata: {}", e));
+                            }
+                        }
+                    }
+                }
+            }
+            Err(_) if is_contract => {
+                // Fallback: try to find first token with this contract address
+                debug!(target: LOG_TARGET, contract_address = %token_id, "Contract metadata not found, searching for first token");
+                let (fallback_metadata, fallback_token_id) =
+                    self.get_first_token_metadata(token_id).await?;
+                debug!(target: LOG_TARGET, contract_address = %token_id, fallback_token = %fallback_token_id, "Using fallback token image");
+                fallback_metadata
+            }
+            Err(e) => {
+                return Err(anyhow::anyhow!(
+                    "Failed to fetch metadata from database: {}",
+                    e
+                ));
+            }
+        };
 
-        let metadata: serde_json::Value =
-            serde_json::from_str(&query_result.0).context("Failed to parse metadata")?;
         let image_uri = metadata
             .get("image")
             .context("Image URL not found in metadata")?