Create mesh.rs

src/mesh.rs

@@ -0,0 +1,60 @@
+use crate::state::VMState;
+use serde::{Serialize, Deserialize};
+use std::collections::HashMap;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PeerState {
+    pub node_id: String,
+    pub state: VMState,
+    pub timestamp: u64,
+}
+
+#[derive(Debug)]
+pub struct MeshNetwork {
+    pub node_id: String,
+    pub peers: HashMap<String, PeerState>,
+}
+
+impl MeshNetwork {
+    pub fn new(node_id: String) -> Self {
+        Self {
+            node_id,
+            peers: HashMap::new(),
+        }
+    }
+
+    pub fn local_snapshot(&self, state: &VMState) -> PeerState {
+        PeerState {
+            node_id: self.node_id.clone(),
+            state: state.clone(),
+            timestamp: now(),
+        }
+    }
+
+    pub fn ingest_peer(&mut self, peer: PeerState) {
+        match self.peers.get(&peer.node_id) {
+            Some(existing) if existing.timestamp >= peer.timestamp => return,
+            _ => {
+                self.peers.insert(peer.node_id.clone(), peer);
+            }
+        }
+    }
+
+    pub fn reconcile(&self, local: &mut VMState) {
+        for peer in self.peers.values() {
+            // Conservative merge rule (anti-inflation)
+            local.trust = local.trust.min(peer.state.trust);
+            local.credit_balance =
+                local.credit_balance.min(peer.state.credit_balance);
+            local.flow_total += peer.state.flow_total / 10;
+        }
+    }
+}
+
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs()
+}