feat: add translator search space allocation for non-aggregated mode

- Rename min_extranonce2_size -> downstream_extranonce2_size for clarity
- Add 4 bytes translator search space in aggregated mode via AGGREGATED_MODE_TRANSLATOR_SEARCH_SPACE_BYTES constant
- Add per-channel extranonce factories for non-aggregated mode size adjustment

Author: GitGab19

roles/translator/README.md

@@ -35,7 +35,7 @@ max_supported_version = 2
 min_supported_version = 2
 
 # Extranonce Configuration
-min_extranonce2_size = 4  # Min: 2, Max: 16 (CGminer max: 8)
+downstream_extranonce2_size = 4  # Min: 2, Max: 16 (CGminer max: 8)
 
 # User Identity (appended with counter for each miner)
 user_identity = "your_username_here"

roles/translator/config-examples/tproxy-config-hosted-pool-example.toml

@@ -6,11 +6,11 @@ downstream_port = 34255
 max_supported_version = 2
 min_supported_version = 2
 
-# Minimum extranonce2 size for downstream
-# Max value: 16 (leaves 0 bytes for search space splitting of downstreams)
+# Extranonce2 size for downstream connections
+# This controls the rollable part of the extranonce for downstream SV1 miners
 # Max value for CGminer: 8
 # Min value: 2
-min_extranonce2_size = 4
+downstream_extranonce2_size = 4
 
 # User identity/username for pool connection
 # This will be appended with a counter for each mining client (e.g., username.miner1, username.miner2)

roles/translator/config-examples/tproxy-config-local-jdc-example.toml

@@ -6,11 +6,11 @@ downstream_port = 34255
 max_supported_version = 2
 min_supported_version = 2
 
-# Minimum extranonce2 size for downstream
-# Max value: 16 (leaves 0 bytes for search space splitting of downstreams)
+# Extranonce2 size for downstream connections
+# This controls the rollable part of the extranonce for downstream miners
 # Max value for CGminer: 8
 # Min value: 2
-min_extranonce2_size = 4
+downstream_extranonce2_size = 4
 
 # User identity/username for pool connection
 # This will be appended with a counter for each mining client (e.g., username.miner1, username.miner2)

roles/translator/config-examples/tproxy-config-local-pool-example.toml

@@ -6,11 +6,11 @@ downstream_port = 34255
 max_supported_version = 2
 min_supported_version = 2
 
-# Minimum extranonce2 size for downstream
-# Max value: 16 (leaves 0 bytes for search space splitting of downstreams)
+# Extranonce2 size for downstream connections
+# This controls the rollable part of the extranonce for downstream miners
 # Max value for CGminer: 8
 # Min value: 2
-min_extranonce2_size = 4
+downstream_extranonce2_size = 4
 
 # User identity/username for pool connection
 # This will be appended with a counter for each mining client (e.g., username.miner1, username.miner2)

roles/translator/src/lib/config.rs

@@ -27,8 +27,8 @@ pub struct TranslatorConfig {
     pub max_supported_version: u16,
     /// The minimum supported protocol version for communication.
     pub min_supported_version: u16,
-    /// The minimum size required for the extranonce2 field in mining submissions.
-    pub min_extranonce2_size: u16,
+    /// The size of the extranonce2 field for downstream mining connections.
+    pub downstream_extranonce2_size: u16,
     /// The user identity/username to use when connecting to the pool.
     /// This will be appended with a counter for each mining channel (e.g., username.miner1,
     /// username.miner2).
@@ -74,7 +74,7 @@ impl TranslatorConfig {
         downstream_difficulty_config: DownstreamDifficultyConfig,
         max_supported_version: u16,
         min_supported_version: u16,
-        min_extranonce2_size: u16,
+        downstream_extranonce2_size: u16,
         user_identity: String,
         aggregate_channels: bool,
     ) -> Self {
@@ -84,7 +84,7 @@ impl TranslatorConfig {
             downstream_port,
             max_supported_version,
             min_supported_version,
-            min_extranonce2_size,
+            downstream_extranonce2_size,
             user_identity,
             downstream_difficulty_config,
             aggregate_channels,
@@ -182,7 +182,7 @@ mod tests {
         assert_eq!(config.downstream_port, 3333);
         assert_eq!(config.max_supported_version, 2);
         assert_eq!(config.min_supported_version, 1);
-        assert_eq!(config.min_extranonce2_size, 4);
+        assert_eq!(config.downstream_extranonce2_size, 4);
         assert_eq!(config.user_identity, "test_user");
         assert!(config.aggregate_channels);
         assert!(config.log_file.is_none());

roles/translator/src/lib/sv1/downstream/message_handler.rs

@@ -62,7 +62,7 @@ impl IsServer<'static> for DownstreamData {
     fn handle_submit(&self, request: &client_to_server::Submit<'static>) -> bool {
         if let Some(channel_id) = self.channel_id {
             info!(
-                "Received mining.submit from Sv1 downstream for channel id: {}",
+                "Received mining.submit from SV1 downstream for channel id: {}",
                 channel_id
             );
             let is_valid_share = validate_sv1_share(

roles/translator/src/lib/sv1/sv1_server/sv1_server.rs

@@ -575,7 +575,7 @@ impl Sv1Server {
 
         let hashrate = config.min_individual_miner_hashrate as f64;
         let shares_per_min = config.shares_per_minute as f64;
-        let min_extranonce_size = self.config.min_extranonce2_size;
+        let min_extranonce_size = self.config.downstream_extranonce2_size;
         let vardiff_enabled = config.enable_vardiff;
 
         let max_target = if vardiff_enabled {
@@ -790,7 +790,7 @@ mod tests {
             difficulty_config,     // downstream_difficulty_config
             2,                     // max_supported_version
             1,                     // min_supported_version
-            4,                     // min_extranonce2_size
+            4,                     // downstream_extranonce2_size
             "test_user".to_string(),
             true, // aggregate_channels
         )

roles/translator/src/lib/sv2/channel_manager/channel_manager.rs

@@ -24,6 +24,11 @@ use stratum_common::roles_logic_sv2::{
 use tokio::sync::{broadcast, mpsc};
 use tracing::{debug, error, info, warn};
 
+/// Extra bytes allocated for translator search space in aggregated mode.
+/// This allows the translator to manage multiple downstream connections
+/// by allocating unique extranonce prefixes to each downstream.
+const AGGREGATED_MODE_TRANSLATOR_SEARCH_SPACE_BYTES: usize = 4;
+
 /// Type alias for SV2 mining messages with static lifetime
 pub type Sv2Message = Mining<'static>;
 
@@ -413,14 +418,31 @@ impl ChannelManager {
                             user_identity.as_bytes().to_vec().try_into().unwrap();
                     }
                 }
-                // Store the user identity and hashrate
+                // In aggregated mode, add extra bytes for translator search space allocation
+                let upstream_min_extranonce_size = self.channel_manager_data.super_safe_lock(|c| {
+                    if c.mode == ChannelMode::Aggregated {
+                        min_extranonce_size + AGGREGATED_MODE_TRANSLATOR_SEARCH_SPACE_BYTES
+                    } else {
+                        min_extranonce_size
+                    }
+                });
+
+                // Update the message with the adjusted extranonce size for upstream
+                open_channel_msg.min_extranonce_size = upstream_min_extranonce_size as u16;
+
+                // Store the user identity, hashrate, and original downstream extranonce size
                 self.channel_manager_data.super_safe_lock(|c| {
                     c.pending_channels.insert(
                         open_channel_msg.request_id,
                         (user_identity, hashrate, min_extranonce_size),
                     );
                 });
 
+                info!(
+                    "Sending OpenExtendedMiningChannel message to upstream: {:?}",
+                    open_channel_msg
+                );
+
                 let frame = StdFrame::try_from(Message::Mining(Mining::OpenExtendedMiningChannel(
                     open_channel_msg,
                 )))
@@ -510,6 +532,39 @@ impl ChannelManager {
                         m.sequence_number = self
                             .channel_manager_data
                             .super_safe_lock(|c| c.next_share_sequence_number(m.channel_id));
+
+                        // Check if we have a per-channel factory for extranonce adjustment
+                        let channel_factory = self.channel_manager_data.super_safe_lock(|c| {
+                            c.extranonce_factories
+                                .as_ref()
+                                .and_then(|factories| factories.get(&m.channel_id).cloned())
+                        });
+
+                        if let Some(factory) = channel_factory {
+                            // We need to adjust the extranonce for this channel
+                            let downstream_extranonce_prefix =
+                                self.channel_manager_data.super_safe_lock(|c| {
+                                    c.extended_channels.get(&m.channel_id).map(|channel| {
+                                        channel.read().unwrap().get_extranonce_prefix().clone()
+                                    })
+                                });
+                            let range0_len = factory
+                                .safe_lock(|e| e.get_range0_len())
+                                .expect("Failed to access extranonce factory range - this should not happen");
+                            if let Some(downstream_extranonce_prefix) = downstream_extranonce_prefix
+                            {
+                                // Skip the upstream prefix (range0) and take the remaining
+                                // bytes (translator proxy prefix)
+                                let translator_prefix = &downstream_extranonce_prefix[range0_len..];
+                                // Create new extranonce: translator proxy prefix + miner's
+                                // extranonce
+                                let mut new_extranonce = translator_prefix.to_vec();
+                                new_extranonce.extend_from_slice(m.extranonce.as_ref());
+                                // Replace the original extranonce with the modified one for
+                                // upstream submission
+                                m.extranonce = new_extranonce.try_into()?;
+                            }
+                        }
                     }
 
                     info!(

roles/translator/src/lib/sv2/channel_manager/data.rs

@@ -46,6 +46,9 @@ pub struct ChannelManagerData {
     /// In aggregated mode: single counter for all shares going to the upstream channel.
     /// In non-aggregated mode: one counter per downstream channel.
     pub share_sequence_counters: HashMap<u32, u32>,
+    /// Per-channel extranonce factories for non-aggregated mode when extranonce adjustment is
+    /// needed
+    pub extranonce_factories: Option<HashMap<u32, Arc<Mutex<ExtendedExtranonce>>>>,
 }
 
 impl ChannelManagerData {
@@ -64,6 +67,7 @@ impl ChannelManagerData {
             extranonce_prefix_factory: None,
             mode,
             share_sequence_counters: HashMap::new(),
+            extranonce_factories: None,
         }
     }
 
@@ -85,6 +89,7 @@ impl ChannelManagerData {
         self.upstream_extended_channel = None;
         self.extranonce_prefix_factory = None;
         self.share_sequence_counters.clear();
+        self.extranonce_factories = None;
         // Note: we intentionally preserve `mode` as it's a configuration setting
     }
 

roles/translator/src/lib/sv2/channel_manager/message_handler.rs

@@ -21,7 +21,7 @@ use stratum_common::roles_logic_sv2::{
     utils::Mutex,
 };
 
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 
 impl HandleMiningMessagesFromServerAsync for ChannelManager {
     type Error = TproxyError;
@@ -90,7 +90,6 @@ impl HandleMiningMessagesFromServerAsync for ChannelManager {
                         Some(Arc::new(RwLock::new(extended_channel.clone())));
 
                     let upstream_extranonce_prefix: Extranonce = m.extranonce_prefix.clone().into();
-                    info!(downstream_extranonce_len, "downstream_extranonce_len");
                     let translator_proxy_extranonce_prefix_len = proxy_extranonce_prefix_len(
                         m.extranonce_size.into(),
                         downstream_extranonce_len,
@@ -102,7 +101,8 @@ impl HandleMiningMessagesFromServerAsync for ChannelManager {
                     // that is used for rolling)
                     let range_0 = 0..extranonce_prefix.len();
                     let range1 = range_0.end..range_0.end + translator_proxy_extranonce_prefix_len;
-                    let range2 = range1.end..m.extranonce_size as usize + extranonce_prefix.len();
+                    let range2 = range1.end..range1.end + downstream_extranonce_len;
+                    debug!("\n\nrange_0: {:?}, range1: {:?}, range2: {:?}\n\n", range_0, range1, range2);
                     let extended_extranonce_factory = ExtendedExtranonce::from_upstream_extranonce(
                         upstream_extranonce_prefix,
                         range_0,
@@ -121,44 +121,102 @@ impl HandleMiningMessagesFromServerAsync for ChannelManager {
                         .safe_lock(|f| f.get_range2_len())
                         .expect("extranonce_prefix_factory mutex should not be poisoned")
                         as u16;
-                    if downstream_extranonce_len <= new_extranonce_size as usize {
+                    let new_extranonce_prefix = factory
+                        .safe_lock(|f| f.next_prefix_extended(new_extranonce_size as usize))
+                        .expect("extranonce_prefix_factory mutex should not be poisoned")
+                        .expect("next_prefix_extended should return a value for valid input")
+                        .into_b032();
+                    let new_downstream_extended_channel = ExtendedChannel::new(
+                        m.channel_id,
+                        user_identity.clone(),
+                        new_extranonce_prefix.clone().into_static().to_vec(),
+                        target.clone().into(),
+                        nominal_hashrate,
+                        true,
+                        new_extranonce_size,
+                    );
+                    channel_manager_data.extended_channels.insert(
+                        m.channel_id,
+                        Arc::new(RwLock::new(new_downstream_extended_channel)),
+                    );
+                    let new_open_extended_mining_channel_success =
+                        OpenExtendedMiningChannelSuccess {
+                            request_id: m.request_id,
+                            channel_id: m.channel_id,
+                            extranonce_prefix: new_extranonce_prefix,
+                            extranonce_size: new_extranonce_size,
+                            target: m.target.clone(),
+                        };
+                    new_open_extended_mining_channel_success.into_static()
+                } else {
+                    // Non-aggregated mode: check if we need to adjust extranonce size
+                    if m.extranonce_size as usize != downstream_extranonce_len {
+                        // We need to create an extranonce factory to ensure proper extranonce2_size
+                        let upstream_extranonce_prefix: Extranonce = m.extranonce_prefix.clone().into();
+                        let translator_proxy_extranonce_prefix_len = proxy_extranonce_prefix_len(
+                            m.extranonce_size.into(),
+                            downstream_extranonce_len,
+                        );
+
+                        // range 0 is the extranonce1 from upstream
+                        // range 1 is the extranonce1 added by the tproxy
+                        // range 2 is the extranonce2 used by the miner for rolling
+                        let range_0 = 0..extranonce_prefix.len();
+                        let range1 = range_0.end..range_0.end + translator_proxy_extranonce_prefix_len;
+                        let range2 = range1.end..range1.end + downstream_extranonce_len;
+                        debug!("\n\nrange_0: {:?}, range1: {:?}, range2: {:?}\n\n", range_0, range1, range2);
+                        // Create the factory - this should succeed if configuration is valid
+                        let extended_extranonce_factory = ExtendedExtranonce::from_upstream_extranonce(
+                            upstream_extranonce_prefix,
+                            range_0,
+                            range1,
+                            range2,
+                        )
+                        .expect("Failed to create ExtendedExtranonce factory - likely extranonce size configuration issue");
+                        // Store the factory for this specific channel
+                        let factory = Arc::new(Mutex::new(extended_extranonce_factory));
                         let new_extranonce_prefix = factory
-                            .safe_lock(|f| f.next_prefix_extended(new_extranonce_size as usize))
-                            .expect("extranonce_prefix_factory mutex should not be poisoned")
-                            .expect("next_prefix_extended should return a value for valid input")
+                            .safe_lock(|f| f.next_prefix_extended(downstream_extranonce_len))
+                            .expect("Failed to access extranonce factory")
+                            .expect("Failed to generate extranonce prefix")
                             .into_b032();
+                        // Create channel with the configured extranonce size
                         let new_downstream_extended_channel = ExtendedChannel::new(
                             m.channel_id,
                             user_identity.clone(),
                             new_extranonce_prefix.clone().into_static().to_vec(),
                             target.clone().into(),
                             nominal_hashrate,
                             true,
-                            new_extranonce_size,
+                            downstream_extranonce_len as u16,
                         );
                         channel_manager_data.extended_channels.insert(
                             m.channel_id,
                             Arc::new(RwLock::new(new_downstream_extended_channel)),
                         );
-                        let new_open_extended_mining_channel_success =
-                            OpenExtendedMiningChannelSuccess {
-                                request_id: m.request_id,
-                                channel_id: m.channel_id,
-                                extranonce_prefix: new_extranonce_prefix,
-                                extranonce_size: new_extranonce_size,
-                                target: m.target.clone(),
-                            };
-                        return new_open_extended_mining_channel_success.into_static();
+                        // Store factory for this channel (we'll need it for share processing)
+                        if channel_manager_data.extranonce_factories.is_none() {
+                            channel_manager_data.extranonce_factories = Some(std::collections::HashMap::new());
+                        }
+                        if let Some(ref mut factories) = channel_manager_data.extranonce_factories {
+                            factories.insert(m.channel_id, factory);
+                        }
+                        let new_open_extended_mining_channel_success = OpenExtendedMiningChannelSuccess {
+                            request_id: m.request_id,
+                            channel_id: m.channel_id,
+                            extranonce_prefix: new_extranonce_prefix,
+                            extranonce_size: downstream_extranonce_len as u16,
+                            target: m.target.clone(),
+                        };
+                        new_open_extended_mining_channel_success.into_static()
+                    } else {
+                        // Extranonce size matches, use as-is
+                        channel_manager_data
+                            .extended_channels
+                            .insert(m.channel_id, Arc::new(RwLock::new(extended_channel)));
+                        m.into_static()
                     }
                 }
-
-                // If we are not in aggregated mode, we just insert the extended channel into the
-                // map
-                channel_manager_data
-                    .extended_channels
-                    .insert(m.channel_id, Arc::new(RwLock::new(extended_channel)));
-
-                m.into_static()
             })
             .map_err(|e| {
                 error!("Failed to lock channel manager data: {:?}", e);
@@ -228,7 +286,7 @@ impl HandleMiningMessagesFromServerAsync for ChannelManager {
         &mut self,
         m: SubmitSharesError<'_>,
     ) -> Result<(), Self::Error> {
-        warn!("Received: {} ❌", m.channel_id);
+        warn!("Received: {} ❌", m);
         Ok(())
     }