Building a Complete Blockchain

Let's build a complete, functional blockchain that combines all the concepts we've learned!

Project Structure

RUST
Copy
// Complete blockchain implementation
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

struct Transaction {
    from: String,
    to: String,
    amount: u64,
    fee: u64,
    timestamp: u64,
}

struct Block {
    index: u64,
    timestamp: u64,
    transactions: Vec<Transaction>,
    previous_hash: String,
    hash: String,
    nonce: u64,
}

struct Blockchain {
    blocks: Vec<Block>,
    balances: HashMap<String, u64>,
    pending_transactions: Vec<Transaction>,
}

Core Functionality

1. Genesis Block: First block in the chain
2. Add Transactions: Add to pending pool
3. Mine Block: Create new block with transactions
4. Validate Chain: Ensure blockchain integrity
5. Transfer Funds: Update balances

Complete Implementation

RUST
Copy
impl Blockchain {
    fn new() -> Self {
        let mut chain = Blockchain {
            blocks: Vec::new(),
            balances: HashMap::new(),
            pending_transactions: Vec::new(),
        };
        
        // Create genesis block
        let genesis = Block {
            index: 0,
            timestamp: current_timestamp(),
            transactions: Vec::new(),
            previous_hash: String::from("0"),
            hash: String::from("genesis"),
            nonce: 0,
        };
        
        chain.blocks.push(genesis);
        chain
    }
    
    fn add_transaction(&mut self, tx: Transaction) -> Result<(), String> {
        // Validate transaction
        let balance = self.balances.get(&tx.from).copied().unwrap_or(0);
        if balance < tx.amount + tx.fee {
            return Err(String::from("Insufficient balance"));
        }
        
        self.pending_transactions.push(tx);
        Ok(())
    }
    
    fn mine_block(&mut self, difficulty: usize) -> Result<(), String> {
        if self.pending_transactions.is_empty() {
            return Err(String::from("No transactions to mine"));
        }
        
        // Take transactions from pool
        let transactions: Vec<Transaction> = self.pending_transactions.drain(..).collect();
        
        // Create block
        let previous_block = self.blocks.last().unwrap();
        let mut block = Block {
            index: previous_block.index + 1,
            timestamp: current_timestamp(),
            transactions,
            previous_hash: previous_block.hash.clone(),
            hash: String::new(),
            nonce: 0,
        };
        
        // Mine block (simplified)
        block.hash = format!("block_hash_{}", block.index);
        
        // Update balances
        for tx in &block.transactions {
            *self.balances.entry(tx.from.clone()).or_insert(0) -= tx.amount + tx.fee;
            *self.balances.entry(tx.to.clone()).or_insert(0) += tx.amount;
        }
        
        self.blocks.push(block);
        Ok(())
    }
    
    fn get_balance(&self, address: &str) -> u64 {
        self.balances.get(address).copied().unwrap_or(0)
    }
    
    fn height(&self) -> usize {
        self.blocks.len()
    }
}

Usage Example

RUST
Copy
fn main() {
    let mut blockchain = Blockchain::new();
    
    // Initialize accounts
    blockchain.balances.insert(String::from("0xAlice"), 1000);
    blockchain.balances.insert(String::from("0xBob"), 500);
    
    // Add transactions
    blockchain.add_transaction(Transaction {
        from: String::from("0xAlice"),
        to: String::from("0xBob"),
        amount: 100,
        fee: 10,
        timestamp: current_timestamp(),
    }).unwrap();
    
    // Mine block
    blockchain.mine_block(2).unwrap();
    
    println!("Blockchain height: {}", blockchain.height());
    println!("Alice balance: {}", blockchain.get_balance("0xAlice"));
    println!("Bob balance: {}", blockchain.get_balance("0xBob"));
}

Next Steps

• Add cryptographic hashing
• Implement proper mining
• Add digital signatures
• Build P2P networking
• Create consensus mechanism