Restore rc1 production code for all conflicting files

Co-authored-by: Steake <530040+Steake@users.noreply.github.com>

Author: Copilot

crates/bitcell-node/src/blockchain.rs

@@ -1,4 +1,10 @@
 ///! Blockchain manager for block production and validation
+///!
+///! Provides functionality for:
+///! - Block production with VRF-based proposer selection
+///! - Block validation including signature, VRF, and transaction verification
+///! - Transaction indexing for efficient lookups
+///! - State management with Merkle tree root computation
 
 use crate::{Result, MetricsRegistry};
 use bitcell_consensus::{Block, BlockHeader, Transaction, BattleProof};
@@ -11,7 +17,17 @@ use std::collections::HashMap;
 /// Genesis block height
 pub const GENESIS_HEIGHT: u64 = 0;
 
+/// Transaction location in blockchain (block height and index within block)
+#[derive(Clone, Debug)]
+pub struct TxLocation {
+    pub block_height: u64,
+    pub tx_index: usize,
+}
+
 /// Blockchain manager
+/// 
+/// Maintains the blockchain state including blocks, transactions, and state root.
+/// Provides O(1) transaction lookup via hash index.
 #[derive(Clone)]
 pub struct Blockchain {
     /// Current chain height
@@ -23,6 +39,9 @@ pub struct Blockchain {
     /// Block storage (height -> block)
     blocks: Arc<RwLock<HashMap<u64, Block>>>,
 
+    /// Transaction hash index for O(1) lookups (tx_hash -> location)
+    tx_index: Arc<RwLock<HashMap<Hash256, TxLocation>>>,
+    
     /// State manager
     state: Arc<RwLock<StateManager>>,
 
@@ -46,6 +65,7 @@ impl Blockchain {
             height: Arc::new(RwLock::new(GENESIS_HEIGHT)),
             latest_hash: Arc::new(RwLock::new(genesis_hash)),
             blocks: Arc::new(RwLock::new(blocks)),
+            tx_index: Arc::new(RwLock::new(HashMap::new())),
             state: Arc::new(RwLock::new(StateManager::new())),
             metrics,
             secret_key,
@@ -81,29 +101,64 @@ impl Blockchain {
     }
 
     /// Get current chain height
+    /// 
+    /// Returns the current blockchain height. If the lock is poisoned (indicating
+    /// a prior panic while holding the lock), logs an error and recovers the guard.
     pub fn height(&self) -> u64 {
         *self.height.read().unwrap_or_else(|e| {
-            eprintln!("Lock poisoned in height(): {}", e);
+            tracing::error!("Lock poisoned in height() - prior panic detected: {}", e);
             e.into_inner()
         })
     }
 
     /// Get latest block hash
+    ///
+    /// Returns the hash of the latest block. If the lock is poisoned (indicating
+    /// a prior panic while holding the lock), logs an error and recovers the guard.
     pub fn latest_hash(&self) -> Hash256 {
         *self.latest_hash.read().unwrap_or_else(|e| {
-            eprintln!("Lock poisoned in latest_hash(): {}", e);
+            tracing::error!("Lock poisoned in latest_hash() - prior panic detected: {}", e);
             e.into_inner()
         })
     }
 
     /// Get block by height
+    ///
+    /// Returns the block at the specified height, or None if not found.
+    /// If the lock is poisoned, logs an error and recovers the guard.
     pub fn get_block(&self, height: u64) -> Option<Block> {
         self.blocks.read().unwrap_or_else(|e| {
-            eprintln!("Lock poisoned in get_block(): {}", e);
+            tracing::error!("Lock poisoned in get_block() - prior panic detected: {}", e);
             e.into_inner()
         }).get(&height).cloned()
     }
-    
+
+    /// Get transaction by hash using the O(1) hash index
+    ///
+    /// Returns the transaction and its location (block height, index) if found.
+    /// This is significantly more efficient than linear scan for large blockchains.
+    pub fn get_transaction_by_hash(&self, tx_hash: &Hash256) -> Option<(Transaction, TxLocation)> {
+        // First, look up the location in the index
+        let location = {
+            let index = self.tx_index.read().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in get_transaction_by_hash() - prior panic detected: {}", e);
+                e.into_inner()
+            });
+            index.get(tx_hash).cloned()
+        };
+
+        // Then retrieve the actual transaction from the block
+        if let Some(loc) = location {
+            if let Some(block) = self.get_block(loc.block_height) {
+                if loc.tx_index < block.transactions.len() {
+                    return Some((block.transactions[loc.tx_index].clone(), loc));
+                }
+            }
+        }
+
+        None
+    }
+
     /// Get state manager (read-only access)
     pub fn state(&self) -> Arc<RwLock<StateManager>> {
         Arc::clone(&self.state)
@@ -135,24 +190,45 @@ impl Blockchain {
 
         // Get current state root
         let state_root = {
-            let state = self.state.read().unwrap();
+            let state = self.state.read().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in produce_block() while reading state - prior panic detected: {}", e);
+                e.into_inner()
+            });
             state.state_root
         };
-        
-        // Generate VRF output and proof
-        // Input is previous block's VRF output (or hash if genesis)
-        let vrf_input = if new_height == 1 {
-            prev_hash.as_bytes().to_vec()
+
+        // Generate VRF output and proof using proper VRF chaining
+        // For genesis block (height 1), use previous hash as input
+        // For all other blocks, use the previous block's VRF output for chaining
+        //
+        // NOTE: We generate VRF proof while holding the blocks lock to prevent race conditions
+        // where the blockchain state could change between reading the VRF input and using it.
+        let (vrf_output, vrf_proof_bytes) = if new_height == 1 {
+            // First block after genesis uses genesis hash as VRF input
+            let vrf_input = prev_hash.as_bytes().to_vec();
+            let (vrf_output, vrf_proof) = self.secret_key.vrf_prove(&vrf_input);
+            (vrf_output, bincode::serialize(&vrf_proof).unwrap_or_default())
         } else {
-            // In a real implementation, we'd get the previous block's VRF output
-            // For now, we mix the prev_hash with the height to ensure uniqueness
-            let mut input = prev_hash.as_bytes().to_vec();
-            input.extend_from_slice(&new_height.to_le_bytes());
-            input
+            // Use previous block's VRF output for proper VRF chaining
+            // This ensures verifiable randomness chain where each output
+            // deterministically derives from the previous output
+            let blocks = self.blocks.read().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in produce_block() - prior panic detected: {}", e);
+                e.into_inner()
+            });
+
+            let vrf_input = if let Some(prev_block) = blocks.get(&current_height) {
+                prev_block.header.vrf_output.to_vec()
+            } else {
+                // Fallback if previous block not found (shouldn't happen in normal operation)
+                tracing::warn!("Previous block {} not found for VRF chaining, using hash fallback", current_height);
+                prev_hash.as_bytes().to_vec()
+            };
+
+            // Generate VRF proof while still holding the read lock to prevent race conditions
+            let (vrf_output, vrf_proof) = self.secret_key.vrf_prove(&vrf_input);
+            (vrf_output, bincode::serialize(&vrf_proof).unwrap_or_default())
         };
-        
-        let (vrf_output, vrf_proof) = self.secret_key.vrf_prove(&vrf_input);
-        let vrf_proof_bytes = bincode::serialize(&vrf_proof).unwrap_or_default();
 
         // Create block header
         let header = BlockHeader {
@@ -206,17 +282,28 @@ impl Blockchain {
         if block.signature.verify(&block.header.proposer, header_hash.as_bytes()).is_err() {
             return Err(crate::Error::Node("Invalid block signature".to_string()));
         }
-        
-        // Verify VRF
+
+        // Verify VRF proof using proper VRF chaining
         let vrf_proof: bitcell_crypto::VrfProof = bincode::deserialize(&block.header.vrf_proof)
             .map_err(|_| crate::Error::Node("Invalid VRF proof format".to_string()))?;
-            
+
+        // Reconstruct VRF input using the same chaining logic as produce_block
         let vrf_input = if block.header.height == 1 {
+            // First block after genesis uses genesis hash as VRF input
             block.header.prev_hash.as_bytes().to_vec()
         } else {
-            let mut input = block.header.prev_hash.as_bytes().to_vec();
-            input.extend_from_slice(&block.header.height.to_le_bytes());
-            input
+            // Use previous block's VRF output for proper VRF chaining
+            let blocks = self.blocks.read().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in validate_block() - prior panic detected: {}", e);
+                e.into_inner()
+            });
+            if let Some(prev_block) = blocks.get(&(block.header.height - 1)) {
+                prev_block.header.vrf_output.to_vec()
+            } else {
+                return Err(crate::Error::Node(
+                    format!("Previous block {} not found for VRF verification", block.header.height - 1)
+                ));
+            }
         };
 
         let vrf_output = vrf_proof.verify(&block.header.proposer, &vrf_input)
@@ -250,7 +337,10 @@ impl Blockchain {
 
         // Apply transactions to state
         {
-            let mut state = self.state.write().unwrap();
+            let mut state = self.state.write().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in add_block() while writing state - prior panic detected: {}", e);
+                e.into_inner()
+            });
 
             // Apply block reward to proposer
             let reward = Self::calculate_block_reward(block_height);
@@ -287,19 +377,43 @@ impl Blockchain {
             }
         }
 
+        // Index transactions for O(1) lookup
+        {
+            let mut tx_index = self.tx_index.write().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in add_block() while indexing transactions - prior panic detected: {}", e);
+                e.into_inner()
+            });
+            for (idx, tx) in block.transactions.iter().enumerate() {
+                tx_index.insert(tx.hash(), TxLocation {
+                    block_height,
+                    tx_index: idx,
+                });
+            }
+            tracing::debug!("Indexed {} transactions in block {}", block.transactions.len(), block_height);
+        }
+        
         // Store block
         {
-            let mut blocks = self.blocks.write().unwrap();
+            let mut blocks = self.blocks.write().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in add_block() while storing block - prior panic detected: {}", e);
+                e.into_inner()
+            });
             blocks.insert(block_height, block);
         }
 
         // Update chain tip
         {
-            let mut height = self.height.write().unwrap();
+            let mut height = self.height.write().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in add_block() while updating height - prior panic detected: {}", e);
+                e.into_inner()
+            });
             *height = block_height;
         }
         {
-            let mut latest_hash = self.latest_hash.write().unwrap();
+            let mut latest_hash = self.latest_hash.write().unwrap_or_else(|e| {
+                tracing::error!("Lock poisoned in add_block() while updating latest hash - prior panic detected: {}", e);
+                e.into_inner()
+            });
             *latest_hash = block_hash;
         }
 
@@ -332,7 +446,10 @@ impl Blockchain {
         }
 
         // Check nonce and balance
-        let state = self.state.read().unwrap();
+        let state = self.state.read().unwrap_or_else(|e| {
+            tracing::error!("Lock poisoned in validate_transaction() - prior panic detected: {}", e);
+            e.into_inner()
+        });
         if let Some(account) = state.get_account(tx.from.as_bytes()) {
             if tx.nonce != account.nonce {
                 return Err(crate::Error::Node(format!(

crates/bitcell-node/src/dht.rs

@@ -50,7 +50,7 @@ impl DhtManager {
         // 1. Create libp2p keypair
         let keypair = Self::bitcell_to_libp2p_keypair(secret_key)?;
         let local_peer_id = PeerId::from(keypair.public());
-        println!("Local Peer ID: {}", local_peer_id);
+        tracing::info!("Local Peer ID: {}", local_peer_id);
 
         // 2. Create transport
         let mut swarm = SwarmBuilder::with_existing_identity(keypair.clone())
@@ -136,18 +136,18 @@ impl DhtManager {
                         })) => {
                             if message.topic == block_topic.hash() {
                                 if let Ok(block) = bincode::deserialize::<Block>(&message.data) {
-                                    println!("Received block via Gossipsub from {}", peer_id);
+                                    tracing::info!("Received block via Gossipsub from {}", peer_id);
                                     let _ = block_tx.send(block).await;
                                 }
                             } else if message.topic == tx_topic.hash() {
                                 if let Ok(tx) = bincode::deserialize::<Transaction>(&message.data) {
-                                    println!("Received tx via Gossipsub from {}", peer_id);
+                                    tracing::info!("Received tx via Gossipsub from {}", peer_id);
                                     let _ = tx_tx.send(tx).await;
                                 }
                             }
                         }
                         SwarmEvent::NewListenAddr { address, .. } => {
-                            println!("DHT listening on {:?}", address);
+                            tracing::info!("DHT listening on {:?}", address);
                         }
                         _ => {}
                     },
@@ -157,12 +157,12 @@ impl DhtManager {
                         }
                         Some(DhtCommand::BroadcastBlock(data)) => {
                             if let Err(e) = swarm.behaviour_mut().gossipsub.publish(block_topic.clone(), data) {
-                                eprintln!("Failed to publish block: {:?}", e);
+                                tracing::error!("Failed to publish block via Gossipsub: {:?}", e);
                             }
                         }
                         Some(DhtCommand::BroadcastTransaction(data)) => {
                             if let Err(e) = swarm.behaviour_mut().gossipsub.publish(tx_topic.clone(), data) {
-                                eprintln!("Failed to publish tx: {:?}", e);
+                                tracing::error!("Failed to publish transaction via Gossipsub: {:?}", e);
                             }
                         }
                         None => break,