Address PR feedback: fix compilation errors and documentation

claude · claude · commit 5012d674b191 · 2025-11-23T10:39:15.000Z
Changes:
- Fix documentation inconsistencies: Update FINAL_REPORT.md to consistently use 92-95% completion status
- Fix benchmark compilation: Update ca_benchmarks.rs to use new Grid API (Grid::new(), Position-based setters, evolve_grid function)
- Fix error handling in storage.rs: Replace private rocksdb::Error::new() calls with String-based error handling
diff --git a/crates/bitcell-ca/benches/ca_benchmarks.rs b/crates/bitcell-ca/benches/ca_benchmarks.rs
@@ -0,0 +1,87 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
+use bitcell_ca::{Grid, Glider, GliderPattern, Battle, Position, Cell};
+use bitcell_ca::rules::evolve_grid;
+
+fn grid_creation_benchmark(c: &mut Criterion) {
+    c.bench_function("grid_1024x1024_creation", |b| {
+        b.iter(|| Grid::new())
+    });
+}
+
+fn grid_evolution_benchmark(c: &mut Criterion) {
+    let mut grid = Grid::new();
+    // Add some initial patterns
+    grid.set(Position::new(100, 100), Cell::alive(128));
+    grid.set(Position::new(100, 101), Cell::alive(128));
+    grid.set(Position::new(101, 100), Cell::alive(128));
+
+    c.bench_function("grid_evolution_step", |b| {
+        b.iter(|| {
+            let g = grid.clone();
+            black_box(evolve_grid(&g))
+        });
+    });
+}
+
+fn glider_creation_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("glider_creation");
+
+    let patterns = vec![
+        ("Standard", GliderPattern::Standard),
+        ("Lightweight", GliderPattern::Lightweight),
+        ("Middleweight", GliderPattern::Middleweight),
+        ("Heavyweight", GliderPattern::Heavyweight),
+    ];
+
+    for (name, pattern) in patterns {
+        group.bench_with_input(BenchmarkId::from_parameter(name), &pattern, |b, pattern| {
+            b.iter(|| {
+                let glider = Glider::new(*pattern, Position::new(100, 100));
+                let mut grid = Grid::new();
+                grid.set_pattern(glider.position, &glider.cells());
+                black_box(grid)
+            });
+        });
+    }
+    group.finish();
+}
+
+fn battle_simulation_benchmark(c: &mut Criterion) {
+    c.bench_function("battle_simulation", |b| {
+        let glider_a = Glider::new(GliderPattern::Heavyweight, Position::new(200, 200));
+        let glider_b = Glider::new(GliderPattern::Standard, Position::new(800, 800));
+        let battle = Battle::new(glider_a, glider_b);
+
+        b.iter(|| {
+            let b = battle.clone();
+            black_box(b.simulate())
+        });
+    });
+}
+
+fn parallel_grid_evolution_benchmark(c: &mut Criterion) {
+    let mut grid = Grid::new();
+    // Add scattered patterns for realistic parallel workload
+    for i in 0..10 {
+        for j in 0..10 {
+            grid.set(Position::new(i * 100, j * 100), Cell::alive(200));
+        }
+    }
+
+    c.bench_function("parallel_evolution_step", |b| {
+        b.iter(|| {
+            let g = grid.clone();
+            black_box(evolve_grid(&g))
+        });
+    });
+}
+
+criterion_group!(
+    benches,
+    grid_creation_benchmark,
+    grid_evolution_benchmark,
+    glider_creation_benchmark,
+    battle_simulation_benchmark,
+    parallel_grid_evolution_benchmark
+);
+criterion_main!(benches);
diff --git a/crates/bitcell-state/src/storage.rs b/crates/bitcell-state/src/storage.rs
@@ -0,0 +1,235 @@
+/// RocksDB persistent storage layer
+/// Provides durable storage for blocks, state, and chain data
+
+use rocksdb::{DB, Options, WriteBatch, IteratorMode};
+use std::path::Path;
+use std::sync::Arc;
+use serde::{Serialize, Deserialize};
+
+use crate::{Account, BondState};
+
+/// Database column families
+const CF_BLOCKS: &str = "blocks";
+const CF_HEADERS: &str = "headers";
+const CF_TRANSACTIONS: &str = "transactions";
+const CF_ACCOUNTS: &str = "accounts";
+const CF_BONDS: &str = "bonds";
+const CF_STATE_ROOTS: &str = "state_roots";
+const CF_CHAIN_INDEX: &str = "chain_index";
+
+/// Persistent storage manager
+pub struct StorageManager {
+    db: Arc<DB>,
+}
+
+impl StorageManager {
+    /// Open or create a database
+    pub fn new<P: AsRef<Path>>(path: P) -> Result<Self, rocksdb::Error> {
+        let mut opts = Options::default();
+        opts.create_if_missing(true);
+        opts.create_missing_column_families(true);
+        
+        let cfs = vec![
+            CF_BLOCKS,
+            CF_HEADERS,
+            CF_TRANSACTIONS,
+            CF_ACCOUNTS,
+            CF_BONDS,
+            CF_STATE_ROOTS,
+            CF_CHAIN_INDEX,
+        ];
+        
+        let db = DB::open_cf(&opts, path, cfs)?;
+        
+        Ok(Self {
+            db: Arc::new(db),
+        })
+    }
+
+    /// Store a block header
+    pub fn store_header(&self, height: u64, hash: &[u8], header: &[u8]) -> Result<(), String> {
+        let cf = self.db.cf_handle(CF_HEADERS)
+            .ok_or_else(|| "Headers column family not found".to_string())?;
+
+        let mut batch = WriteBatch::default();
+        // Store by height
+        batch.put_cf(cf, height.to_be_bytes(), header);
+        // Store by hash
+        batch.put_cf(cf, hash, header);
+        // Update chain index
+        let index_cf = self.db.cf_handle(CF_CHAIN_INDEX)
+            .ok_or_else(|| "Chain index column family not found".to_string())?;
+        batch.put_cf(index_cf, b"latest_height", height.to_be_bytes());
+        batch.put_cf(index_cf, b"latest_hash", hash);
+
+        self.db.write(batch).map_err(|e| e.to_string())
+    }
+
+    /// Store a full block
+    pub fn store_block(&self, hash: &[u8], block: &[u8]) -> Result<(), String> {
+        let cf = self.db.cf_handle(CF_BLOCKS)
+            .ok_or_else(|| "Blocks column family not found".to_string())?;
+        self.db.put_cf(cf, hash, block).map_err(|e| e.to_string())
+    }
+
+    /// Get block by hash
+    pub fn get_block(&self, hash: &[u8]) -> Result<Option<Vec<u8>>, String> {
+        let cf = self.db.cf_handle(CF_BLOCKS)
+            .ok_or_else(|| "Blocks column family not found".to_string())?;
+        self.db.get_cf(cf, hash).map_err(|e| e.to_string())
+    }
+
+    /// Get header by height
+    pub fn get_header_by_height(&self, height: u64) -> Result<Option<Vec<u8>>, String> {
+        let cf = self.db.cf_handle(CF_HEADERS)
+            .ok_or_else(|| "Headers column family not found".to_string())?;
+        self.db.get_cf(cf, height.to_be_bytes()).map_err(|e| e.to_string())
+    }
+
+    /// Get header by hash
+    pub fn get_header_by_hash(&self, hash: &[u8]) -> Result<Option<Vec<u8>>, String> {
+        let cf = self.db.cf_handle(CF_HEADERS)
+            .ok_or_else(|| "Headers column family not found".to_string())?;
+        self.db.get_cf(cf, hash).map_err(|e| e.to_string())
+    }
+
+    /// Get latest chain height
+    pub fn get_latest_height(&self) -> Result<Option<u64>, String> {
+        let cf = self.db.cf_handle(CF_CHAIN_INDEX)
+            .ok_or_else(|| "Chain index column family not found".to_string())?;
+        if let Some(bytes) = self.db.get_cf(cf, b"latest_height").map_err(|e| e.to_string())? {
+            let height = u64::from_be_bytes(
+                bytes.as_slice().try_into()
+                    .map_err(|_| "Invalid height data".to_string())?
+            );
+            Ok(Some(height))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Store account state
+    pub fn store_account(&self, address: &[u8], account: &Account) -> Result<(), String> {
+        let cf = self.db.cf_handle(CF_ACCOUNTS)
+            .ok_or_else(|| "Accounts column family not found".to_string())?;
+        let data = bincode::serialize(account)
+            .map_err(|e| format!("Serialization error: {}", e))?;
+        self.db.put_cf(cf, address, data).map_err(|e| e.to_string())
+    }
+
+    /// Get account state
+    pub fn get_account(&self, address: &[u8]) -> Result<Option<Account>, String> {
+        let cf = self.db.cf_handle(CF_ACCOUNTS)
+            .ok_or_else(|| "Accounts column family not found".to_string())?;
+        if let Some(data) = self.db.get_cf(cf, address).map_err(|e| e.to_string())? {
+            Ok(bincode::deserialize(&data).ok())
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Store bond state
+    pub fn store_bond(&self, miner_id: &[u8], bond: &BondState) -> Result<(), String> {
+        let cf = self.db.cf_handle(CF_BONDS)
+            .ok_or_else(|| "Bonds column family not found".to_string())?;
+        let data = bincode::serialize(bond)
+            .map_err(|e| format!("Serialization error: {}", e))?;
+        self.db.put_cf(cf, miner_id, data).map_err(|e| e.to_string())
+    }
+
+    /// Get bond state
+    pub fn get_bond(&self, miner_id: &[u8]) -> Result<Option<BondState>, String> {
+        let cf = self.db.cf_handle(CF_BONDS)
+            .ok_or_else(|| "Bonds column family not found".to_string())?;
+        if let Some(data) = self.db.get_cf(cf, miner_id).map_err(|e| e.to_string())? {
+            Ok(bincode::deserialize(&data).ok())
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Store state root for a given height
+    pub fn store_state_root(&self, height: u64, root: &[u8]) -> Result<(), String> {
+        let cf = self.db.cf_handle(CF_STATE_ROOTS)
+            .ok_or_else(|| "State roots column family not found".to_string())?;
+        self.db.put_cf(cf, height.to_be_bytes(), root).map_err(|e| e.to_string())
+    }
+
+    /// Get state root for a given height
+    pub fn get_state_root(&self, height: u64) -> Result<Option<Vec<u8>>, String> {
+        let cf = self.db.cf_handle(CF_STATE_ROOTS)
+            .ok_or_else(|| "State roots column family not found".to_string())?;
+        self.db.get_cf(cf, height.to_be_bytes()).map_err(|e| e.to_string())
+    }
+
+    /// Prune old blocks (keep last N blocks)
+    pub fn prune_old_blocks(&self, keep_last: u64) -> Result<(), String> {
+        let latest = self.get_latest_height()?.unwrap_or(0);
+        if latest <= keep_last {
+            return Ok(());
+        }
+
+        let prune_until = latest - keep_last;
+        let _cf = self.db.cf_handle(CF_BLOCKS)
+            .ok_or_else(|| "Blocks column family not found".to_string())?;
+
+        // This is a simplified version - in production would iterate and delete
+        for height in 0..prune_until {
+            if let Some(header_data) = self.get_header_by_height(height)? {
+                // Extract hash and delete block
+                // (Simplified - would need proper header deserialization)
+                let _ = header_data;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Get database statistics
+    pub fn get_stats(&self) -> Result<String, rocksdb::Error> {
+        self.db.property_value("rocksdb.stats")
+            .map(|v| v.unwrap_or_else(|| "No stats available".to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_storage_manager_creation() {
+        let temp_dir = TempDir::new().unwrap();
+        let result = StorageManager::new(temp_dir.path());
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_store_and_retrieve_header() {
+        let temp_dir = TempDir::new().unwrap();
+        let storage = StorageManager::new(temp_dir.path()).unwrap();
+        
+        let height = 100u64;
+        let hash = b"test_hash_12345678";
+        let header = b"test_header_data";
+        
+        storage.store_header(height, hash, header).unwrap();
+        
+        let retrieved = storage.get_header_by_height(height).unwrap();
+        assert_eq!(retrieved.as_deref(), Some(header.as_slice()));
+        
+        let by_hash = storage.get_header_by_hash(hash).unwrap();
+        assert_eq!(by_hash.as_deref(), Some(header.as_slice()));
+    }
+
+    #[test]
+    fn test_latest_height() {
+        let temp_dir = TempDir::new().unwrap();
+        let storage = StorageManager::new(temp_dir.path()).unwrap();
+        
+        assert_eq!(storage.get_latest_height().unwrap(), None);
+        
+        storage.store_header(42, b"hash", b"header").unwrap();
+        assert_eq!(storage.get_latest_height().unwrap(), Some(42));
+    }
+}
diff --git a/docs/FINAL_REPORT.md b/docs/FINAL_REPORT.md
