Blockchain Simulator

Example Code

```rust
use sha2::{Sha256, Digest};
use chrono::prelude::*;
use std::fmt::{self, Debug, Formatter};

/// Represents a single block in the blockchain.
struct Block {
    id: u64,
    timestamp: i64,
    previous_hash: String,
    data: String, // Simplified: represents transactions or any data as a string
    nonce: u64,
    hash: String,
}

// Implement Debug for easy printing of Block details.
impl Debug for Block {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(
            f,
            "Block{{\n  id: {}\n  timestamp: {}\n  previous_hash: {}\n  data: {}\n  nonce: {}\n  hash: {}\n}}",
            self.id,
            self.timestamp,
            self.previous_hash,
            self.data,
            self.nonce,
            self.hash
        )
    }
}

impl Block {
    /// Creates a new Block instance.
    fn new(id: u64, previous_hash: String, data: String) -> Self {
        let now = Utc::now().timestamp();
        let mut block = Block {
            id,
            timestamp: now,
            previous_hash,
            data,
            nonce: 0,
            hash: String::new(), // Will be calculated after mining
        };
        block.hash = block.calculate_hash(); // Initial hash, re-calculated during mining
        block
    }

    /// Calculates the SHA-256 hash of the block's contents.
    /// This combines the block's metadata and data into a single string for hashing.
    fn calculate_hash(&self) -> String {
        let mut hasher = Sha256::new();
        let input = format!(
            "{}{}{}{}{}",
            self.id,
            self.timestamp,
            self.previous_hash,
            self.data,
            self.nonce
        );
        hasher.update(input.as_bytes());
        format!("{:x}", hasher.finalize())
    }
}

/// Represents the blockchain itself.
struct Blockchain {
    chain: Vec<Block>,
    difficulty: usize, // Number of leading zeros required for Proof of Work
}

impl Blockchain {
    /// Creates a new blockchain with a genesis block.
    fn new(difficulty: usize) -> Self {
        let mut blockchain = Blockchain {
            chain: Vec::new(),
            difficulty,
        };
        blockchain.create_genesis_block();
        blockchain
    }

    /// Creates the very first block in the chain (genesis block).
    fn create_genesis_block(&mut self) {
        let genesis_block = Block::new(0, "0".to_string(), "Genesis Block".to_string());
        self.chain.push(genesis_block);
        println!("Genesis block created.");
    }

    /// Returns a reference to the last block in the chain.
    fn get_last_block(&self) -> &Block {
        self.chain
            .last()
            .expect("Blockchain should have at least a genesis block.")
    }

    /// Mines a new block by finding a nonce that satisfies the Proof of Work difficulty.
    fn mine_block(&mut self, data: String) {
        let last_block = self.get_last_block();
        let mut new_block = Block::new(last_block.id + 1, last_block.hash.clone(), data);

        let target_prefix = "0".repeat(self.difficulty);

        println!("Mining block {}... (Difficulty: {})", new_block.id, self.difficulty);
        while !new_block.hash.starts_with(&target_prefix) {
            new_block.nonce += 1; // Increment nonce and recalculate hash until target is met
            new_block.hash = new_block.calculate_hash();
        }

        println!(
            "Block {} mined successfully! {{ Nonce: {}, Hash: {} }}",
            new_block.id,
            new_block.nonce,
            new_block.hash
        );
        self.chain.push(new_block);
    }

    /// Validates the entire blockchain by checking hash integrity and PoW for each block.
    fn is_chain_valid(&self) -> bool {
        for i in 1..self.chain.len() {
            let current_block = &self.chain[i];
            let previous_block = &self.chain[i - 1];

            // 1. Check if the current block's stored hash is actually its calculated hash
            if current_block.hash != current_block.calculate_hash() {
                println!("Chain Invalid: Block {} hash mismatch.", current_block.id);
                return false;
            }

            // 2. Check if the current block's previous_hash correctly points to the actual previous block's hash
            if current_block.previous_hash != previous_block.hash {
                println!("Chain Invalid: Block {} previous hash link broken.", current_block.id);
                return false;
            }

            // 3. Check if the current block's hash meets the Proof of Work difficulty
            let target_prefix = "0".repeat(self.difficulty);
            if !current_block.hash.starts_with(&target_prefix) {
                println!("Chain Invalid: Block {} does not meet PoW difficulty.", current_block.id);
                return false;
            }
        }
        true
    }
}

fn main() {
    println!("==========================================");
    println!("       Starting Basic Blockchain Simulator");
    println!("==========================================");

    let mut my_blockchain = Blockchain::new(2); // Set difficulty to 2 leading zeros

    println!("\n--- Mining new blocks ---");
    my_blockchain.mine_block("Transaction: Alice sends 10 BTC to Bob".to_string());
    my_blockchain.mine_block("Transaction: Bob sends 5 BTC to Carol".to_string());
    my_blockchain.mine_block("Transaction: Carol sends 2 BTC to David".to_string());

    println!("\n==========================================");
    println!("         Blockchain State");
    println!("==========================================");
    for block in &my_blockchain.chain {
        println!("{:?}", block);
    }

    println!("\nIs blockchain valid? {}", my_blockchain.is_chain_valid());

    // --- Demonstrate tampering --- 
    // Let's tamper with the data of Block 1 (index 1 in the vector)
    if let Some(block_to_tamper) = my_blockchain.chain.get_mut(1) {
        println!("\n--- Attempting to tamper with Block {} ---", block_to_tamper.id);
        let original_data = block_to_tamper.data.clone();
        block_to_tamper.data = "Transaction: Alice sends 1000000 BTC to Bob (TAMPERED)".to_string();
        // The hash of this block will now be incorrect because its data changed
        // We recalculate its hash, but it won't satisfy PoW or match subsequent blocks' previous_hash
        block_to_tamper.hash = block_to_tamper.calculate_hash(); 
        println!("Block {} data changed from '{}' to '{}'. New hash: {}",
                 block_to_tamper.id,
                 original_data,
                 block_to_tamper.data,
                 block_to_tamper.hash);
    }

    println!("\nIs blockchain valid after tampering? {}", my_blockchain.is_chain_valid());
    println!("\nNotice: Tampering with a block invalidates its hash, which then breaks the link to the next block, and often fails the PoW check for the tampered block itself, making the whole chain invalid.");

    println!("==========================================");
    println!("       Blockchain Simulator Finished");
    println!("==========================================");
}
```