added enhancements

Author: intelliDean

Cargo.lock

@@ -5,6 +5,7 @@ members = [
     "bin/flashstat-server",
     "bin/flashstat-tui",
     "bin/flashstat-simulate",
+    "bin/flashstat-watchtower-test",
     "crates/flashstat-core",
     "crates/flashstat-api",
     "crates/flashstat-db",

Cargo.toml

@@ -1,15 +1,16 @@
 # 🏮 FlashStat
 **The Transparency Layer for Unichain Soft-Finality**
 
-FlashStat provides real-time cryptographic confidence scores for Unichain's 200ms Flashblocks. It monitors the sequencer for equivocations (soft-reorgs) and provides an Ethereum-compatible JSON-RPC interface for wallets and DApps.
+FlashStat provides real-time cryptographic confidence scores for Unichain's 200ms Flashblocks. It monitors the sequencer for equivocations (soft-reorgs) and provides an Ethereum-compatible JSON-RPC interface with active fraud proof protection (Watchtower).
 
 ## 🏗 Architecture
 FlashStat is built as a high-performance Rust monorepo:
 
-- **`bin/flashstat`**: The primary indexing engine. Subscribes to 200ms Flashblocks via WebSockets.
-- **`bin/flashstat-server`**: JSON-RPC server providing confidence metrics.
-- **`crates/flashstat-core`**: Core monitoring and reorg detection logic.
-- **`crates/flashstat-db`**: Ultra-low latency persistence layer using redb (pure-Rust).
+- **`bin/flashstat-server`**: Main entry point. Runs the JSON-RPC server and the indexing engine.
+- **`bin/flashstat-tui`**: Terminal UI Dashboard for real-time monitoring and forensics.
+- **`bin/flashstat-simulate`**: Forensic simulation tool for testing detection and slashing.
+- **`crates/flashstat-core`**: Core monitoring, TEE verification, and reorg detection logic.
+- **`crates/flashstat-db`**: Ultra-low latency persistence layer using `redb`.
 - **`crates/flashstat-api`**: Type-safe JSON-RPC interface definitions.
 
 ## 🚀 Getting Started
@@ -21,37 +22,39 @@ FlashStat is built as a high-performance Rust monorepo:
 Edit `flashstat.toml` or set environment variables:
 ```toml
 [rpc]
-ws_url = "wss://sepolia.unichain.org"
-http_url = "https://sepolia.unichain.org"
+ws_url = "wss://unichain-sepolia..."
+http_url = "https://unichain-sepolia..."
 
-[storage]
-db_path = "./data/flashstat_db"
+[guardian]
+private_key = "0x..." # Or set FLASHSTAT__GUARDIAN__PRIVATE_KEY
+slashing_contract = "0x..."
 ```
 
-### Running the Monitor
-```bash
-cargo run -p flashstat
-```
+### Running the System
+1. **Start the Monitor & Server**:
+   ```bash
+   cargo run -p flashstat-server
+   ```
 
-### Running the API Server
-```bash
-cargo run -p flashstat-server
-```
+2. **Launch the Dashboard**:
+   ```bash
+   cargo run -p flashstat-tui
+   ```
 
 ## 📡 JSON-RPC API
 The API server runs by default on `127.0.0.1:9944`.
 
-### `flash_getConfidence`
-Returns the cryptographic confidence score for a given block hash.
-```bash
-curl -X POST -H "Content-Type: application/json" --data '{"jsonrpc":"2.0","method":"flash_getConfidence","params":["0x..."],"id":1}' http://localhost:9944
-```
-
-## 🛡 Security & Trust
-FlashStat calculates confidence based on:
-1. **Persistence**: Number of consecutive sub-blocks seen for a hash.
-2. **TEE Validity**: Verification of the Intel TDX sequencer signature (In Progress).
-3. **Equivocation Checks**: Detection of conflicting TEE signatures for the same slot.
+### Key Methods
+- `flash_getConfidence`: Returns confidence score for a hash.
+- `flash_getLatestBlock`: Returns the most recent processed block.
+- `flash_getSequencerRankings`: Returns reputation stats for all sequencers.
+- `flash_ingestBlock`: Manually submit a block for analysis (useful for external indexers).
+
+## 🛡 Security & Active Protection
+FlashStat doesn't just watch; it protects.
+- **TEE Attestation**: Verifies Intel TDX quotes for every sequencer signature.
+- **Reputation Scoring**: Tracks sequencer performance and reset streaks on reorgs.
+- **Active Watchtower**: Automatically submits fraud proofs to the `SlashingManager` contract upon detecting equivocation.
 
 ---
 Built with 🦀 by One Block Org.

README.md

@@ -24,6 +24,7 @@ pub struct FlashServer {
     total_blocks: Arc<AtomicU64>,
     total_reorgs: Arc<AtomicU64>,
     db_path: String,
+    monitor: Arc<flashstat_core::FlashMonitor>,
 }
 
 #[async_trait]
@@ -96,6 +97,13 @@ impl FlashApiServer for FlashServer {
         Ok(stats)
     }
 
+    async fn ingest_block(&self, block: ethers::types::Block<ethers::types::H256>) -> RpcResult<()> {
+        self.monitor
+            .handle_new_block(block)
+            .await
+            .map_err(|e| ErrorObjectOwned::owned(-32603, e.to_string(), None::<()>))
+    }
+
     async fn subscribe_blocks(
         &self,
         pending: jsonrpsee::PendingSubscriptionSink,
@@ -154,15 +162,17 @@ async fn main() -> eyre::Result<()> {
     let storage = std::sync::Arc::new(flashstat_db::RedbStorage::new(&config.storage.db_path)?);
 
     // 3. Initialize Monitor
-    let mut monitor =
+    let monitor = Arc::new(
         flashstat_core::FlashMonitor::new(config.clone(), storage.clone(), shutdown_tx.subscribe())
-            .await?;
+            .await?,
+    );
     let block_tx = monitor.block_notifier();
     let event_tx = monitor.event_notifier();
 
     // 3. Start Monitor in background
+    let monitor_clone = monitor.clone();
     tokio::spawn(async move {
-        if let Err(e) = monitor.run().await {
+        if let Err(e) = monitor_clone.run().await {
             tracing::error!("Monitor error: {:?}", e);
         }
     });
@@ -183,6 +193,7 @@ async fn main() -> eyre::Result<()> {
         total_blocks: Arc::new(AtomicU64::new(0)),
         total_reorgs: Arc::new(AtomicU64::new(initial_reorgs)),
         db_path: config.storage.db_path.clone(),
+        monitor: monitor.clone(),
     };
 
     // Stats listeners

bin/flashstat-server/src/main.rs

@@ -13,3 +13,4 @@ chrono = { workspace = true }
 flashstat-common = { path = "../../crates/flashstat-common" }
 flashstat-db = { path = "../../crates/flashstat-db" }
 clap = { version = "4", features = ["derive"] }
+jsonrpsee = { workspace = true }

bin/flashstat-simulate/Cargo.toml

@@ -1,17 +1,15 @@
 use clap::Parser;
-use ethers::types::{Address, Bytes, H256, U256};
+use ethers::types::{Address, Block, H256, Transaction, U256};
 use eyre::Result;
-use flashstat_common::{
-    ConflictAnalysis, DoubleSpendProof, EquivocationEvent, ReorgEvent, ReorgSeverity,
-};
-use flashstat_db::{FlashStorage, RedbStorage};
-use std::sync::Arc;
+use jsonrpsee::http_client::HttpClientBuilder;
+use jsonrpsee::core::client::ClientT;
+use std::time::Duration;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about = "🏮 FlashStat Forensic Simulation Tool", long_about = None)]
 struct Args {
-    #[arg(short, long, default_value = "flashstat.db")]
-    db_path: String,
+    #[arg(short, long, default_value = "http://127.0.0.1:9944")]
+    url: String,
 
     #[arg(short, long, default_value_t = 1)]
     count: usize,
@@ -23,65 +21,65 @@ struct Args {
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = Args::parse();
-    let storage: Arc<dyn FlashStorage> = Arc::new(RedbStorage::new(&args.db_path)?);
+    let client = HttpClientBuilder::default().build(&args.url)?;
 
     println!(
-        "🏮 Injecting {} synthetic {} events into {}...",
-        args.count, args.severity, args.db_path
+        "🏮 Simulating {} {} event(s) via RPC at {}...",
+        args.count, args.severity, args.url
     );
 
     for i in 0..args.count {
-        let block_number = 50_000_000 + i as u64;
-        let severity = match args.severity.as_str() {
-            "soft" => ReorgSeverity::Soft,
-            "deep" => ReorgSeverity::Deep,
-            _ => ReorgSeverity::Equivocation,
-        };
+        let block_number = 60_000_000 + i as u64;
+        let hash_1 = H256::random();
+        let hash_2 = H256::random();
 
-        let event = if severity == ReorgSeverity::Equivocation {
-            // Create a detailed equivocation with double-spend data
-            let ds_tx = DoubleSpendProof {
-                tx_hash_1: H256::random(),
-                tx_hash_2: H256::random(),
-                sender: Address::random(),
-                nonce: U256::from(1),
-            };
+        if args.severity == "equivocation" {
+            println!("⚔️  Simulating Equivocation at block #{}", block_number);
 
-            let conflict = ConflictAnalysis {
-                dropped_txs: vec![H256::random(), H256::random()],
-                double_spend_txs: vec![ds_tx],
-            };
+            // Block 1
+            let mut block_1 = create_mock_block(block_number, hash_1);
+            // Mock signature in extra_data (last 65 bytes)
+            let mut extra_1 = vec![0u8; 32];
+            extra_1.extend_from_slice(&[1u8; 65]);
+            block_1.extra_data = extra_1.into();
 
-            let equivocation = EquivocationEvent {
-                signer: Address::random(),
-                signature_1: Bytes::from(vec![1, 2, 3]),
-                signature_2: Bytes::from(vec![4, 5, 6]),
-                conflict_analysis: Some(conflict),
-            };
+            // Block 2 (conflicting)
+            let mut block_2 = create_mock_block(block_number, hash_2);
+            let mut extra_2 = vec![0u8; 32];
+            extra_2.extend_from_slice(&[2u8; 65]);
+            block_2.extra_data = extra_2.into();
+
+            // Ingest both
+            let _: () = client.request("flash_ingestBlock", (block_1,)).await?;
+            tokio::time::sleep(Duration::from_millis(500)).await;
+            let _: () = client.request("flash_ingestBlock", (block_2,)).await?;
 
-            ReorgEvent {
-                block_number: U256::from(block_number),
-                old_hash: H256::random(),
-                new_hash: H256::random(),
-                detected_at: chrono::Utc::now(),
-                severity,
-                equivocation: Some(equivocation),
-            }
         } else {
-            ReorgEvent {
-                block_number: U256::from(block_number),
-                old_hash: H256::random(),
-                new_hash: H256::random(),
-                detected_at: chrono::Utc::now(),
-                severity,
-                equivocation: None,
-            }
-        };
+            println!("📦 Simulating Standard Block #{}", block_number);
+            let block = create_mock_block(block_number, hash_1);
+            let _: () = client.request("flash_ingestBlock", (block,)).await?;
+        }
 
-        storage.save_reorg(event).await?;
-        println!("  ✅ Injected alert at block #{}", block_number);
+        tokio::time::sleep(Duration::from_millis(1000)).await;
     }
 
-    println!("🎉 Done!");
+    println!("🎉 Simulation complete!");
     Ok(())
 }
+
+fn create_mock_block(number: u64, hash: H256) -> Block<H256> {
+    let mut block = Block::default();
+    block.number = Some(number.into());
+    block.hash = Some(hash);
+    block.parent_hash = H256::random();
+    block.timestamp = U256::from(chrono::Utc::now().timestamp());
+    
+    // Add some mock transactions if needed
+    let mut tx = Transaction::default();
+    tx.hash = H256::random();
+    tx.from = Address::random();
+    tx.nonce = U256::from(0);
+    // block.transactions.push(tx); // Block<H256> only has hashes by default
+
+    block
+}

bin/flashstat-simulate/src/main.rs

@@ -0,0 +1,11 @@
+[package]
+name = "flashstat-watchtower-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tokio = { workspace = true }
+ethers = { workspace = true }
+eyre = { workspace = true }
+jsonrpsee = { workspace = true }
+chrono = { workspace = true }