Rust for Blockchain in 2025: Libraries, Tools, and Best Practices

// Using RustCrypto for cryptographic operations
// Cargo.toml:
// [dependencies]
// sha2 = "0.10"
// ed25519-dalek = "2.0"
// x25519-dalek = "2.0"
// rand = "0.8"
// hex = "0.4"

use ed25519_dalek::{Keypair, Signer, SigningKey, Verifier, VerifyingKey};
use rand::rngs::OsRng;
use sha2::{Digest, Sha256};
use x25519_dalek::{EphemeralSecret, PublicKey};

fn main() {
    // Generate a hash
    let mut hasher = Sha256::new();
    hasher.update(b"hello world");
    let result = hasher.finalize();
    println!("SHA-256 hash: {}", hex::encode(result));
    
    // Generate an Ed25519 keypair for digital signatures
    let mut csprng = OsRng;
    let signing_key = SigningKey::generate(&mut csprng);
    let verifying_key = VerifyingKey::from(&signing_key);
    let keypair = Keypair {
        secret: signing_key,
        public: verifying_key,
    };
    
    // Sign a message
    let message = b"This is a blockchain transaction";
    let signature = keypair.sign(message);
    
    // Verify the signature
    match verifying_key.verify(message, &signature) {
        Ok(_) => println!("Signature is valid"),
        Err(e) => println!("Signature verification failed: {}", e),
    }
    
    // X25519 key exchange (for secure communication)
    let alice_secret = EphemeralSecret::random_from_rng(OsRng);
    let alice_public = PublicKey::from(&alice_secret);
    
    let bob_secret = EphemeralSecret::random_from_rng(OsRng);
    let bob_public = PublicKey::from(&bob_secret);
    
    // Shared secrets - should be the same for both parties
    let alice_shared = alice_secret.diffie_hellman(&bob_public);
    let bob_shared = bob_secret.diffie_hellman(&alice_public);
    
    println!("Alice's shared secret: {}", hex::encode(alice_shared.as_bytes()));
    println!("Bob's shared secret: {}", hex::encode(bob_shared.as_bytes()));
}

// Implementing a Merkle tree
// Cargo.toml:
// [dependencies]
// sha2 = "0.10"
// hex = "0.4"

use sha2::{Digest, Sha256};
use std::fmt;

// Merkle tree implementation
struct MerkleTree {
    nodes: Vec<Vec<Vec<u8>>>,
}

impl MerkleTree {
    // Create a new Merkle tree from a list of data blocks
    fn new(data: Vec<Vec<u8>>) -> Self {
        if data.is_empty() {
            return MerkleTree { nodes: vec![vec![]] };
        }
        
        // Hash the leaf nodes
        let mut current_level = data
            .iter()
            .map(|d| {
                let mut hasher = Sha256::new();
                hasher.update(d);
                hasher.finalize().to_vec()
            })
            .collect::<Vec<_>>();
        
        // Ensure even number of nodes at each level
        if current_level.len() % 2 == 1 {
            current_level.push(current_level.last().unwrap().clone());
        }
        
        let mut nodes = vec![current_level];
        
        // Build the tree bottom-up
        while nodes.last().unwrap().len() > 1 {
            let current_level = nodes.last().unwrap();
            let mut next_level = Vec::new();
            
            for i in (0..current_level.len()).step_by(2) {
                let mut hasher = Sha256::new();
                hasher.update(&current_level[i]);
                hasher.update(&current_level[i + 1]);
                next_level.push(hasher.finalize().to_vec());
            }
            
            // Ensure even number of nodes at each level
            if next_level.len() % 2 == 1 && next_level.len() > 1 {
                next_level.push(next_level.last().unwrap().clone());
            }
            
            nodes.push(next_level);
        }
        
        MerkleTree { nodes }
    }
    
    // Get the Merkle root hash
    fn root(&self) -> Option<&Vec<u8>> {
        self.nodes.last()?.first()
    }
    
    // Generate a Merkle proof for a specific leaf
    fn generate_proof(&self, leaf_index: usize) -> Vec<Vec<u8>> {
        let mut proof = Vec::new();
        let mut index = leaf_index;
        
        for level in 0..self.nodes.len() - 1 {
            let is_right = index % 2 == 0;
            let sibling_index = if is_right { index + 1 } else { index - 1 };
            
            if sibling_index < self.nodes[level].len() {
                proof.push(self.nodes[level][sibling_index].clone());
            }
            
            index /= 2;
        }
        
        proof
    }
    
    // Verify a Merkle proof
    fn verify_proof(root: &[u8], data: &[u8], proof: &[Vec<u8>], leaf_index: usize) -> bool {
        let mut hasher = Sha256::new();
        hasher.update(data);
        let mut hash = hasher.finalize().to_vec();
        
        let mut index = leaf_index;
        
        for sibling in proof {
            let mut hasher = Sha256::new();
            
            if index % 2 == 0 {
                hasher.update(&hash);
                hasher.update(sibling);
            } else {
                hasher.update(sibling);
                hasher.update(&hash);
            }
            
            hash = hasher.finalize().to_vec();
            index /= 2;
        }
        
        hash == root
    }
}

impl fmt::Debug for MerkleTree {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(f, "Merkle Tree:")?;
        
        for (i, level) in self.nodes.iter().enumerate().rev() {
            write!(f, "Level {}: ", i)?;
            for hash in level {
                write!(f, "{} ", hex::encode(&hash[..4]))?; // Show first 4 bytes for brevity
            }
            writeln!(f)?;
        }
        
        Ok(())
    }
}

fn main() {
    // Create some sample data
    let data = vec![
        b"Transaction 1".to_vec(),
        b"Transaction 2".to_vec(),
        b"Transaction 3".to_vec(),
        b"Transaction 4".to_vec(),
    ];
    
    // Build a Merkle tree
    let tree = MerkleTree::new(data.clone());
    println!("{:?}", tree);
    
    // Get the Merkle root
    if let Some(root) = tree.root() {
        println!("Merkle root: {}", hex::encode(root));
        
        // Generate a proof for the second transaction
        let leaf_index = 1;
        let proof = tree.generate_proof(leaf_index);
        
        println!("Proof for transaction {}: {:?}", leaf_index + 1, 
                 proof.iter().map(|h| hex::encode(&h[..4])).collect::<Vec<_>>());
        
        // Verify the proof
        let is_valid = MerkleTree::verify_proof(root, &data[leaf_index], &proof, leaf_index);
        println!("Proof verification: {}", if is_valid { "Valid" } else { "Invalid" });
    }
}

// Basic blockchain implementation
// Cargo.toml:
// [dependencies]
// sha2 = "0.10"
// chrono = "0.4"
// serde = { version = "1.0", features = ["derive"] }
// serde_json = "1.0"
// hex = "0.4"

use chrono::Utc;
use sha2::{Digest, Sha256};
use serde::{Deserialize, Serialize};
use std::fmt;

// Transaction structure
#[derive(Clone, Debug, Serialize, Deserialize)]
struct Transaction {
    sender: String,
    recipient: String,
    amount: f64,
    timestamp: i64,
    signature: Option<String>,
}

impl Transaction {
    fn new(sender: &str, recipient: &str, amount: f64) -> Self {
        Transaction {
            sender: sender.to_string(),
            recipient: recipient.to_string(),
            amount,
            timestamp: Utc::now().timestamp(),
            signature: None,
        }
    }
    
    fn calculate_hash(&self) -> String {
        let mut hasher = Sha256::new();
        let data = format!("{}{}{}{}", self.sender, self.recipient, self.amount, self.timestamp);
        hasher.update(data.as_bytes());
        hex::encode(hasher.finalize())
    }
    
    fn sign(&mut self, signature: &str) {
        self.signature = Some(signature.to_string());
    }
    
    fn is_valid(&self) -> bool {
        // In a real implementation, this would verify the signature
        self.signature.is_some()
    }
}

// Block structure
#[derive(Clone, Debug, Serialize, Deserialize)]
struct Block {
    index: u64,
    timestamp: i64,
    transactions: Vec<Transaction>,
    previous_hash: String,
    nonce: u64,
    hash: String,
}

impl Block {
    fn new(index: u64, transactions: Vec<Transaction>, previous_hash: &str) -> Self {
        let mut block = Block {
            index,
            timestamp: Utc::now().timestamp(),
            transactions,
            previous_hash: previous_hash.to_string(),
            nonce: 0,
            hash: String::new(),
        };
        
        block.hash = block.calculate_hash();
        block
    }
    
    fn calculate_hash(&self) -> String {
        let mut hasher = Sha256::new();
        let data = format!(
            "{}{}{}{}{}",
            self.index,
            self.timestamp,
            serde_json::to_string(&self.transactions).unwrap(),
            self.previous_hash,
            self.nonce
        );
        hasher.update(data.as_bytes());
        hex::encode(hasher.finalize())
    }
    
    fn mine_block(&mut self, difficulty: usize) {
        let target = "0".repeat(difficulty);
        
        while &self.hash[0..difficulty] != target {
            self.nonce += 1;
            self.hash = self.calculate_hash();
        }
        
        println!("Block mined: {}", self.hash);
    }
    
    fn has_valid_transactions(&self) -> bool {
        for transaction in &self.transactions {
            if !transaction.is_valid() {
                return false;
            }
        }
        true
    }
}

// Blockchain structure
#[derive(Debug)]
struct Blockchain {
    chain: Vec<Block>,
    difficulty: usize,
    pending_transactions: Vec<Transaction>,
    mining_reward: f64,
}

impl Blockchain {
    fn new(difficulty: usize, mining_reward: f64) -> Self {
        let mut blockchain = Blockchain {
            chain: Vec::new(),
            difficulty,
            pending_transactions: Vec::new(),
            mining_reward,
        };
        
        // Create genesis block
        blockchain.create_genesis_block();
        blockchain
    }
    
    fn create_genesis_block(&mut self) {
        let genesis_block = Block::new(0, Vec::new(), "0");
        self.chain.push(genesis_block);
    }
    
    fn get_latest_block(&self) -> &Block {
        self.chain.last().unwrap()
    }
    
    fn mine_pending_transactions(&mut self, mining_reward_address: &str) {
        // Create a reward transaction
        let reward_tx = Transaction::new("Blockchain", mining_reward_address, self.mining_reward);
        self.pending_transactions.push(reward_tx);
        
        // Create a new block
        let block = Block::new(
            self.chain.len() as u64,
            self.pending_transactions.clone(),
            &self.get_latest_block().hash,
        );
        
        // Mine the block
        let mut mineable_block = block;
        mineable_block.mine_block(self.difficulty);
        
        // Add the block to the chain
        println!("Block successfully mined!");
        self.chain.push(mineable_block);
        
        // Reset pending transactions
        self.pending_transactions = Vec::new();
    }
    
    fn add_transaction(&mut self, transaction: Transaction) -> bool {
        if transaction.sender.is_empty() || transaction.recipient.is_empty() {
            return false;
        }
        
        if !transaction.is_valid() {
            return false;
        }
        
        self.pending_transactions.push(transaction);
        true
    }
    
    fn get_balance(&self, address: &str) -> f64 {
        let mut balance = 0.0;
        
        for block in &self.chain {
            for transaction in &block.transactions {
                if transaction.sender == address {
                    balance -= transaction.amount;
                }
                
                if transaction.recipient == address {
                    balance += transaction.amount;
                }
            }
        }
        
        balance
    }
    
    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];
            
            // Verify hash
            if current_block.hash != current_block.calculate_hash() {
                return false;
            }
            
            // Verify previous hash reference
            if current_block.previous_hash != previous_block.hash {
                return false;
            }
            
            // Verify transactions
            if !current_block.has_valid_transactions() {
                return false;
            }
        }
        
        true
    }
}

fn main() {
    // Create a new blockchain
    let mut blockchain = Blockchain::new(2, 100.0);
    
    // Create and sign some transactions
    let mut tx1 = Transaction::new("Alice", "Bob", 50.0);
    tx1.sign("alice_signature"); // In a real implementation, this would be a cryptographic signature
    
    let mut tx2 = Transaction::new("Bob", "Charlie", 25.0);
    tx2.sign("bob_signature");
    
    // Add transactions to the blockchain
    blockchain.add_transaction(tx1);
    blockchain.add_transaction(tx2);
    
    // Mine pending transactions
    println!("Mining block...");
    blockchain.mine_pending_transactions("Miner");
    
    // Check balances
    println!("Alice's balance: {}", blockchain.get_balance("Alice"));
    println!("Bob's balance: {}", blockchain.get_balance("Bob"));
    println!("Charlie's balance: {}", blockchain.get_balance("Charlie"));
    println!("Miner's balance: {}", blockchain.get_balance("Miner"));
    
    // Validate the blockchain
    println!("Is blockchain valid? {}", blockchain.is_chain_valid());
}

// Solana smart contract (program)
// Cargo.toml:
// [dependencies]
// solana-program = "1.16"
// thiserror = "1.0"
// 
// [lib]
// crate-type = ["cdylib", "lib"]

use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    program_error::ProgramError,
    pubkey::Pubkey,
};
use thiserror::Error;

// Define program errors
#[derive(Error, Debug, Copy, Clone)]
pub enum TokenError {
    #[error("Token account already initialized")]
    AlreadyInitialized,
    #[error("Insufficient funds")]
    InsufficientFunds,
    #[error("Owner mismatch")]
    OwnerMismatch,
}

impl From<TokenError> for ProgramError {
    fn from(e: TokenError) -> Self {
        ProgramError::Custom(e as u32)
    }
}

// Define instruction types
#[derive(Debug)]
pub enum TokenInstruction {
    // Initialize a new token account
    InitializeAccount,
    // Transfer tokens from one account to another
    Transfer { amount: u64 },
}

// Program entrypoint
entrypoint!(process_instruction);

// Process instruction
pub fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    msg!("Token program entrypoint");
    
    // Parse instruction data
    let instruction = if instruction_data.is_empty() {
        return Err(ProgramError::InvalidInstructionData);
    } else {
        match instruction_data[0] {
            0 => TokenInstruction::InitializeAccount,
            1 => {
                if instruction_data.len() < 9 {
                    return Err(ProgramError::InvalidInstructionData);
                }
                let amount = u64::from_le_bytes(instruction_data[1..9].try_into().unwrap());
                TokenInstruction::Transfer { amount }
            }
            _ => return Err(ProgramError::InvalidInstructionData),
        }
    };
    
    // Process the instruction
    match instruction {
        TokenInstruction::InitializeAccount => {
            msg!("Instruction: InitializeAccount");
            process_initialize_account(program_id, accounts)
        }
        TokenInstruction::Transfer { amount } => {
            msg!("Instruction: Transfer");
            process_transfer(program_id, accounts, amount)
        }
    }
}

// Initialize a new token account
fn process_initialize_account(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
    let account_info_iter = &mut accounts.iter();
    
    // Get accounts
    let token_account = next_account_info(account_info_iter)?;
    let owner = next_account_info(account_info_iter)?;
    
    // Check program ownership
    if token_account.owner != program_id {
        return Err(ProgramError::IncorrectProgramId);
    }
    
    // Check signer
    if !owner.is_signer {
        return Err(ProgramError::MissingRequiredSignature);
    }
    
    // Initialize account data
    let mut account_data = token_account.data.borrow_mut();
    
    // Check if already initialized
    if !account_data.is_empty() {
        return Err(TokenError::AlreadyInitialized.into());
    }
    
    // Set owner and balance
    account_data[0..32].copy_from_slice(owner.key.as_ref());
    account_data[32..40].copy_from_slice(&0u64.to_le_bytes()); // Initial balance
    
    msg!("Token account initialized");
    Ok(())
}

// Transfer tokens between accounts
fn process_transfer(program_id: &Pubkey, accounts: &[AccountInfo], amount: u64) -> ProgramResult {
    let account_info_iter = &mut accounts.iter();
    
    // Get accounts
    let source = next_account_info(account_info_iter)?;
    let destination = next_account_info(account_info_iter)?;
    let owner = next_account_info(account_info_iter)?;
    
    // Check program ownership
    if source.owner != program_id || destination.owner != program_id {
        return Err(ProgramError::IncorrectProgramId);
    }
    
    // Check signer
    if !owner.is_signer {
        return Err(ProgramError::MissingRequiredSignature);
    }
    
    // Check source account owner
    let source_data = source.data.borrow();
    let source_owner = Pubkey::new(&source_data[0..32]);
    if source_owner != *owner.key {
        return Err(TokenError::OwnerMismatch.into());
    }
    
    // Check balance
    let source_balance = u64::from_le_bytes(source_data[32..40].try_into().unwrap());
    if source_balance < amount {
        return Err(TokenError::InsufficientFunds.into());
    }
    
    // Update balances
    let mut source_data = source.data.borrow_mut();
    let mut dest_data = destination.data.borrow_mut();
    
    // Decrease source balance
    let new_source_balance = source_balance - amount;
    source_data[32..40].copy_from_slice(&new_source_balance.to_le_bytes());
    
    // Increase destination balance
    let dest_balance = u64::from_le_bytes(dest_data[32..40].try_into().unwrap());
    let new_dest_balance = dest_balance + amount;
    dest_data[32..40].copy_from_slice(&new_dest_balance.to_le_bytes());
    
    msg!("Transfer complete");
    Ok(())
}

// Near smart contract
// Cargo.toml:
// [dependencies]
// near-sdk = "4.1"
// 
// [lib]
// crate-type = ["cdylib", "rlib"]

use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::UnorderedMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, PanicOnDefault};

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]
pub struct TokenContract {
    // Owner of the contract
    owner_id: AccountId,
    // Total supply of tokens
    total_supply: Balance,
    // Balances for each account
    balances: UnorderedMap<AccountId, Balance>,
}

#[near_bindgen]
impl TokenContract {
    #[init]
    pub fn new(owner_id: AccountId, total_supply: Balance) -> Self {
        let mut contract = Self {
            owner_id,
            total_supply,
            balances: UnorderedMap::new(b"b"),
        };
        
        // Assign all tokens to the owner
        let owner_id = contract.owner_id.clone();
        contract.balances.insert(&owner_id, &total_supply);
        
        contract
    }
    
    // Get balance of an account
    pub fn get_balance(&self, account_id: AccountId) -> Balance {
        self.balances.get(&account_id).unwrap_or(0)
    }
    
    // Transfer tokens to another account
    pub fn transfer(&mut self, receiver_id: AccountId, amount: Balance) {
        // Get the sender's account ID
        let sender_id = env::predecessor_account_id();
        
        // Check if sender has enough balance
        let sender_balance = self.get_balance(sender_id.clone());
        assert!(
            sender_balance >= amount,
            "Not enough balance to transfer"
        );
        
        // Update balances
        self.balances.insert(&sender_id, &(sender_balance - amount));
        
        let receiver_balance = self.get_balance(receiver_id.clone());
        self.balances.insert(&receiver_id, &(receiver_balance + amount));
        
        // Log the transfer
        env::log_str(&format!(
            "Transfer {} from {} to {}",
            amount, sender_id, receiver_id
        ));
    }
    
    // Get the total supply of tokens
    pub fn get_total_supply(&self) -> Balance {
        self.total_supply
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use near_sdk::test_utils::{accounts, VMContextBuilder};
    use near_sdk::{testing_env, VMContext};
    
    fn get_context(predecessor_account_id: AccountId) -> VMContext {
        VMContextBuilder::new()
            .predecessor_account_id(predecessor_account_id)
            .build()
    }
    
    #[test]
    fn test_new() {
        let context = get_context(accounts(1));
        testing_env!(context);
        
        let contract = TokenContract::new(accounts(1), 1000);
        assert_eq!(contract.get_total_supply(), 1000);
        assert_eq!(contract.get_balance(accounts(1)), 1000);
    }
    
    #[test]
    fn test_transfer() {
        let context = get_context(accounts(1));
        testing_env!(context);
        
        let mut contract = TokenContract::new(accounts(1), 1000);
        
        // Transfer tokens
        contract.transfer(accounts(2), 100);
        
        // Check balances
        assert_eq!(contract.get_balance(accounts(1)), 900);
        assert_eq!(contract.get_balance(accounts(2)), 100);
    }
    
    #[test]
    #[should_panic(expected = "Not enough balance to transfer")]
    fn test_transfer_not_enough_balance() {
        let context = get_context(accounts(1));
        testing_env!(context);
        
        let mut contract = TokenContract::new(accounts(1), 1000);
        
        // Try to transfer more than the balance
        contract.transfer(accounts(2), 1500);
    }
}