From a867cc616aabc0a17e20004fec00fe4839345c4a Mon Sep 17 00:00:00 2001
From: 4NK Dev <dev@4nkweb.com>
Date: Sat, 20 Sep 2025 02:27:13 +0000
Subject: [PATCH] fix faucet empty commitment

---
 src/main.rs | 43 +++++++++++++++++++++++++++----------------
 src/sync.rs | 12 ++++++++++++
 2 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 42c9d9f..707c605 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -610,24 +610,35 @@ async fn main() -> Result<()> {
         let do_faucet = config.bootstrap_faucet;
         let our_sp = our_sp_address.to_string();
         tokio::spawn(async move {
+            log::info!("Starting bootstrap connection and sync");
             if let Err(e) = crate::sync::bootstrap_connect_and_sync(bs_url.clone()).await {
                 log::warn!("bootstrap failed: {}", e);
-            } else if do_faucet && !peer_store::faucet_already_done(&bs_url) {
-                let env = sdk_common::network::Envelope {
-                    flag: sdk_common::network::AnkFlag::Faucet,
-                    content: serde_json::json!({
-                        "sp_address": our_sp,
-                        "commitment": "",
-                        "error": null
-                    }).to_string(),
-                };
-                if let Ok((mut ws, _)) = tokio_tungstenite::connect_async(&bs_url).await {
-                    let _ = ws
-                        .send(tokio_tungstenite::tungstenite::Message::Text(
-                            serde_json::to_string(&env).unwrap(),
-                        ))
-                        .await;
-                    peer_store::mark_faucet_done(&bs_url);
+            } else {
+                log::info!("Bootstrap sync successful, checking faucet request");
+                if do_faucet && !peer_store::faucet_already_done(&bs_url) {
+                    log::info!("Sending faucet request to bootstrap");
+                    let env = sdk_common::network::Envelope {
+                        flag: sdk_common::network::AnkFlag::Faucet,
+                        content: serde_json::json!({
+                            "sp_address": our_sp,
+                            "commitment": "",
+                            "error": null
+                        }).to_string(),
+                    };
+                    if let Ok((mut ws, _)) = tokio_tungstenite::connect_async(&bs_url).await {
+                        log::info!("Connected to bootstrap for faucet request");
+                        let _ = ws
+                            .send(tokio_tungstenite::tungstenite::Message::Text(
+                                serde_json::to_string(&env).unwrap(),
+                            ))
+                            .await;
+                        log::info!("Faucet request sent to bootstrap");
+                        peer_store::mark_faucet_done(&bs_url);
+                    } else {
+                        log::error!("Failed to connect to bootstrap for faucet request");
+                    }
+                } else {
+                    log::info!("Faucet request skipped: do_faucet={}, already_done={}", do_faucet, peer_store::faucet_already_done(&bs_url));
                 }
             }
         });
diff --git a/src/sync.rs b/src/sync.rs
index fb14159..4850c87 100644
--- a/src/sync.rs
+++ b/src/sync.rs
@@ -6,16 +6,21 @@ use crate::peers;
 use sdk_common::network::{AnkFlag, Envelope};
 
 pub async fn bootstrap_connect_and_sync(bootstrap_url: String) -> Result<()> {
+    log::info!("Connecting to bootstrap: {}", bootstrap_url);
     let (ws_stream, _) = tokio_tungstenite::connect_async(&bootstrap_url).await?;
+    log::info!("Connected to bootstrap successfully");
     let (mut write, mut read) = ws_stream.split();
 
     // Send our empty Sync (we don't share, just ask implicitly)
     let ask = Envelope { flag: AnkFlag::Sync, content: serde_json::json!({"peers": []}).to_string() };
+    log::info!("Sending sync request to bootstrap");
     write.send(Message::Text(serde_json::to_string(&ask)?)).await?;
 
     // Wait one message for peer list
     if let Some(Ok(Message::Text(txt))) = read.next().await {
+        log::info!("Received response from bootstrap: {}", txt);
         if let Ok(env) = serde_json::from_str::<Envelope>(&txt) {
+            log::info!("Parsed envelope with flag: {:?}", env.flag);
             if let AnkFlag::Sync = env.flag {
                 if let Ok(val) = serde_json::from_str::<serde_json::Value>(&env.content) {
                     if let Some(arr) = val.get("peers").and_then(|v| v.as_array()) {
@@ -26,10 +31,17 @@ pub async fn bootstrap_connect_and_sync(bootstrap_url: String) -> Result<()> {
                         }
                     }
                 }
+            } else {
+                log::warn!("Bootstrap response is not a Sync message, flag: {:?}", env.flag);
             }
+        } else {
+            log::warn!("Failed to parse bootstrap response as envelope: {}", txt);
         }
+    } else {
+        log::warn!("No response received from bootstrap");
     }
 
     // Optionally request one faucet if configured is handled by higher layer
+    log::info!("Bootstrap sync completed");
     Ok(())
 }