Mastering Programming Languages for Blockchain Development: Python, JavaScript, and Rust

// Rust Ownership and Memory Safety Example
use std::collections::HashMap;

#[derive(Debug, Clone)]
struct BlockchainTransaction {
    from: String,
    to: String,
    amount: u64,
    timestamp: u64,
}

impl BlockchainTransaction {
    fn new(from: String, to: String, amount: u64) -> Self {
        Self {
            from,
            to,
            amount,
            timestamp: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs(),
        }
    }
    
    fn is_valid(&self) -> bool {
        !self.from.is_empty() && !self.to.is_empty() && self.amount > 0
    }
}

struct SimpleBlockchain {
    transactions: Vec<BlockchainTransaction>,
    balances: HashMap<String, u64>,
}

impl SimpleBlockchain {
    fn new() -> Self {
        Self {
            transactions: Vec::new(),
            balances: HashMap::new(),
        }
    }
    
    fn add_transaction(&mut self, transaction: BlockchainTransaction) -> Result<(), String> {
        if !transaction.is_valid() {
            return Err("Invalid transaction".to_string());
        }
        
        // Check balance
        let sender_balance = self.balances.get(&transaction.from).unwrap_or(&0);
        if *sender_balance < transaction.amount {
            return Err("Insufficient balance".to_string());
        }
        
        // Update balances
        self.balances.entry(transaction.from.clone())
            .and_modify(|balance| *balance -= transaction.amount);
        
        self.balances.entry(transaction.to.clone())
            .and_modify(|balance| *balance += transaction.amount)
            .or_insert(transaction.amount);
        
        self.transactions.push(transaction);
        Ok(())
    }
}

fn main() {
    let mut blockchain = SimpleBlockchain::new();
    
    // Initialize balances
    blockchain.balances.insert("Alice".to_string(), 100);
    blockchain.balances.insert("Bob".to_string(), 50);
    
    // Create and add transaction
    let tx = BlockchainTransaction::new(
        "Alice".to_string(),
        "Bob".to_string(),
        25
    );
    
    match blockchain.add_transaction(tx) {
        Ok(_) => println!("Transaction successful!"),
        Err(e) => println!("Transaction failed: {}", e),
    }
}