Merge branch 'master' into fix/triton-take-average-of-last-20-slots

Author: HardhatChad

src/dynamic_fee.rs

@@ -9,10 +9,12 @@ use url::Url;
 enum FeeStrategy {
     Helius,
     Triton,
+    Alchemy,
+    Quiknode,
 }
 
 impl Miner {
-    pub async fn dynamic_fee(&self) -> Option<u64> {
+    pub async fn dynamic_fee(&self) -> Result<u64, String> {
         // Get url
         let rpc_url = self
             .dynamic_fee_url
@@ -27,10 +29,14 @@ impl Miner {
             .to_string();
         let strategy = if host.contains("helius-rpc.com") {
             FeeStrategy::Helius
+        } else if host.contains("alchemy.com") {
+            FeeStrategy::Alchemy
+        } else if host.contains("quiknode.pro") {
+            FeeStrategy::Quiknode
         } else if host.contains("rpcpool.com") {
             FeeStrategy::Triton
         } else {
-            return None;
+            return Err("Dynamic fees not supported by this RPC.".to_string());
         };
 
         // Build fee estimate request
@@ -52,6 +58,27 @@ impl Miner {
                     }]
                 })
             }
+            FeeStrategy::Alchemy => {
+                json!({
+                    "jsonrpc": "2.0",
+                    "id": "priority-fee-estimate",
+                    "method": "getRecentPrioritizationFees",
+                    "params": [
+                        ore_addresses
+                    ]
+                })
+            }
+            FeeStrategy::Quiknode => {
+                json!({
+                    "jsonrpc": "2.0",
+                    "id": "1",
+                    "method": "qn_estimatePriorityFees",
+                    "params": {
+                        "account": "oreV2ZymfyeXgNgBdqMkumTqqAprVqgBWQfoYkrtKWQ",
+                        "last_n_blocks": 100
+                    }
+                })
+            }
             FeeStrategy::Triton => {
                 json!({
                     "jsonrpc": "2.0",
@@ -83,27 +110,49 @@ impl Miner {
             FeeStrategy::Helius => response["result"]["priorityFeeEstimate"]
                 .as_f64()
                 .map(|fee| fee as u64)
-                .ok_or_else(|| format!("Failed to parse priority fee. Response: {:?}", response))
-                .unwrap(),
+                .ok_or_else(|| format!("Failed to parse priority fee response: {:?}", response)),
+            FeeStrategy::Quiknode => response["result"]["per_compute_unit"]["medium"]
+                .as_f64()
+                .map(|fee| fee as u64)
+                .ok_or_else(|| format!("Please enable the Solana Priority Fee API add-on in your QuickNode account.")),
+            FeeStrategy::Alchemy => response["result"]
+                .as_array()
+                .and_then(|arr| {
+                    Some(
+                        arr.into_iter()
+                            .map(|v| v["prioritizationFee"].as_u64().unwrap())
+                            .collect::<Vec<u64>>(),
+                    )
+                })
+                .and_then(|fees| {
+                    Some(
+                        ((fees.iter().sum::<u64>() as f32 / fees.len() as f32).ceil() * 1.2) as u64,
+                    )
+                })
+                .ok_or_else(|| format!("Failed to parse priority fee response: {:?}", response)),
             FeeStrategy::Triton => {
                 serde_json::from_value::<Vec<RpcPrioritizationFee>>(response["result"].clone())
                     .map(|prioritization_fees| {
                         estimate_prioritization_fee_micro_lamports(prioritization_fees)
                     })
-                    .or_else(|error: serde_json::Error| {
+                    .ok_or_else(|error: serde_json::Error| {
                         Err(format!(
                             "Failed to parse priority fee. Response: {response:?}, error: {error}"
                         ))
                     })
-                    .unwrap()
             }
         };
 
         // Check if the calculated fee is higher than max
-        if let Some(max_fee) = self.priority_fee {
-            Some(calculated_fee.min(max_fee))
-        } else {
-            Some(calculated_fee)
+        match calculated_fee {
+            Err(err) => Err(err),
+            Ok(fee) => {
+                if let Some(max_fee) = self.priority_fee {
+                    Ok(fee.min(max_fee))
+                } else {
+                    Ok(fee)
+                }
+            }
         }
     }
 }

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,18 +35,28 @@ 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;
             let proof =
                 get_updated_proof_with_authority(&self.rpc_client, signer.pubkey(), last_hash_at)
                     .await;
-            last_hash_at = proof.last_hash_at;
             println!(
-                "\nStake: {} ORE\n  Multiplier: {:12}x",
+                "\nStake: {} ORE\n{}  Multiplier: {:12}x",
                 amount_u64_to_string(proof.balance),
+                if last_hash_at.gt(&0) {
+                    format!(
+                        "  Change: {} ORE\n",
+                        amount_u64_to_string(proof.balance.saturating_sub(last_balance))
+                    )
+                } else {
+                    "".to_string()
+                },
                 calculate_multiplier(proof.balance, config.top_balance)
             );
+            last_hash_at = proof.last_hash_at;
+            last_balance = proof.balance;
 
             // Calculate cutoff time
             let cutoff_time = self.get_cutoff(proof, args.buffer_time).await;
@@ -87,11 +97,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,19 +135,34 @@ 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,
+                                        ));
+                                    }
+                                    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,
                                         cutoff_time.saturating_sub(timer.elapsed().as_secs()),
                                     ));
                                 }

src/send_and_confirm.rs

@@ -89,13 +89,21 @@ impl Miner {
             if attempts % 10 == 0 {
                 // Reset the compute unit price
                 if self.dynamic_fee {
-                    let fee = if let Some(fee) = self.dynamic_fee().await {
-                        progress_bar.println(format!("  Priority fee: {} microlamports", fee));
-                        fee
-                    } else {
-                        let fee = self.priority_fee.unwrap_or(0);
-                        progress_bar.println(format!("  {} Dynamic fees not supported by this RPC. Falling back to static value: {} microlamports", "WARNING".bold().yellow(), fee));
-                        fee
+                    let fee = match self.dynamic_fee().await {
+                        Ok(fee) => {
+                            progress_bar.println(format!("  Priority fee: {} microlamports", fee));
+                            fee
+                        }
+                        Err(err) => {
+                            let fee = self.priority_fee.unwrap_or(0);
+                            progress_bar.println(format!(
+                                "  {} {} Falling back to static value: {} microlamports",
+                                "WARNING".bold().yellow(),
+                                err,
+                                fee
+                            ));
+                            fee
+                        }
                     };
                     final_ixs.remove(1);
                     final_ixs.insert(1, ComputeBudgetInstruction::set_compute_unit_price(fee));