Merge rc1 into feature/economic-system-and-rewards: resolve conflicts in favor of production code

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

Author: Copilot

crates/bitcell-node/src/blockchain.rs

@@ -1,33 +1,17 @@
 ///! 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};
 use bitcell_crypto::{Hash256, PublicKey, SecretKey};
-use bitcell_economics::{COIN, INITIAL_BLOCK_REWARD, HALVING_INTERVAL, MAX_HALVINGS};
+use bitcell_economics::{COIN, INITIAL_BLOCK_REWARD, HALVING_INTERVAL};
 use bitcell_state::StateManager;
 use std::sync::{Arc, RwLock};
 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
@@ -39,9 +23,6 @@ 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>>,
 
@@ -65,7 +46,6 @@ 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,
@@ -101,64 +81,29 @@ 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| {
-            tracing::error!("Lock poisoned in height() - prior panic detected: {}", e);
+            eprintln!("Lock poisoned in height(): {}", 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| {
-            tracing::error!("Lock poisoned in latest_hash() - prior panic detected: {}", e);
+            eprintln!("Lock poisoned in latest_hash(): {}", 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| {
-            tracing::error!("Lock poisoned in get_block() - prior panic detected: {}", e);
+            eprintln!("Lock poisoned in get_block(): {}", 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)
@@ -167,8 +112,8 @@ impl Blockchain {
     /// Calculate block reward based on height (halves every HALVING_INTERVAL blocks)
     pub fn calculate_block_reward(height: u64) -> u64 {
         let halvings = height / HALVING_INTERVAL;
-        if halvings >= MAX_HALVINGS {
-            // After MAX_HALVINGS halvings, reward is effectively 0
+        if halvings >= 64 {
+            // After 64 halvings, reward is effectively 0
             return 0;
         }
         INITIAL_BLOCK_REWARD >> halvings
@@ -190,45 +135,24 @@ impl Blockchain {
 
         // Get current state root
         let state_root = {
-            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()
-            });
+            let state = self.state.read().unwrap();
             state.state_root
         };
 
-        // 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())
+        // 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()
         } else {
-            // 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())
+            // 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
         };
+        
+        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 {
@@ -283,27 +207,16 @@ impl Blockchain {
             return Err(crate::Error::Node("Invalid block signature".to_string()));
         }
 
-        // Verify VRF proof using proper VRF chaining
+        // Verify VRF
         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 {
-            // 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 mut input = block.header.prev_hash.as_bytes().to_vec();
+            input.extend_from_slice(&block.header.height.to_le_bytes());
+            input
         };
 
         let vrf_output = vrf_proof.verify(&block.header.proposer, &vrf_input)
@@ -337,23 +250,13 @@ impl Blockchain {
 
         // Apply transactions to state
         {
-            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()
-            });
+            let mut state = self.state.write().unwrap();
 
             // Apply block reward to proposer
             let reward = Self::calculate_block_reward(block_height);
             if reward > 0 {
-                match state.credit_account(*block.header.proposer.as_bytes(), reward) {
-                    Ok(_) => {
-                        tracing::info!("Block reward credited: {} units to proposer", reward);
-                    }
-                    Err(e) => {
-                        tracing::error!("Failed to credit block reward: {:?}", e);
-                        return Err(crate::Error::Node("Failed to credit block reward".to_string()));
-                    }
-                }
+                state.credit_account(*block.header.proposer.as_bytes(), reward);
+                println!("Block reward credited: {} units to proposer", reward);
             }
 
             for tx in &block.transactions {
@@ -366,54 +269,30 @@ impl Blockchain {
                 ) {
                     Ok(new_state_root) => {
                         // State updated successfully
-                        tracing::debug!("Transaction applied, new state root: {:?}", new_state_root);
+                        println!("Transaction applied, new state root: {:?}", new_state_root);
                     }
                     Err(e) => {
-                        tracing::warn!("Failed to apply transaction: {:?}", e);
+                        println!("Failed to apply transaction: {:?}", e);
                         // In production, this should rollback the entire block
                         // For now, we just skip the transaction
                     }
                 }
             }
         }
 
-        // 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_or_else(|e| {
-                tracing::error!("Lock poisoned in add_block() while storing block - prior panic detected: {}", e);
-                e.into_inner()
-            });
+            let mut blocks = self.blocks.write().unwrap();
             blocks.insert(block_height, block);
         }
 
         // Update chain tip
         {
-            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()
-            });
+            let mut height = self.height.write().unwrap();
             *height = block_height;
         }
         {
-            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()
-            });
+            let mut latest_hash = self.latest_hash.write().unwrap();
             *latest_hash = block_hash;
         }
 
@@ -446,10 +325,7 @@ impl Blockchain {
         }
 
         // Check nonce and balance
-        let state = self.state.read().unwrap_or_else(|e| {
-            tracing::error!("Lock poisoned in validate_transaction() - prior panic detected: {}", e);
-            e.into_inner()
-        });
+        let state = self.state.read().unwrap();
         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());
-        tracing::info!("Local Peer ID: {}", local_peer_id);
+        println!("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) {
-                                    tracing::info!("Received block via Gossipsub from {}", peer_id);
+                                    println!("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) {
-                                    tracing::info!("Received tx via Gossipsub from {}", peer_id);
+                                    println!("Received tx via Gossipsub from {}", peer_id);
                                     let _ = tx_tx.send(tx).await;
                                 }
                             }
                         }
                         SwarmEvent::NewListenAddr { address, .. } => {
-                            tracing::info!("DHT listening on {:?}", address);
+                            println!("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) {
-                                tracing::error!("Failed to publish block via Gossipsub: {:?}", e);
+                                eprintln!("Failed to publish block: {:?}", e);
                             }
                         }
                         Some(DhtCommand::BroadcastTransaction(data)) => {
                             if let Err(e) = swarm.behaviour_mut().gossipsub.publish(tx_topic.clone(), data) {
-                                tracing::error!("Failed to publish transaction via Gossipsub: {:?}", e);
+                                eprintln!("Failed to publish tx: {:?}", e);
                             }
                         }
                         None => break,