Add enhanced logging and rollback detection

Node startup logging improvements:
- Log data directory path on state load
- Log current_round when loading DAG
- Log last_finalized_round when loading finality tracker
- Log total_supply and last_finalized_round when loading state engine
- Log transaction count when loading mempool
- Log when starting fresh (no state files found)

This will help diagnose restart issues by showing exactly what state
was loaded and from where.

Extended monitoring enhancements:
- Track previous round and supply across samples
- Detect round rollbacks (current < previous)
- Detect supply drops (>100k UDAG decrease)
- Alert with 🚨 when rollback or supply drop detected
- Output NODE:ROUND and NODE:SUPPLY for tracking

This will immediately alert if the network restarts from old state,
preventing undetected rollbacks like the one observed at 12:30:00.

Critical for mainnet safety - rollback detection is essential.

Author: UltraDAGcom

crates/ultradag-node/src/main.rs

@@ -125,44 +125,59 @@ async fn load_state(server: &NodeServer, data_dir: &std::path::Path) {
     let state_path = data_dir.join("state.json");
     let mempool_path = data_dir.join("mempool.json");
 
+    info!("Loading state from: {}", data_dir.display());
+
     if BlockDag::exists(&dag_path) {
         match BlockDag::load(&dag_path) {
             Ok(dag) => {
+                let current_round = dag.current_round();
+                info!("Loaded DAG from disk: current_round={}", current_round);
                 *server.dag.write().await = dag;
-                info!("Loaded DAG from disk");
             }
             Err(e) => warn!("Failed to load DAG: {}", e),
         }
+    } else {
+        info!("No DAG state file found, starting fresh");
     }
 
     if FinalityTracker::exists(&finality_path) {
         match FinalityTracker::load(&finality_path, 3) {
             Ok(fin) => {
+                let last_fin = fin.last_finalized_round();
+                info!("Loaded finality state from disk: last_finalized_round={}", last_fin);
                 *server.finality.write().await = fin;
-                info!("Loaded finality state from disk");
             }
             Err(e) => warn!("Failed to load finality: {}", e),
         }
+    } else {
+        info!("No finality state file found, starting fresh");
     }
 
     if StateEngine::exists(&state_path) {
         match StateEngine::load(&state_path) {
             Ok(state) => {
+                let supply = state.total_supply();
+                let last_round = state.last_finalized_round();
+                info!("Loaded state engine from disk: total_supply={}, last_finalized_round={:?}", supply, last_round);
                 *server.state.write().await = state;
-                info!("Loaded state engine from disk");
             }
             Err(e) => warn!("Failed to load state: {}", e),
         }
+    } else {
+        info!("No state file found, starting fresh");
     }
 
     if Mempool::exists(&mempool_path) {
         match Mempool::load(&mempool_path) {
             Ok(mp) => {
+                let tx_count = mp.len();
+                info!("Loaded mempool from disk: {} transactions", tx_count);
                 *server.mempool.write().await = mp;
-                info!("Loaded mempool from disk");
             }
             Err(e) => warn!("Failed to load mempool: {}", e),
         }
+    } else {
+        info!("No mempool file found, starting fresh");
     }
 }
 

scripts/extended_monitor.sh

@@ -16,6 +16,8 @@ echo "" | tee -a "$LOG_FILE"
 
 END_TIME=$(($(date +%s) + ($DURATION_HOURS * 3600)))
 SAMPLE=0
+PREV_ROUND=0
+PREV_SUPPLY=0
 
 while [ $(date +%s) -lt $END_TIME ]; do
     SAMPLE=$((SAMPLE + 1))
@@ -24,6 +26,9 @@ while [ $(date +%s) -lt $END_TIME ]; do
     echo "[$TIMESTAMP] Sample #$SAMPLE" | tee -a "$LOG_FILE"
 
     # Check all 4 nodes
+    ROUND_ROLLBACK=false
+    SUPPLY_DROP=false
+    
     for n in 1 2 3 4; do
         STATUS=$(curl -s --max-time 10 "https://ultradag-node-$n.fly.dev/status" 2>/dev/null)
 
@@ -52,12 +57,41 @@ try:
     issues_str = ' [' + ','.join(issues) + ']' if issues else ''
     
     print(f'  Node $n: round={dag:4d} fin={fin:4d} lag={lag:2d} peers={peers:2d} supply={supply:,.0f}{issues_str} {status_icon}')
+    
+    # Output round and supply for rollback detection (always output, will filter in shell)
+    print(f'NODE$n:ROUND:{dag}')
+    print(f'NODE$n:SUPPLY:{int(supply)}')
 except Exception as e:
     print(f'  Node $n: Parse error - {e}')
-" | tee -a "$LOG_FILE"
+" | tee -a "$LOG_FILE" | {
+                # Capture round and supply from node 1 output only
+                while IFS= read -r line; do
+                    if [[ $line == NODE1:ROUND:* ]]; then
+                        CURRENT_ROUND_CHECK=${line#NODE1:ROUND:}
+                        if [ $PREV_ROUND -gt 0 ] && [ $CURRENT_ROUND_CHECK -lt $PREV_ROUND ]; then
+                            ROUND_ROLLBACK=true
+                        fi
+                        PREV_ROUND=$CURRENT_ROUND_CHECK
+                    elif [[ $line == NODE1:SUPPLY:* ]]; then
+                        CURRENT_SUPPLY=${line#NODE1:SUPPLY:}
+                        if [ $PREV_SUPPLY -gt 0 ] && [ $CURRENT_SUPPLY -lt $((PREV_SUPPLY - 100000)) ]; then
+                            SUPPLY_DROP=true
+                        fi
+                        PREV_SUPPLY=$CURRENT_SUPPLY
+                    fi
+                done
+            }
         fi
     done
 
+    # Alert on rollback or supply drop
+    if [ "$ROUND_ROLLBACK" = true ]; then
+        echo "  🚨 ALERT: ROUND ROLLBACK DETECTED! Network may have restarted from old state." | tee -a "$LOG_FILE"
+    fi
+    if [ "$SUPPLY_DROP" = true ]; then
+        echo "  🚨 ALERT: SUPPLY DROP DETECTED! Possible state rollback or corruption." | tee -a "$LOG_FILE"
+    fi
+    
     # Check vertex density for recent rounds
     CURRENT_ROUND=$(curl -s "https://ultradag-node-1.fly.dev/status" 2>/dev/null | python3 -c "import sys,json; print(json.load(sys.stdin)['dag_round'])" 2>/dev/null)