bc_utils/

utils.rs

//!
//! Utilities runner for the Blockchain Application.<br>
//! Functions used by the main menu.<br>
//! List, transact and reset the blockchain sample application.
//!

use bc_db::mongo_utils;
use block_chain::block::Block;
use block_chain::blockchain::Blockchain;
use block_chain::wallet::{Transaction, Wallet};
use bson::Document;
use chrono::Utc;
use mongodb::Collection;
use serde_json::json;
use std::collections::{BTreeMap, HashMap, VecDeque};
use std::error::Error;
use uuid::Uuid;

///
/// List blockchain data.
///
pub fn list_blockchain(blockchain: &Blockchain) -> String {
    // Build a JSON object that includes all the relevant information
    let response = json!({
        "message": "Listing Blockchain...",
        "is_valid": blockchain.is_chain_valid(),
        "length": blockchain.chain.len(),
        "mempool_size": blockchain.mempool.len(),
        "blockchain": blockchain // This will serialize the blockchain struct
    });

    // Serialize the JSON object into a string
    serde_json::to_string_pretty(&response).expect("Failed to serialize response to JSON")
}

///
/// View wallet data.
///
pub fn view_wallet(wallet: &Wallet, wallet_name: &str) -> String {
    // Build a JSON object that includes all the relevant information
    let response = json!({
        "message": format!("Listing Wallet {}...", wallet_name),
        "pending transactions": wallet.pending_transactions.len(),
        "wallet": wallet // This will serialize the wallet struct
    });

    // Serialize the JSON object into a string
    serde_json::to_string_pretty(&response).expect("Failed to serialize response to JSON")
}

///
/// Load blockchain data.
///
pub async fn load_blockchain(
    blocks_collection: &Collection<Document>,
    blockchain_collection: &Collection<Document>,
) -> Blockchain {
    // Load blockchain from database
    let result =
        mongo_utils::load_blockchain(blocks_collection.clone(), blockchain_collection.clone())
            .await;
    result.unwrap()
}

///
/// Get wallet data.
///
pub async fn get_wallet_addresses(wallets_collection: &Collection<Document>) -> Vec<String> {
    let wallet_map: HashMap<String, Wallet> = Result::expect(
        mongo_utils::load_wallets(wallets_collection.clone()).await,
        "Could not get wallets data",
    );

    let mut addresses: Vec<String> = wallet_map
        .iter()
        .map(|(_key, wallet)| wallet.address.clone())
        .collect();
    addresses.sort();
    addresses
}

///
/// Get pending transactions.
///
pub async fn get_pending_transactions(wallets_collection: &Collection<Document>) -> Vec<String> {
    let wallet_map: HashMap<String, Wallet> = Result::expect(
        mongo_utils::load_wallets(wallets_collection.clone()).await,
        "Could not get wallets data",
    );

    let pending_txrn_map: BTreeMap<String, VecDeque<Transaction>> = wallet_map
        .into_iter()
        .filter(|(_key, wallet)| !wallet.pending_transactions.is_empty())
        .map(|(_key, wallet)| (wallet.address.clone(), wallet.pending_transactions.clone()))
        .collect();

    if pending_txrn_map.len() == 0 {
        let mut no_trxns = Vec::new();
        no_trxns.push(String::from(" No Pending Transactions! "));
        return no_trxns;
    }

    pending_txrn_map
        .values()
        .flat_map(|deque| deque.iter())
        .map(|transaction| format!("{:?}", transaction)) // Adjust this line to your actual string conversion
        .collect()
}

///
/// Retrieve the last hash in the chain.
///
pub async fn get_previous_hash<'a>(
    blocks_collection: &'a Collection<Document>,
    blockchain_collection: &'a Collection<Document>,
) -> String {
    // Extract last_hash as &str
    let blockchain = load_blockchain(&blocks_collection, &blockchain_collection).await;
    let previous_hash: String = blockchain.get_last_hash().unwrap().to_string();
    previous_hash
}

///
/// Retrieve the tx_id from the existing map.
///
pub async fn get_transaction(
    tx_id: String,
    wallets_collection: Collection<Document>,
) -> Transaction {
    let result = get_pending_txrn(&wallets_collection.clone()).await;

    let mut transaction = None;
    for (_address, transactions) in &result {
        for txn in transactions.iter() {
            println!("txn.tx_id {} and given tx_id is {}", txn.tx_id, tx_id);
            println!("txn is {:?}", Some(txn));
            if txn.tx_id.to_string() == tx_id.to_string() {
                transaction = Some(txn);
            }
        }
    }
    transaction.unwrap().clone()
}

///
/// Crypto transaction from one wallet to another.
///
pub async fn send_crypto(
    amount: f64,
    fee: f64,
    blockchain: &mut Blockchain,
    sender_wallet: &mut Wallet,
    receiver_wallet: &mut Wallet,
    blocks_collection: Collection<Document>,
    wallets_collection: Collection<Document>,
    blockchain_collection: Collection<Document>,
) -> Result<String, Box<dyn Error>> {
    // Check amounts are valid
    let (is_valid, msg) = validate_txn(blockchain, sender_wallet, amount, fee).await;
    if is_valid == -1 {
        return Ok(msg);
    }

    // Process transaction
    sender_wallet.update_balance(-amount - fee);
    // receiver_wallet.update_balance(amount);

    let transaction = Transaction {
        tx_id: Uuid::new_v4().to_string(),
        sender: sender_wallet.address.clone(),
        receiver: receiver_wallet.address.clone(),
        amount,
        fee,
        timestamp: Utc::now().timestamp() as u64,
    };

    let mut transactions: Vec<Transaction> = Vec::new();
    transactions.push(transaction.clone());

    sender_wallet.add_pending_transaction(transaction.clone());

    blockchain.mempool.push(transaction);

    save_to_db(
        blockchain,
        sender_wallet,
        receiver_wallet,
        blocks_collection,
        wallets_collection,
        blockchain_collection,
    )
    .await?;

    Ok(String::from(
        "Transaction successful, blockchain and wallets updated",
    ))
}

///
/// Get pending transactions.
///
pub async fn get_pending_txrn(
    wallets_collection: &Collection<Document>,
) -> BTreeMap<String, VecDeque<Transaction>> {
    let wallet_map: HashMap<String, Wallet> = mongo_utils::load_wallets(wallets_collection.clone())
        .await
        .expect("Could not get wallets data");

    let pending_txrn_map: BTreeMap<String, VecDeque<Transaction>> = wallet_map
        .into_iter()
        .filter(|(_key, wallet)| !wallet.pending_transactions.is_empty())
        .map(|(_key, wallet)| (wallet.address.clone(), wallet.pending_transactions.clone()))
        .collect();

    pending_txrn_map
}

///
/// Mine a pending transaction.
///
pub async fn mine_crypto(
    blocks_collection: Collection<Document>,
    blockchain_collection: Collection<Document>,
) {
    // Extract last_hash as &str
    let blockchain = load_blockchain(&blocks_collection, &blockchain_collection).await;
    let previous_hash: &str = blockchain.get_last_hash().unwrap();

    // call mine_tranasaction
    let result = mine_transactions("The", previous_hash, 1).await;
    let (nonce, hash, msg) = match result {
        Ok((nonce, hash, formatted_message)) => (nonce, hash, formatted_message),
        Err(e) => {
            println!("Error occurred: {}", e);
            return;
        }
    };
    println!("Nonce: {nonce}, hash: {hash}\n{msg}");
}

///
/// Commit the mined transaction to the database.
///
pub async fn commit_mine_crypto(
    tx_id: String,
    blocks_collection: Collection<Document>,
    blockchain_collection: Collection<Document>,
    wallets_collection: Collection<Document>,
) -> String {
    // Extract last_hash as &str
    let mut blockchain = load_blockchain(&blocks_collection, &blockchain_collection).await;

    let transaction = get_transaction(tx_id.clone(), wallets_collection.clone()).await;
    let data = serde_json::to_value(&transaction).expect("Failed to serialize transaction");
    let mut transaction_data: Vec<Transaction> = Vec::new();
    transaction_data.push(transaction.clone());

    // create new block with txn
    let block = Block::new(
        blockchain.chain.len() as u64,
        Utc::now().timestamp() as u64,
        blockchain
            .chain
            .last()
            .map_or(String::from("0"), |block| block.hash.clone()),
        data,
        String::from("Miner1"),
        transaction_data,
    );

    // insert block in block_chain
    blockchain.chain.push(block.clone());

    // remove txn from mempool[]
    let mut index_to_remove = 0;
    for mp in blockchain.mempool.clone() {
        if mp.tx_id == tx_id {
            blockchain.mempool.remove(index_to_remove);
            break;
        }
        index_to_remove += 1;
    }

    // Load the wallets for txn updates.
    let mut sender_wallet =
        mongo_utils::load_wallet(wallets_collection.clone(), transaction.sender.as_str())
            .await
            .unwrap();
    let mut receiver_wallet =
        mongo_utils::load_wallet(wallets_collection.clone(), transaction.receiver.as_str())
            .await
            .unwrap();

    // sender wallet moving txn from pending[] to transactions[]
    sender_wallet.transfer_txn(tx_id);

    // update receiver wallet by
    receiver_wallet.add_transaction(transaction.clone());
    receiver_wallet.update_balance(transaction.amount);

    // save to db
    let result = save_to_db(
        &mut blockchain,
        &mut sender_wallet,
        &mut receiver_wallet,
        blocks_collection,
        wallets_collection,
        blockchain_collection,
    )
    .await;

    println!("Save db = {:?}", result);

    let response = json!({
        "message": "Listing New Block...",
        "block": block.clone()
    });

    // Serialize the JSON object into a string
    serde_json::to_string_pretty(&response).expect("Failed to serialize response to JSON")
}

///
/// Reset Sample Data.
///
pub async fn reset_sample_data(
    blocks_collection: &Collection<Document>,
    wallets_collection: &Collection<Document>,
    blockchain_collection: &Collection<Document>,
) -> Result<(), Box<dyn Error>> {
    let _ = mongo_utils::reset_sample_data(
        blockchain_collection.clone(),
        blocks_collection.clone(),
        wallets_collection.clone(),
    )
    .await;

    Ok(())
}

///
/// Validate the transaction details.
///
async fn validate_txn(
    blockchain: &Blockchain,
    wallet1: &mut Wallet,
    amount: f64,
    fee: f64,
) -> (i8, String) {
    let mut msg = String::from("All transaction checks OK");
    let mut is_valid = 0;
    let txn_amount = amount + fee;

    if wallet1.get_balance() < txn_amount {
        msg = String::from("Transaction failed: Insufficient balance\n");
        is_valid = -1;
    }

    if blockchain.chain.len() >= 10 {
        msg = String::from(
            "Due to system constraints no more than 10 blocks allowed\nPlease reset data.",
        );
        is_valid = -1;
    }

    if blockchain.mempool.len() >= 6 {
        msg = String::from(
            "Due to system constraints no more than 10 blocks allowed\nPlease reset data.",
        );
        is_valid = -1;
    }

    if wallet1.get_balance() < txn_amount {
        msg = String::from("Insufficient balance");
        is_valid = -1;
    }

    if txn_amount <= 0.0 || txn_amount.is_nan() || amount <= 0.0 || fee <= 0.0 {
        msg = String::from("Not a valid amount.");
        is_valid = -1;
    }

    (is_valid, msg)
}

///
/// Mine Transactions from Mempool.
///
async fn mine_transactions(
    data: &str,
    previous_hash: &str,
    difficulty: usize,
) -> Result<(u64, String, String), Box<dyn Error>> {
    let (nonce, hash) = crate::mining::mine_block(data, previous_hash, difficulty, None);
    let result = (
        nonce,
        hash.clone(),
        format!("\nMining completed!\nNonce: {:>2}, Hash: {}", nonce, hash),
    );

    Ok(result)
}

///
/// Save to mongoDB.
///
async fn save_to_db(
    blockchain: &mut Blockchain,
    wallet1: &mut Wallet,
    wallet2: &mut Wallet,
    blocks_collection: Collection<Document>,
    wallets_collection: Collection<Document>,
    blockchain_collection: Collection<Document>,
) -> Result<(), Box<dyn Error>> {
    // Save updated blockchain and wallets to MongoDB
    mongo_utils::save_blockchain(blockchain, blocks_collection, blockchain_collection).await?;
    mongo_utils::save_wallet(wallet1.clone(), wallets_collection.clone()).await?;
    mongo_utils::save_wallet(wallet2.clone(), wallets_collection).await?;

    Ok(())
}