bc_cli/

main.rs

//!
//! Main CLI runner for the Blockchain Application.<br>
//! Function main.<br>
//! List, transact and reset the blockchain sample application.
//!

use bc_db::mongo_utils;
use bc_utils::utils;
use block_chain::wallet::Wallet;
use bson::Document;
use mongodb::{Client, Collection};
use std::collections::HashMap;
use std::error::Error;
use std::io::{self, Write};
use tokio;

///
/// Function main for the CLI blockchain application.
///
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Initialize MongoDB client
    let client = Client::with_uri_str("mongodb://localhost:27017").await?;
    let db = client.database("blockchain_db");

    // Initialize collections
    let blocks_collection = db.collection("blocks");
    let wallets_collection = db.collection("wallets");
    let blockchain_collection = db.collection("blockchain");

    // Load blockchain from database
    let mut blockchain =
        mongo_utils::load_blockchain(blocks_collection.clone(), blockchain_collection.clone())
            .await?;
    // Validate and print the blockchain validity
    let output = utils::list_blockchain(&blockchain);
    println!("{}", output);

    loop {
        // Display the menu options
        print!("\n\n");
        println!("*************** ITEMS ***************");
        println!("*   1. List Blockchain              *");
        println!("*   2. View Wallet Details          *");
        println!("*   3. Send Crypto Currency         *");
        println!("*   4. Mine Transactions            *");
        println!("*   5. Reset Sample Data            *");
        println!("*   6. Exit                         *");
        println!("*************************************\n");
        print!("Input Choice: ");

        // Flush stdout to ensure the prompt is displayed
        io::stdout().flush().unwrap();

        // Read the user's input
        let mut input = String::new();
        io::stdin()
            .read_line(&mut input)
            .expect("Failed to read line");

        // Trim and parse the input
        let input = input.trim();
        match input.parse::<u32>() {
            Ok(choice) => match choice {
                1 => {
                    let blockchain = mongo_utils::load_blockchain(
                        blocks_collection.clone(),
                        blockchain_collection.clone(),
                    )
                    .await?;
                    let output = utils::list_blockchain(&blockchain);
                    println!("{}", output);
                }
                2 => {
                    // Load wallets from database
                    let wallet_map: HashMap<String, Wallet> =
                        mongo_utils::load_wallets(wallets_collection.clone()).await?;
                    list_wallets(&wallet_map);
                    list_wallet(&wallet_map);
                }
                3 => {
                    // // Load wallets from database
                    // let mut wallet_map: HashMap<String, Wallet> =
                    //     mongo_utils::load_wallets(wallets_collection.clone()).await?;
                    // list_wallets(&wallet_map);
                    send_cc(
                        // &mut wallet_map,
                        // &mut blockchain,
                        blocks_collection.clone(),
                        wallets_collection.clone(),
                        blockchain_collection.clone(),
                    )
                    .await;
                }
                4 => {
                    mine_transactions(
                        blocks_collection.clone(),
                        blockchain_collection.clone(),
                        wallets_collection.clone(),
                    )
                    .await;
                }
                5 => {
                    let result = utils::reset_sample_data(
                        &blocks_collection,
                        &wallets_collection,
                        &blockchain_collection,
                    )
                    .await;

                    // Update the in-memory state
                    let new_blockchain = mongo_utils::load_blockchain(
                        blocks_collection.clone(),
                        blockchain_collection.clone(),
                    )
                    .await?;
                    blockchain = new_blockchain;

                    // Validate and print the blockchain validity
                    print!("{:?}", result);
                    let output = utils::list_blockchain(&blockchain);
                    println!("{}", output);
                }
                6 => {
                    println!("Exiting...");
                    break;
                }
                _ => println!("Invalid choice. Please enter a number between 1 and 7."),
            },
            Err(_) => println!("Invalid input. Please enter a number."),
        }
    }

    Ok(())
}

fn list_wallets(wallet_map: &HashMap<String, Wallet>) {
    println!("\nAvaiable Wallets:\n");
    for (address, wallet) in wallet_map {
        println!("Wallet address: {} and PK: {}", address, wallet.public_key);
    }
}

fn list_wallet(wallet_map: &HashMap<String, Wallet>) {
    print!("\nInput Address of Wallet to display: ");
    io::stdout().flush().unwrap(); // Ensure the prompt is displayed
    let mut selected_address = String::new();
    io::stdin()
        .read_line(&mut selected_address)
        .expect("Failed to read line");
    println!("\nWallet selected {}", selected_address);
    let selected_address = selected_address.trim();
    if let Some(wallet) = wallet_map.get(selected_address) {
        let output = utils::view_wallet(&wallet, &wallet.address);
        println!("{}", output);
    } else {
        println!("Address Not Found!")
    }
}

async fn send_cc(
    // wallet_map: &mut HashMap<String, Wallet>,
    // blockchain: &mut Blockchain,
    blocks_collection: Collection<Document>,
    wallets_collection: Collection<Document>,
    blockchain_collection: Collection<Document>,
) {
    // Load blockchain from database
    let mut blockchain =
        mongo_utils::load_blockchain(blocks_collection.clone(), blockchain_collection.clone())
            .await
            .unwrap();

    // Load wallets from database
    let mut wallet_map: HashMap<String, Wallet> =
        mongo_utils::load_wallets(wallets_collection.clone())
            .await
            .unwrap()
            .clone();
    list_wallets(&wallet_map);

    print!("\nInput Sender Wallet Address: ");
    io::stdout().flush().unwrap(); // Ensure the prompt is displayed
    let mut sender_address = String::new();
    io::stdin()
        .read_line(&mut sender_address)
        .expect("Failed to read line");
    println!("\nWallet selected: {}", sender_address);
    let sender_address = sender_address.trim();

    print!("Input Receiver Wallet Address: ");
    io::stdout().flush().unwrap(); // Ensure the prompt is displayed
    let mut receiver_address = String::new();
    io::stdin()
        .read_line(&mut receiver_address)
        .expect("Failed to read line");
    println!("\nWallet selected: {}", receiver_address);
    let receiver_address = receiver_address.trim();

    let mut sender_wallet = wallet_map
        .remove(sender_address)
        .expect("Sender wallet not found");
    let mut receiver_wallet = wallet_map
        .remove(receiver_address)
        .expect("Receiver wallet not found");

    let (amount, fee) = get_amount_fees();
    let msg: String = Result::expect(
        utils::send_crypto(
            amount,
            fee,
            &mut blockchain,
            &mut sender_wallet,
            &mut receiver_wallet,
            blocks_collection.clone(),
            wallets_collection.clone(),
            blockchain_collection.clone(),
        )
        .await,
        "Could not complete Transaction!",
    );
    print!("{msg}");
}

fn get_amount_fees() -> (f64, f64) {
    let amount = get_input("Please enter the amount to send: ");
    let fee = get_input("Please enter the fee for mining: ");

    (amount, fee)
}

fn get_input(msg: &str) -> f64 {
    loop {
        // Prompt the user to input a value
        print!("{msg}");
        io::stdout().flush().unwrap(); // Ensure the prompt is displayed

        let mut input = String::new();
        io::stdin()
            .read_line(&mut input)
            .expect("Failed to read line");

        // Try to parse the input
        match input.trim().parse::<f64>() {
            Ok(amt_value) => return amt_value, // Return the value if it's valid
            Err(_) => println!("Invalid input, please enter a valid number"), // Prompt the user to try again
        }
    }
}

async fn mine_transactions(
    blocks_collection: Collection<Document>,
    blockchain_collection: Collection<Document>,
    wallets_collection: Collection<Document>,
) {
    println!("\nList of Pending Transactions from Mempool\n");
    let result = utils::get_pending_txrn(&wallets_collection.clone()).await;

    let mut gbl_index = 0;
    for (_address, transactions) in &result {
        for txn in transactions.iter() {
            println!(
                "No#:-{} tx_id: {:?} timestamp: {} sender: {} receiver: {} amount: {} fee: {}",
                gbl_index, txn.tx_id, txn.timestamp, txn.sender, txn.receiver, txn.amount, txn.fee
            );
            gbl_index += 1;
        }
    }

    if gbl_index == 0 {
        println!("\nNo Pending transactions to mine!\n");
        return ();
    }

    println!("Select No# to mine: ");
    io::stdout().flush().unwrap(); // Ensure the prompt is displayed
    let mut selected_number = String::new();
    io::stdin()
        .read_line(&mut selected_number)
        .expect("Failed to read line");

    let selected_index: usize = selected_number
        .trim()
        .parse()
        .expect("Please enter a valid number");

    // Retrieve the tx_id from the existing map
    gbl_index = 0;
    let mut selected_tx_id = None;
    for (_address, transactions) in &result {
        for txn in transactions.iter() {
            if gbl_index == selected_index {
                selected_tx_id = Some(txn.tx_id.clone());
                break;
            }
            gbl_index += 1;
        }
        if selected_tx_id.is_some() {
            break;
        }
    }

    let tx_id = selected_tx_id.unwrap();

    utils::mine_crypto(blocks_collection.clone(), blockchain_collection.clone()).await;
    let response = utils::commit_mine_crypto(
        tx_id,
        blocks_collection,
        blockchain_collection,
        wallets_collection,
    )
    .await;
    println!("{response}");
}