feat: Phase 3-4 Weeks 5+6 — off-grid Bitcoin ops + emergency alert system

Bitcoin relay (mesh/bitcoin_relay.rs): - BlockHeaderCache: stores latest block headers from internet peers for SPV - RelayTracker: tracks in-flight TX and Lightning relay requests - Builder functions: block header announcements (Ed25519 signed), TX relay request/response, Lightning invoice relay/response - All amounts as u64 sats, never float - 4 unit tests Emergency alerts (mesh/alerts.rs): - AlertConfig: dead man switch settings, GPS, emergency contacts - DeadManSwitch: background timer, auto-trigger after configurable interval (default 6h), signed alert broadcast with GPS coordinates - check_in() resets timer, is_triggered() checks elapsed time - GPS as integer microdegrees (Coordinate type from message_types) - Disk persistence for config - 4 unit tests Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-03-17 02:26:07 +00:00
parent f504f08cd4
commit c6f1894e10
3 changed files with 620 additions and 0 deletions
@@ -0,0 +1,291 @@
+//! Emergency alert system and dead man's switch for mesh networking.
+//!
+//! The dead man's switch automatically broadcasts a signed alert with GPS
+//! coordinates if the node operator hasn't interacted with the system for
+//! a configurable interval (default 6 hours). Useful for remote/off-grid
+//! deployments where physical safety is a concern.
+
+use super::message_types::{
+    self, AlertPayload, AlertType, Coordinate, MeshMessageType, TypedEnvelope,
+};
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::RwLock;
+use tracing::{info, warn};
+
+/// Default dead man's switch interval: 6 hours.
+const DEFAULT_INTERVAL_SECS: u64 = 21600;
+
+/// How often the background task checks the switch (60 seconds).
+const CHECK_INTERVAL_SECS: u64 = 60;
+
+const ALERT_CONFIG_FILE: &str = "alert-config.json";
+
+/// Alert system configuration (persisted to disk).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AlertConfig {
+    /// Whether the dead man's switch is enabled.
+    pub dead_man_enabled: bool,
+    /// Interval in seconds before the switch triggers.
+    pub dead_man_interval_secs: u64,
+    /// Last known GPS coordinates (for inclusion in alerts).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_gps: Option<Coordinate>,
+    /// DIDs of peers to alert directly (in addition to mesh broadcast).
+    #[serde(default)]
+    pub emergency_contacts: Vec<String>,
+    /// Whether to automatically include GPS in dead man alerts.
+    pub auto_include_gps: bool,
+    /// Custom message to include in dead man alert.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub custom_message: Option<String>,
+}
+
+impl Default for AlertConfig {
+    fn default() -> Self {
+        Self {
+            dead_man_enabled: false,
+            dead_man_interval_secs: DEFAULT_INTERVAL_SECS,
+            last_gps: None,
+            emergency_contacts: Vec::new(),
+            auto_include_gps: true,
+            custom_message: None,
+        }
+    }
+}
+
+/// Load alert config from disk.
+pub async fn load_config(data_dir: &Path) -> Result<AlertConfig> {
+    let path = data_dir.join(ALERT_CONFIG_FILE);
+    if !path.exists() {
+        return Ok(AlertConfig::default());
+    }
+    let content = tokio::fs::read_to_string(&path)
+        .await
+        .context("Failed to read alert config")?;
+    let config: AlertConfig = serde_json::from_str(&content).unwrap_or_default();
+    Ok(config)
+}
+
+/// Save alert config to disk.
+pub async fn save_config(data_dir: &Path, config: &AlertConfig) -> Result<()> {
+    let content = serde_json::to_string_pretty(config)
+        .context("Failed to serialize alert config")?;
+    tokio::fs::write(data_dir.join(ALERT_CONFIG_FILE), content)
+        .await
+        .context("Failed to write alert config")?;
+    Ok(())
+}
+
+/// Dead man's switch state.
+pub struct DeadManSwitch {
+    config: RwLock<AlertConfig>,
+    last_activity: RwLock<Instant>,
+    triggered: RwLock<bool>,
+    data_dir: PathBuf,
+}
+
+impl DeadManSwitch {
+    /// Create a new dead man's switch.
+    pub async fn new(data_dir: &Path) -> Result<Self> {
+        let config = load_config(data_dir).await?;
+        Ok(Self {
+            config: RwLock::new(config),
+            last_activity: RwLock::new(Instant::now()),
+            triggered: RwLock::new(false),
+            data_dir: data_dir.to_path_buf(),
+        })
+    }
+
+    /// Record user activity (resets the timer).
+    pub async fn check_in(&self) {
+        *self.last_activity.write().await = Instant::now();
+        *self.triggered.write().await = false;
+    }
+
+    /// Check if the switch has been triggered.
+    pub async fn is_triggered(&self) -> bool {
+        let config = self.config.read().await;
+        if !config.dead_man_enabled {
+            return false;
+        }
+        let last = *self.last_activity.read().await;
+        let interval = Duration::from_secs(config.dead_man_interval_secs);
+        last.elapsed() > interval
+    }
+
+    /// Update configuration.
+    pub async fn configure(&self, config: AlertConfig) -> Result<()> {
+        save_config(&self.data_dir, &config).await?;
+        *self.config.write().await = config;
+        Ok(())
+    }
+
+    /// Get current configuration.
+    pub async fn get_config(&self) -> AlertConfig {
+        self.config.read().await.clone()
+    }
+
+    /// Get time remaining before trigger (in seconds), or 0 if triggered.
+    pub async fn time_remaining_secs(&self) -> u64 {
+        let config = self.config.read().await;
+        if !config.dead_man_enabled {
+            return u64::MAX;
+        }
+        let last = *self.last_activity.read().await;
+        let interval = Duration::from_secs(config.dead_man_interval_secs);
+        let elapsed = last.elapsed();
+        if elapsed > interval {
+            0
+        } else {
+            (interval - elapsed).as_secs()
+        }
+    }
+
+    /// Build the dead man alert payload.
+    pub async fn build_alert(&self) -> AlertPayload {
+        let config = self.config.read().await;
+        let message = config
+            .custom_message
+            .clone()
+            .unwrap_or_else(|| "Dead man's switch triggered — node operator unresponsive".to_string());
+
+        AlertPayload {
+            alert_type: AlertType::DeadMan,
+            message,
+            coordinate: if config.auto_include_gps {
+                config.last_gps.clone()
+            } else {
+                None
+            },
+        }
+    }
+
+    /// Build a signed alert envelope ready for mesh transmission.
+    pub async fn build_signed_alert(
+        &self,
+        signing_key: &ed25519_dalek::SigningKey,
+    ) -> Result<Vec<u8>> {
+        let alert = self.build_alert().await;
+        let payload = message_types::encode_payload(&alert)?;
+        let envelope = TypedEnvelope::new_signed(MeshMessageType::Alert, payload, signing_key);
+        envelope.to_wire()
+    }
+
+    /// Get the list of emergency contact DIDs.
+    pub async fn emergency_contacts(&self) -> Vec<String> {
+        self.config.read().await.emergency_contacts.clone()
+    }
+
+    /// Update GPS coordinates.
+    pub async fn update_gps(&self, coord: Coordinate) -> Result<()> {
+        let mut config = self.config.write().await;
+        config.last_gps = Some(coord);
+        save_config(&self.data_dir, &config).await?;
+        Ok(())
+    }
+
+    /// Get status info for RPC.
+    pub async fn status(&self) -> AlertStatus {
+        let config = self.config.read().await;
+        let triggered = self.is_triggered().await;
+        let remaining = self.time_remaining_secs().await;
+
+        AlertStatus {
+            dead_man_enabled: config.dead_man_enabled,
+            dead_man_interval_secs: config.dead_man_interval_secs,
+            triggered,
+            time_remaining_secs: remaining,
+            has_gps: config.last_gps.is_some(),
+            emergency_contacts: config.emergency_contacts.len(),
+        }
+    }
+}
+
+/// Status info returned via RPC.
+#[derive(Debug, Clone, Serialize)]
+pub struct AlertStatus {
+    pub dead_man_enabled: bool,
+    pub dead_man_interval_secs: u64,
+    pub triggered: bool,
+    pub time_remaining_secs: u64,
+    pub has_gps: bool,
+    pub emergency_contacts: usize,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_config_roundtrip() {
+        let dir = tempfile::tempdir().unwrap();
+        let config = AlertConfig {
+            dead_man_enabled: true,
+            dead_man_interval_secs: 3600,
+            last_gps: Some(Coordinate::from_degrees(30.2672, -97.7431, Some("Austin".into()))),
+            emergency_contacts: vec!["did:key:z6MkContact1".into()],
+            auto_include_gps: true,
+            custom_message: Some("Help!".into()),
+        };
+        save_config(dir.path(), &config).await.unwrap();
+        let loaded = load_config(dir.path()).await.unwrap();
+        assert!(loaded.dead_man_enabled);
+        assert_eq!(loaded.dead_man_interval_secs, 3600);
+        assert_eq!(loaded.emergency_contacts.len(), 1);
+    }
+
+    #[tokio::test]
+    async fn test_dead_man_not_triggered_when_disabled() {
+        let dir = tempfile::tempdir().unwrap();
+        let switch = DeadManSwitch::new(dir.path()).await.unwrap();
+        // Default config has dead_man_enabled = false
+        assert!(!switch.is_triggered().await);
+    }
+
+    #[tokio::test]
+    async fn test_check_in_resets_timer() {
+        let dir = tempfile::tempdir().unwrap();
+        let switch = DeadManSwitch::new(dir.path()).await.unwrap();
+        switch
+            .configure(AlertConfig {
+                dead_man_enabled: true,
+                dead_man_interval_secs: 1, // 1 second for test
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+
+        // Wait for trigger
+        tokio::time::sleep(Duration::from_secs(2)).await;
+        assert!(switch.is_triggered().await);
+
+        // Check in
+        switch.check_in().await;
+        assert!(!switch.is_triggered().await);
+    }
+
+    #[tokio::test]
+    async fn test_build_alert_payload() {
+        let dir = tempfile::tempdir().unwrap();
+        let switch = DeadManSwitch::new(dir.path()).await.unwrap();
+        switch
+            .configure(AlertConfig {
+                dead_man_enabled: true,
+                last_gps: Some(Coordinate::from_degrees(51.5074, -0.1278, None)),
+                auto_include_gps: true,
+                custom_message: Some("SOS".into()),
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+
+        let alert = switch.build_alert().await;
+        assert_eq!(alert.alert_type, AlertType::DeadMan);
+        assert_eq!(alert.message, "SOS");
+        assert!(alert.coordinate.is_some());
+    }
+}