update diff when rate_limit_hit_count >= 5

Author: Priceless-P

src/jd_client/mining_downstream/mod.rs

@@ -613,10 +613,11 @@ impl
                             header_nonce: share.nonce,
                             coinbase_tx: coinbase.try_into()?,
                         };
-                        // The below channel should never be full is ok to block
-                        solution_sender
-                            .blocking_send(solution)
-                            .map_err(|_| Error::DownstreamDown)?; // Better Error to return here?
+                        tokio::spawn(async move {
+                            if solution_sender.send(solution).await.is_err() {
+                                error!("Downstream channel closed, couldn't send solution");
+                            }
+                        });
                         if !self.status.is_solo_miner() {
                             {
                                 let jd = self.jd.clone();

src/translator/downstream/diff_management.rs

@@ -47,7 +47,8 @@ impl Downstream {
         });
         stats_sender.update_diff(connection_id, diff);
         stats_sender.update_hashrate(connection_id, estimated_hashrate);
-        tokio::spawn(crate::translator::utils::check_share_rate_limit());
+        let downstream = self_.clone();
+        tokio::spawn(crate::translator::utils::check_share_rate_limit(downstream));
 
         Ok(())
     }

src/translator/proxy/bridge.rs

@@ -263,25 +263,22 @@ impl Bridge {
         let mut upstream_target: Target = upstream_target.into();
         let res = self_
             .safe_lock(|s| {
-                let job_id = share.share.job_id.parse::<u32>().expect("Invalid job_id format");
+                let job_id = share.share.job_id.parse::<u32>().expect("Invalid job_id");
                 if !s.valid_job_ids.contains(&job_id) {
                     info!("Share rejected: job_id {} not in last two jobs", job_id);
                     return Err(roles_logic_sv2::Error::ShareDoNotMatchAnyJob); // rejected
                 }
                 s.channel_factory.set_target(&mut upstream_target);
-                 match s.translate_submit(
-                    share.channel_id,
-                    share.share,
-                    share.version_rolling_mask,
-                ) {
+                match s.translate_submit(share.channel_id, share.share, share.version_rolling_mask)
+                {
                     Ok(submit_shares_extended) => {
-                        // Ordering::Relaxed is safe here because we only need simple counter updates. 
+                        // Ordering::Relaxed is safe here because we only need simple counter updates.
                         // No need for strict ordering since it just tracks failures.
                         SUBMIT_FAIL_COUNTER.store(0, Ordering::Relaxed); // Reset on success
-                        s.channel_factory.on_submit_shares_extended(submit_shares_extended)
-                   },
-                    Err(e) => {
-                        error!("Failed to Translates SV1 mining.submit message to SV2 SubmitSharesExtended message: {e}");
+                        s.channel_factory
+                            .on_submit_shares_extended(submit_shares_extended)
+                    }
+                    Err(_) => {
                         Err(roles_logic_sv2::Error::NoValidJob) // Error will be handled by the caller
                     }
                 }
@@ -537,7 +534,7 @@ impl Bridge {
             self_
                 .safe_lock(|s| {
                     s.last_notify = Some(notify);
-                    s.valid_job_ids.push_back(j_id); // Add new job_id
+                    s.valid_job_ids.push_back(j_id);
                     if s.valid_job_ids.len() > 2 {
                         s.valid_job_ids.pop_front(); // Remove oldest if more than 2
                     }

src/translator/utils.rs

@@ -17,7 +17,7 @@ use bitcoin::{
 use lazy_static::lazy_static;
 use roles_logic_sv2::utils::Mutex;
 use sv1_api::{client_to_server, server_to_client::Notify};
-use tracing::error;
+use tracing::{debug, error};
 
 use super::downstream::Downstream;
 lazy_static! {
@@ -30,8 +30,11 @@ lazy_static! {
 
 /// Checks if a share can be sent upstream based on a rate limit of 70 shares per minute.
 /// Returns `true` if the share can be sent, `false` if the limit is exceeded.
-pub async fn check_share_rate_limit() {
+pub async fn check_share_rate_limit(downstream: Arc<Mutex<Downstream>>) {
     let mut interval = tokio::time::interval(std::time::Duration::from_secs(1));
+    let mut last_update = tokio::time::Instant::now(); // Track last difficulty update
+    let mut rate_limit_hit_count = 0;
+
     loop {
         interval.tick().await;
         let now = tokio::time::Instant::now();
@@ -52,7 +55,24 @@ pub async fn check_share_rate_limit() {
                 0
             });
 
-        IS_RATE_LIMITED.store(count >= 70, std::sync::atomic::Ordering::SeqCst);
+        let is_limited = count >= 70;
+        IS_RATE_LIMITED.store(is_limited, std::sync::atomic::Ordering::SeqCst);
+
+        if is_limited {
+            rate_limit_hit_count += 1;
+        } else {
+            rate_limit_hit_count = 0;
+        }
+
+        if rate_limit_hit_count >= 5 && now.duration_since(last_update).as_secs() >= 2 {
+            debug!("Rate limited. Updating difficulty");
+            if let Err(e) = Downstream::try_update_difficulty_settings(&downstream).await {
+                error!("Failed to update difficulty: {e}");
+            }
+            last_update = now;
+            IS_RATE_LIMITED.store(false, std::sync::atomic::Ordering::SeqCst);
+            rate_limit_hit_count = 0;
+        }
     }
 }
 
@@ -92,7 +112,10 @@ pub fn validate_share(
     let job = match matching_job {
         Some(job) => job,
         None => {
-            error!("Share rejected: Invalid Job ID {}", request.job_id);
+            error!(
+                "Share rejected: Job ID {} not found in recent notify msgs",
+                request.job_id
+            );
             return false;
         }
     };