Update mine.rs

little update for see update on best difficulty and update best difficulty

build with support from OneOkRock Renegades Song :)

Author: JustPandaEver

src/mine.rs

@@ -1,4 +1,4 @@
-use std::{sync::Arc, time::Instant};
+use std::{sync::Arc, sync::RwLock, time::Instant};
 
 use colored::*;
 use drillx::{
@@ -35,6 +35,7 @@ impl Miner {
 
         // Start mining loop
         let mut last_hash_at = 0;
+        let mut last_balance = 0;
         loop {
             // Fetch proof
             let config = get_config(&self.rpc_client).await;
@@ -43,11 +44,12 @@ impl Miner {
                     .await;
             last_hash_at = proof.last_hash_at;
             println!(
-                "\nStake: {} ORE\n  Multiplier: {:12}x",
+                "\nStake: {} ORE \n balance change:{} ORE\n  Multiplier: {:12}x",
                 amount_u64_to_string(proof.balance),
+                amount_u64_to_string(proof.balance.saturating_sub(last_balance)),
                 calculate_multiplier(proof.balance, config.top_balance)
             );
-
+            last_balance = proof.balance;
             // Calculate cutoff time
             let cutoff_time = self.get_cutoff(proof, args.buffer_time).await;
 
@@ -87,11 +89,13 @@ impl Miner {
     ) -> Solution {
         // Dispatch job to each thread
         let progress_bar = Arc::new(spinner::new_progress_bar());
+        let global_best_difficulty = Arc::new(RwLock::new(0u32));
         progress_bar.set_message("Mining...");
         let core_ids = core_affinity::get_core_ids().unwrap();
         let handles: Vec<_> = core_ids
             .into_iter()
             .map(|i| {
+                let global_best_difficulty = Arc::clone(&global_best_difficulty);
                 std::thread::spawn({
                     let proof = proof.clone();
                     let progress_bar = progress_bar.clone();
@@ -123,24 +127,39 @@ impl Miner {
                                     best_nonce = nonce;
                                     best_difficulty = difficulty;
                                     best_hash = hx;
+                                    // {{ edit_1 }}
+                                    if best_difficulty.gt(&*global_best_difficulty.read().unwrap()) {
+                                        *global_best_difficulty.write().unwrap() = best_difficulty;
+                                    }
+                                    // {{ edit_1 }}
                                 }
                             }
 
                             // Exit if time has elapsed
                             if nonce % 100 == 0 {
+                                let global_best_difficulty = *global_best_difficulty.read().unwrap();
                                 if timer.elapsed().as_secs().ge(&cutoff_time) {
-                                    if best_difficulty.ge(&min_difficulty) {
+                                    if i.id == 0 {
+                                        progress_bar.set_message(format!(
+                                            "Mining... ({} / {} difficulty)",
+                                            global_best_difficulty,
+                                            min_difficulty,
+                                        ));
+                                    }
+                                    if global_best_difficulty.ge(&min_difficulty) {
                                         // Mine until min difficulty has been met
                                         break;
                                     }
                                 } else if i.id == 0 {
                                     progress_bar.set_message(format!(
-                                        "Mining... ({} sec remaining)",
+                                        "Mining... ({} / {} difficulty, {} sec remaining)",
+                                        global_best_difficulty,
+                                        min_difficulty,
                                         cutoff_time.saturating_sub(timer.elapsed().as_secs()),
                                     ));
                                 }
                             }
-
+                            
                             // Increment nonce
                             nonce += 1;
                         }