routing_logic removal from ParseMiningMessagesFromUpstream and adaptation on roles

Author: GitGab19

protocols/v2/roles-logic-sv2/src/handlers/mining.rs

@@ -40,7 +40,7 @@ use mining_sv2::{
 
 use crate::{
     common_properties::{IsMiningDownstream, IsMiningUpstream},
-    routing_logic::{MiningRouter, MiningRoutingLogic},
+    routing_logic::MiningRouter,
     selectors::DownstreamMiningSelector,
 };
 
@@ -332,12 +332,10 @@ pub trait ParseMiningMessagesFromUpstream<
         self_mutex: Arc<Mutex<Self>>,
         message_type: u8,
         payload: &mut [u8],
-        routing_logic: MiningRoutingLogic<Down, Self, Selector, Router>,
     ) -> Result<SendTo<Down>, Error> {
         match Self::handle_message_mining_deserialized(
             self_mutex,
             (message_type, payload).try_into(),
-            routing_logic,
         ) {
             Err(Error::UnexpectedMessage(0)) => Err(Error::UnexpectedMessage(message_type)),
             result => result,
@@ -349,41 +347,26 @@ pub trait ParseMiningMessagesFromUpstream<
     fn handle_message_mining_deserialized(
         self_mutex: Arc<Mutex<Self>>,
         message: Result<Mining, Error>,
-        routing_logic: MiningRoutingLogic<Down, Self, Selector, Router>,
     ) -> Result<SendTo<Down>, Error> {
         let (channel_type, is_work_selection_enabled) = self_mutex
             .safe_lock(|s| (s.get_channel_type(), s.is_work_selection_enabled()))
             .map_err(|e| crate::Error::PoisonLock(e.to_string()))?;
 
         match message {
-            Ok(Mining::OpenStandardMiningChannelSuccess(mut m)) => {
-                let remote = match routing_logic {
-                    MiningRoutingLogic::None => None,
-                    MiningRoutingLogic::Proxy(r_logic) => {
-                        let up = r_logic
-                            .safe_lock(|r_logic| {
-                                r_logic.on_open_standard_channel_success(self_mutex.clone(), &mut m)
-                            })
-                            .map_err(|e| crate::Error::PoisonLock(e.to_string()))?;
-                        Some(up?)
-                    }
-                    MiningRoutingLogic::_P(_) => panic!("Must use either MiningRoutingLogic::None or MiningRoutingLogic::Proxy for `routing_logic` param"),
-                };
-                match channel_type {
-                    SupportedChannelTypes::Standard => self_mutex
-                        .safe_lock(|s| s.handle_open_standard_mining_channel_success(m, remote))
-                        .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
-                    SupportedChannelTypes::Extended => Err(Error::UnexpectedMessage(
-                        MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
-                    )),
-                    SupportedChannelTypes::Group => self_mutex
-                        .safe_lock(|s| s.handle_open_standard_mining_channel_success(m, remote))
-                        .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
-                    SupportedChannelTypes::GroupAndExtended => self_mutex
-                        .safe_lock(|s| s.handle_open_standard_mining_channel_success(m, remote))
-                        .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
-                }
-            }
+            Ok(Mining::OpenStandardMiningChannelSuccess(m)) => match channel_type {
+                SupportedChannelTypes::Standard => self_mutex
+                    .safe_lock(|s| s.handle_open_standard_mining_channel_success(m))
+                    .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
+                SupportedChannelTypes::Extended => Err(Error::UnexpectedMessage(
+                    MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
+                )),
+                SupportedChannelTypes::Group => self_mutex
+                    .safe_lock(|s| s.handle_open_standard_mining_channel_success(m))
+                    .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
+                SupportedChannelTypes::GroupAndExtended => self_mutex
+                    .safe_lock(|s| s.handle_open_standard_mining_channel_success(m))
+                    .map_err(|e| crate::Error::PoisonLock(e.to_string()))?,
+            },
             Ok(Mining::OpenExtendedMiningChannelSuccess(m)) => {
                 info!("Received OpenExtendedMiningChannelSuccess with request id: {} and channel id: {}", m.request_id, m.channel_id);
                 debug!("OpenStandardMiningChannelSuccess: {:?}", m);
@@ -673,7 +656,6 @@ pub trait ParseMiningMessagesFromUpstream<
     fn handle_open_standard_mining_channel_success(
         &mut self,
         m: OpenStandardMiningChannelSuccess,
-        remote: Option<Arc<Mutex<Down>>>,
     ) -> Result<SendTo<Down>, Error>;
 
     /// Handles a successful response for opening an extended mining channel.

protocols/v2/roles-logic-sv2/src/routing_logic.rs

@@ -73,7 +73,7 @@ pub trait MiningRouter<
     /// Handles an `OpenStandardMiningChannelSuccess` message from an upstream.
     fn on_open_standard_channel_success(
         &mut self,
-        upstream: Arc<Mutex<Up>>,
+        upstream: &mut Up,
         request: &mut OpenStandardMiningChannelSuccess,
     ) -> Result<Arc<Mutex<Down>>, Error>;
 }
@@ -109,7 +109,7 @@ impl<
 
     fn on_open_standard_channel_success(
         &mut self,
-        _upstream: Arc<Mutex<Up>>,
+        _upstream: &mut Up,
         _request: &mut OpenStandardMiningChannelSuccess,
     ) -> Result<Arc<Mutex<Down>>, Error> {
         unreachable!()
@@ -257,30 +257,23 @@ impl<
     // updates the associated group and channel IDs in the upstream.
     fn on_open_standard_channel_success(
         &mut self,
-        upstream: Arc<Mutex<Up>>,
+        upstream: &mut Up,
         request: &mut OpenStandardMiningChannelSuccess,
     ) -> Result<Arc<Mutex<Down>>, Error> {
         let upstream_request_id = request.get_request_id_as_u32();
         let original_request_id = upstream
-            .safe_lock(|u| {
-                u.get_mapper()
-                    .ok_or(crate::Error::RequestIdNotMapped(upstream_request_id))?
-                    .remove(upstream_request_id)
-                    .ok_or(Error::RequestIdNotMapped(upstream_request_id))
-            })
-            .map_err(|e| Error::PoisonLock(e.to_string()))??;
+            .get_mapper()
+            .ok_or(crate::Error::RequestIdNotMapped(upstream_request_id))?
+            .remove(upstream_request_id)
+            .ok_or(Error::RequestIdNotMapped(upstream_request_id));
 
-        request.update_id(original_request_id);
-        upstream
-            .safe_lock(|u| {
-                let selector = u.get_remote_selector();
-                selector.on_open_standard_channel_success(
-                    upstream_request_id,
-                    request.group_channel_id,
-                    request.channel_id,
-                )
-            })
-            .map_err(|e| Error::PoisonLock(e.to_string()))?
+        request.update_id(original_request_id?);
+        let selector = upstream.get_remote_selector();
+        selector.on_open_standard_channel_success(
+            upstream_request_id,
+            request.group_channel_id,
+            request.channel_id,
+        )
     }
 }
 

roles/jd-client/src/lib/upstream_sv2/upstream.rs

@@ -26,7 +26,7 @@ use roles_logic_sv2::{
     job_declaration_sv2::DeclareMiningJob,
     mining_sv2::{ExtendedExtranonce, Extranonce, SetCustomMiningJob},
     parsers::{AnyMessage, Mining, MiningDeviceMessages},
-    routing_logic::{MiningRoutingLogic, NoRouting},
+    routing_logic::NoRouting,
     selectors::NullDownstreamMiningSelector,
     utils::{Id, Mutex},
     Error as RolesLogicError,
@@ -340,21 +340,11 @@ impl Upstream {
 
                     let payload = incoming.payload();
 
-                    // Since this is not communicating with an SV2 proxy, but instead a custom SV1
-                    // proxy where the routing logic is handled via the `Upstream`'s communication
-                    // channels, we do not use the mining routing logic in the SV2 library and
-                    // specify no mining routing logic here
-                    let routing_logic = MiningRoutingLogic::None;
-
                     // Gets the response message for the received SV2 Upstream role message
                     // `handle_message_mining` takes care of the SetupConnection +
                     // SetupConnection.Success
-                    let next_message_to_send = Upstream::handle_message_mining(
-                        self_.clone(),
-                        message_type,
-                        payload,
-                        routing_logic,
-                    );
+                    let next_message_to_send =
+                        Upstream::handle_message_mining(self_.clone(), message_type, payload);
 
                     // Routes the incoming messages accordingly
                     match next_message_to_send {
@@ -560,7 +550,6 @@ impl ParseMiningMessagesFromUpstream<Downstream, NullDownstreamMiningSelector, N
     fn handle_open_standard_mining_channel_success(
         &mut self,
         _m: roles_logic_sv2::mining_sv2::OpenStandardMiningChannelSuccess,
-        _remote: Option<Arc<Mutex<Downstream>>>,
     ) -> Result<roles_logic_sv2::handlers::mining::SendTo<Downstream>, RolesLogicError> {
         panic!("Standard Mining Channels are not used in Translator Proxy")
     }

roles/mining-proxy/src/lib/upstream_mining.rs

@@ -9,6 +9,10 @@ use nohash_hasher::BuildNoHashHasher;
 use tokio::{net::TcpStream, task};
 use tracing::{debug, error, info};
 
+use super::{
+    downstream_mining::{Channel, DownstreamMiningNode, StdFrame as DownstreamFrame},
+    EXTRANONCE_RANGE_1_LENGTH,
+};
 use codec_sv2::{HandshakeRole, Initiator, StandardEitherFrame, StandardSv2Frame};
 use network_helpers_sv2::noise_connection::Connection;
 use roles_logic_sv2::{
@@ -28,18 +32,13 @@ use roles_logic_sv2::{
     job_dispatcher::GroupChannelJobDispatcher,
     mining_sv2::*,
     parsers::{AnyMessage, CommonMessages, Mining, MiningDeviceMessages},
-    routing_logic::MiningProxyRoutingLogic,
+    routing_logic::{MiningProxyRoutingLogic, MiningRouter, MiningRoutingLogic},
     selectors::{DownstreamMiningSelector, ProxyDownstreamMiningSelector as Prs},
     template_distribution_sv2::SubmitSolution,
     utils::{GroupId, Id, Mutex},
 };
 use stratum_common::bitcoin::TxOut;
 
-use super::{
-    downstream_mining::{Channel, DownstreamMiningNode, StdFrame as DownstreamFrame},
-    EXTRANONCE_RANGE_1_LENGTH,
-};
-
 pub type Message = AnyMessage<'static>;
 pub type StdFrame = StandardSv2Frame<Message>;
 pub type EitherFrame = StandardEitherFrame<Message>;
@@ -581,14 +580,8 @@ impl UpstreamMiningNode {
         let message_type = incoming.get_header().unwrap().msg_type();
         let payload = incoming.payload();
 
-        let routing_logic = super::get_routing_logic();
-
-        let next_message_to_send = UpstreamMiningNode::handle_message_mining(
-            self_mutex.clone(),
-            message_type,
-            payload,
-            routing_logic,
-        );
+        let next_message_to_send =
+            UpstreamMiningNode::handle_message_mining(self_mutex.clone(), message_type, payload);
         Self::match_next_message(self_mutex, next_message_to_send, incoming).await;
     }
 
@@ -898,8 +891,20 @@ impl
     fn handle_open_standard_mining_channel_success(
         &mut self,
         m: OpenStandardMiningChannelSuccess,
-        remote: Option<Arc<Mutex<DownstreamMiningNode>>>,
     ) -> Result<SendTo<DownstreamMiningNode>, Error> {
+        let routing_logic = super::get_routing_logic();
+        let remote = match routing_logic {
+            MiningRoutingLogic::None => None,
+            MiningRoutingLogic::Proxy(r_logic) => {
+                let up = r_logic
+                    .safe_lock(|r_logic| {
+                        r_logic.on_open_standard_channel_success(self, &mut m.clone())
+                    })
+                    .map_err(|e| Error::PoisonLock(e.to_string()))?;
+                Some(up?)
+            }
+            MiningRoutingLogic::_P(_) => panic!("Must use either MiningRoutingLogic::None or MiningRoutingLogic::Proxy for `routing_logic` param"),
+        };
         match &mut self.channel_kind {
             ChannelKind::Group(group) => {
                 let down_is_header_only = remote

roles/test-utils/mining-device/src/lib/mod.rs

@@ -17,7 +17,7 @@ use roles_logic_sv2::{
     },
     mining_sv2::*,
     parsers::{Mining, MiningDeviceMessages},
-    routing_logic::{MiningRoutingLogic, NoRouting},
+    routing_logic::NoRouting,
     selectors::NullDownstreamMiningSelector,
     utils::{Id, Mutex},
 };
@@ -294,13 +294,8 @@ impl Device {
             let mut incoming: StdFrame = receiver.recv().await.unwrap().try_into().unwrap();
             let message_type = incoming.get_header().unwrap().msg_type();
             let payload = incoming.payload();
-            let next = Device::handle_message_mining(
-                self_mutex.clone(),
-                message_type,
-                payload,
-                MiningRoutingLogic::None,
-            )
-            .unwrap();
+            let next =
+                Device::handle_message_mining(self_mutex.clone(), message_type, payload).unwrap();
             let mut notify_changes_to_mining_thread = self_mutex
                 .safe_lock(|s| s.notify_changes_to_mining_thread.clone())
                 .unwrap();
@@ -407,7 +402,6 @@ impl ParseMiningMessagesFromUpstream<(), NullDownstreamMiningSelector, NoRouting
     fn handle_open_standard_mining_channel_success(
         &mut self,
         m: OpenStandardMiningChannelSuccess,
-        _: Option<std::sync::Arc<Mutex<()>>>,
     ) -> Result<SendTo<()>, Error> {
         self.channel_opened = true;
         self.channel_id = Some(m.channel_id);

roles/translator/src/lib/upstream_sv2/upstream.rs

@@ -26,7 +26,7 @@ use roles_logic_sv2::{
         SetNewPrevHash, SubmitSharesExtended,
     },
     parsers::Mining,
-    routing_logic::{MiningRoutingLogic, NoRouting},
+    routing_logic::NoRouting,
     selectors::NullDownstreamMiningSelector,
     utils::Mutex,
     Error as RolesLogicError,
@@ -327,21 +327,11 @@ impl Upstream {
 
                 let payload = incoming.payload();
 
-                // Since this is not communicating with an SV2 proxy, but instead a custom SV1
-                // proxy where the routing logic is handled via the `Upstream`'s communication
-                // channels, we do not use the mining routing logic in the SV2 library and specify
-                // no mining routing logic here
-                let routing_logic = MiningRoutingLogic::None;
-
                 // Gets the response message for the received SV2 Upstream role message
                 // `handle_message_mining` takes care of the SetupConnection +
                 // SetupConnection.Success
-                let next_message_to_send = Upstream::handle_message_mining(
-                    self_.clone(),
-                    message_type,
-                    payload,
-                    routing_logic,
-                );
+                let next_message_to_send =
+                    Upstream::handle_message_mining(self_.clone(), message_type, payload);
 
                 // Routes the incoming messages accordingly
                 match next_message_to_send {
@@ -671,7 +661,6 @@ impl ParseMiningMessagesFromUpstream<Downstream, NullDownstreamMiningSelector, N
     fn handle_open_standard_mining_channel_success(
         &mut self,
         _m: roles_logic_sv2::mining_sv2::OpenStandardMiningChannelSuccess,
-        _remote: Option<Arc<Mutex<Downstream>>>,
     ) -> Result<roles_logic_sv2::handlers::mining::SendTo<Downstream>, RolesLogicError> {
         panic!("Standard Mining Channels are not used in Translator Proxy")
     }