Merge pull request #2006 from GitGab19/fix-version-bumps

GitGab19 · web-flow · commit c7cf42c3ec54 · 2025-11-25T23:17:09.000+01:00
remove dev-dependencies from `extensions_sv2`
diff --git a/.github/workflows/release-libs.yaml b/.github/workflows/release-libs.yaml
@@ -78,7 +78,12 @@ jobs:
         run: |
           ./scripts/release-libs.sh sv2/channels-sv2
 
-      # parsers_sv2 (depends on binary_sv2, framing_sv2, common_messages, mining, template_distribution, job_declaration)
+      # extensions_sv2 (depends on binary_sv2)
+      - name: Publish crate extensions_sv2
+        run: |
+          ./scripts/release-libs.sh sv2/extensions-sv2
+
+      # parsers_sv2 (depends on binary_sv2, framing_sv2, common_messages, mining, template_distribution, job_declaration, extensions_sv2)
       - name: Publish crate parsers_sv2
         run: |
           ./scripts/release-libs.sh sv2/parsers-sv2
@@ -92,13 +97,8 @@ jobs:
       - name: Publish crate stratum_translation
         run: |
           ./scripts/release-libs.sh stratum-core/stratum-translation
-
-      # extensions_sv2 (depends on binary_sv2, codec_sv2, framing_sv2, mining_sv2)
-      - name: Publish crate extensions_sv2
-        run: |
-          ./scripts/release-libs.sh sv2/extensions-sv2
           
-      # handlers_sv2 (depends on parsers_sv2, binary_sv2, common_messages_sv2, mining_sv2, template_distribution_sv2, job_declaration_sv2)
+      # handlers_sv2 (depends on parsers_sv2, binary_sv2, common_messages_sv2, mining_sv2, template_distribution_sv2, job_declaration_sv2, extensions_sv2)
       - name: Publish crate handlers_sv2
         run: |
           ./scripts/release-libs.sh sv2/handlers-sv2
diff --git a/sv2/extensions-sv2/Cargo.toml b/sv2/extensions-sv2/Cargo.toml
@@ -13,7 +13,3 @@ keywords = ["stratum", "mining", "bitcoin", "protocol", "extensions"]
 
 [dependencies]
 binary_sv2 = { path = "../binary-sv2", version = "^5.0.0" }
-
-[dev-dependencies]
-parsers_sv2 = { path = "../parsers-sv2", version = "^0.2.0" }
-mining_sv2 = { path = "../subprotocols/mining", version = "^6.0.0" }
diff --git a/sv2/extensions-sv2/examples/extensions_negotiation.rs b/sv2/extensions-sv2/examples/extensions_negotiation.rs
@@ -1,3 +1,10 @@
+// NOTE: This example is part of the workspace and relies on workspace dependencies.
+// To run: cargo run --example extensions_negotiation --package extensions_sv2 (from workspace root)
+//
+// This example demonstrates the Extensions Negotiation protocol (extension_type=0x0001)
+// which allows Stratum V2 endpoints to negotiate which optional extensions are supported
+// during connection setup.
+
 use binary_sv2::Seq064K;
 use extensions_sv2::{RequestExtensions, RequestExtensionsError, RequestExtensionsSuccess};
 
diff --git a/sv2/extensions-sv2/examples/worker_specific_hashrate_tracking.rs b/sv2/extensions-sv2/examples/worker_specific_hashrate_tracking.rs
@@ -1,228 +1,121 @@
-use binary_sv2::Seq064K;
+// NOTE: This is a simplified example that demonstrates UserIdentity creation.
+// For full TLV encoding/decoding examples with parsers_sv2, see the parsers_sv2 crate tests
+// or run integration tests from the workspace root.
+//
+// To run: cargo run --example worker_specific_hashrate_tracking --package extensions_sv2
+
 use extensions_sv2::{
-    RequestExtensions, RequestExtensionsSuccess, UserIdentity,
-    EXTENSION_TYPE_WORKER_HASHRATE_TRACKING, TLV_FIELD_TYPE_USER_IDENTITY,
+    UserIdentity, EXTENSION_TYPE_WORKER_HASHRATE_TRACKING, TLV_FIELD_TYPE_USER_IDENTITY,
 };
-use mining_sv2::SubmitSharesExtended;
-use parsers_sv2::{TlvField, TlvList, TLV_HEADER_SIZE};
 
 fn main() {
-    println!("=== Worker-Specific Hashrate Tracking Extension Example ===\n");
-
-    // Step 1: Client requests the Worker Hashrate Tracking extension
-    println!("1. Extension Negotiation:");
-    println!("   Client requests Worker Hashrate Tracking extension (0x0002)");
+    println!("=== Worker-Specific Hashrate Tracking Extension (Simplified) ===\n");
 
-    let request = RequestExtensions {
-        request_id: 1,
-        requested_extensions: Seq064K::new(vec![EXTENSION_TYPE_WORKER_HASHRATE_TRACKING]).unwrap(),
-    };
-    println!("   {}", request);
+    // Step 1: Extension Overview
+    println!("1. Extension Overview:");
     println!(
-        "   Extension type: 0x{:04x}\n",
+        "   Extension Type: 0x{:04x}",
         EXTENSION_TYPE_WORKER_HASHRATE_TRACKING
     );
-
-    // Step 2: Server accepts the extension
-    println!("2. Server Response:");
-    let success = RequestExtensionsSuccess {
-        request_id: 1,
-        supported_extensions: Seq064K::new(vec![EXTENSION_TYPE_WORKER_HASHRATE_TRACKING]).unwrap(),
-    };
-    println!("   {}", success);
+    println!("   Purpose: Track individual worker hashrates within aggregated channels");
     println!(
-        "   Extension 0x{:04x} is now active!\n",
-        EXTENSION_TYPE_WORKER_HASHRATE_TRACKING
+        "   TLV Field Type for user_identity: 0x{:02x}\n",
+        TLV_FIELD_TYPE_USER_IDENTITY
     );
 
-    // Step 3: Demonstrate TLV field for user_identity
-    println!("3. TLV Field Structure:");
-    println!("   When submitting shares, the client appends a TLV field:");
-    println!(
-        "   - Type (U16 | U8): Extension Type (0x{:04x}) | Field Type (0x{:02x})",
-        EXTENSION_TYPE_WORKER_HASHRATE_TRACKING, TLV_FIELD_TYPE_USER_IDENTITY
-    );
-    println!("   - Length (U16): Actual byte length of worker name");
-    println!("   - Value: UTF-8 encoded worker identifier\n");
-
-    // Step 4: Create UserIdentity TLV fields for different workers
-    println!("4. Example TLV Fields for Different Workers:\n");
+    // Step 2: Creating UserIdentity instances
+    println!("2. Creating UserIdentity Instances:\n");
 
-    let workers = vec!["Worker_001", "Miner_A", "Device_12345678901234567890123"];
+    let workers = vec![
+        "Worker_001",
+        "Miner_A",
+        "Device_12345678901234567890123", // 27 bytes (under 32 byte limit)
+    ];
 
     for worker_name in workers {
-        let user_id = UserIdentity::new(worker_name).unwrap();
-
-        println!("   {}", user_id);
-        let tlv_bytes = TlvField::to_bytes(&user_id).unwrap();
-        println!("   TLV Size: {} bytes", tlv_bytes.len());
-        println!(
-            "   TLV Format: [Type: 0x{:04x}|0x{:02x}] [Length: 0x{:04x}] [Value: \"{}\"]",
-            EXTENSION_TYPE_WORKER_HASHRATE_TRACKING,
-            TLV_FIELD_TYPE_USER_IDENTITY,
-            worker_name.len(),
-            worker_name
-        );
-
-        println!(
-            "   Total TLV overhead: {} bytes + {} bytes (worker name) = {} bytes\n",
-            TLV_HEADER_SIZE,
-            worker_name.len(),
-            tlv_bytes.len()
-        );
-    }
-
-    // Step 5: Build a complete SubmitSharesExtended frame with TLV
-    println!("5. Building a SubmitSharesExtended Frame with Worker Identity:\n");
-
-    let submit_shares = SubmitSharesExtended {
-        channel_id: 1,
-        sequence_number: 42,
-        job_id: 1,
-        nonce: 0x12345678,
-        ntime: 0x87654321,
-        version: 0x20000000,
-        extranonce: vec![0x01, 0x02, 0x03, 0x04].try_into().unwrap(),
-    };
-
-    // Without worker identity (empty TLV list)
-    let tlv_list_empty = TlvList::from_slice(&[]).unwrap();
-    let frame_bytes_without = tlv_list_empty
-        .build_frame_bytes_with_tlvs(parsers_sv2::Mining::SubmitSharesExtended(
-            submit_shares.clone(),
-        ))
-        .unwrap();
-    println!(
-        "   Frame bytes without worker identity: {} bytes",
-        frame_bytes_without.len()
-    );
-
-    // With worker identity (using UserIdentity::to_tlv())
-    let user_identity = UserIdentity::new("Worker_001").unwrap();
-    let tlv = user_identity.to_tlv().unwrap();
-    let tlv_list_with = TlvList::from_slice(&[tlv]).unwrap();
-    let frame_bytes_with = tlv_list_with
-        .build_frame_bytes_with_tlvs(parsers_sv2::Mining::SubmitSharesExtended(submit_shares))
-        .unwrap();
-    println!(
-        "   Frame bytes with worker identity: {} bytes",
-        frame_bytes_with.len()
-    );
-    println!(
-        "   Difference: {} bytes (TLV overhead + worker name)\n",
-        frame_bytes_with.len() - frame_bytes_without.len()
-    );
-
-    // Step 6: Parsing TLV fields on the receiving side (Pool)
-    println!("6. Parsing TLV Fields from Received Messages:\n");
-    println!("   When a pool receives SubmitSharesExtended with TLV data:");
-
-    // Simulate TLV data that would be appended to a message
-    let worker1_tlv = TlvField::to_bytes(&UserIdentity::new("Worker_001").unwrap()).unwrap();
-    let worker2_tlv = TlvField::to_bytes(&UserIdentity::new("Miner_A").unwrap()).unwrap();
-
-    // Demo 1: Parse single TLV
-    println!("\n   a) Parse single worker identity:");
-    let tlv_list = TlvList::from_bytes(&worker1_tlv);
-    let negotiated = vec![EXTENSION_TYPE_WORKER_HASHRATE_TRACKING];
-    let tlvs = tlv_list.for_extensions(&negotiated);
-
-    // Find user_identity TLV
-    for tlv in &tlvs {
-        if tlv.r#type.extension_type == EXTENSION_TYPE_WORKER_HASHRATE_TRACKING
-            && tlv.r#type.field_type == TLV_FIELD_TYPE_USER_IDENTITY
-        {
-            if let Ok(user_identity) = UserIdentity::from_tlv(tlv) {
-                println!("      Found worker: {}", user_identity);
+        match UserIdentity::new(worker_name) {
+            Ok(user_id) => {
+                println!("   Created: {}", user_id);
+                println!("     - Name: {}", user_id.as_str().unwrap());
+                println!("     - Length: {} bytes", user_id.len());
+                println!("     - Raw bytes: {:?}\n", user_id.as_bytes());
             }
-        }
-    }
-
-    // Demo 2: Parse with TlvList iterator API
-    println!("\n   b) Using iterator API to process TLVs:");
-    for result in tlv_list.iter() {
-        match result {
-            Ok(tlv) => {
-                println!(
-                    "      - Extension: 0x{:04x}, Field: 0x{:02x}, Length: {} bytes",
-                    tlv.r#type.extension_type, tlv.r#type.field_type, tlv.length
-                );
-                if let Ok(s) = std::str::from_utf8(&tlv.value) {
-                    println!("        Value: \"{}\"", s);
-                }
+            Err(e) => {
+                println!("   Error creating worker '{}': {}\n", worker_name, e);
             }
-            Err(e) => println!("      - Error parsing TLV: {:?}", e),
         }
     }
 
-    // Demo 3: Multiple TLVs (simulating batch processing)
-    println!("\n   c) Processing multiple shares with different workers:");
-    let shares_with_workers = vec![
-        ("Worker_001", worker1_tlv.clone()),
-        ("Miner_A", worker2_tlv.clone()),
-    ];
+    // Step 3: Demonstrate length limits
+    println!("3. Length Validation:\n");
 
-    for (expected, tlv_data) in shares_with_workers {
-        let tlvs = TlvList::from_bytes(&tlv_data).for_extensions(&negotiated);
-        for tlv in &tlvs {
-            if tlv.r#type.extension_type == EXTENSION_TYPE_WORKER_HASHRATE_TRACKING
-                && tlv.r#type.field_type == TLV_FIELD_TYPE_USER_IDENTITY
-            {
-                if let Ok(worker) = UserIdentity::from_tlv(tlv) {
-                    println!("      Share from: {} (expected: {})", worker, expected);
-                }
-            }
+    // Valid: exactly 32 bytes
+    let max_length_name = "x".repeat(32);
+    match UserIdentity::new(&max_length_name) {
+        Ok(user_id) => {
+            println!("   ✓ 32-byte worker name accepted (max length)");
+            println!("     Length: {} bytes\n", user_id.len());
+        }
+        Err(e) => {
+            println!("   ✗ Unexpected error: {}\n", e);
         }
     }
 
-    // Demo 4: Using find() to search for specific TLV
-    println!("\n   d) Find specific TLV field:");
-    if let Some(tlv) = TlvList::from_bytes(&worker1_tlv).find(
-        EXTENSION_TYPE_WORKER_HASHRATE_TRACKING,
-        TLV_FIELD_TYPE_USER_IDENTITY,
-    ) {
-        println!(
-            "      Found user_identity TLV with {} bytes",
-            tlv.value.len()
-        );
-        if let Ok(s) = std::str::from_utf8(&tlv.value) {
-            println!("      Worker: \"{}\"", s);
+    // Invalid: exceeds 32 bytes
+    let too_long_name = "x".repeat(33);
+    match UserIdentity::new(&too_long_name) {
+        Ok(_) => {
+            println!("   ✗ 33-byte worker name should have been rejected!\n");
+        }
+        Err(e) => {
+            println!("   ✓ 33-byte worker name rejected as expected");
+            println!("     Error: {}\n", e);
         }
     }
 
-    println!();
+    // Step 4: Empty worker identity
+    println!("4. Edge Cases:\n");
 
-    // Step 7: Convenience methods for applications
-    println!("7. Simplified API for Applications:\n");
+    let empty_identity = UserIdentity::new("").unwrap();
+    println!("   Empty identity:");
+    println!("     - Is empty: {}", empty_identity.is_empty());
+    println!("     - Length: {} bytes\n", empty_identity.len());
 
-    println!("   a) Convert UserIdentity to TLV:");
-    let user_identity = UserIdentity::new("Worker_001").unwrap();
-    let tlv = TlvField::to_tlv(&user_identity).unwrap();
-    println!(
-        "      Created TLV: extension_type=0x{:04x}, field_type=0x{:02x}",
-        tlv.r#type.extension_type, tlv.r#type.field_type
-    );
+    // Step 5: Byte-level construction
+    println!("5. Creating from Raw Bytes:\n");
 
-    println!("\n   b) Create Vec<Tlv> from UserIdentity:");
-    let tlv_vec = vec![TlvField::to_tlv(&user_identity).unwrap()];
-    println!("      Created Vec<Tlv> with {} element(s)", tlv_vec.len());
-    println!(
-        "      Usage: channel_sender.send((Mining::SubmitSharesExtended(msg), Some(tlv_vec)))?;"
-    );
+    let raw_bytes = b"CustomWorker";
+    let identity = UserIdentity::from_bytes(raw_bytes).unwrap();
+    println!("   From bytes: {:?}", raw_bytes);
+    println!("   Result: {}", identity);
+    println!("   As string: {}\n", identity.as_str().unwrap());
 
-    println!("\n   This simplifies the application code:");
-    println!("      let user_identity = UserIdentity::new(worker_name)?;");
-    println!("      let tlv = TlvField::to_tlv(&user_identity)?;");
-    println!("      let tlv_vec = vec![tlv];");
+    // Step 6: Display method
+    println!("6. Display Format:\n");
 
-    println!();
+    let identity = UserIdentity::new("ExampleWorker").unwrap();
+    println!("   Display: {}", identity);
+    println!("   Debug: {:?}\n", identity);
+
+    // Step 7: Invalid UTF-8 handling
+    println!("7. Invalid UTF-8 Handling:\n");
+
+    let invalid_utf8_bytes = vec![0xFF, 0xFE, 0xFD];
+    let invalid_identity = UserIdentity::from_bytes(&invalid_utf8_bytes).unwrap();
+    println!("   Bytes: {:?}", invalid_utf8_bytes);
+    println!("   as_str(): {:?}", invalid_identity.as_str());
+    println!(
+        "   as_string_or_hex(): {}\n",
+        invalid_identity.as_string_or_hex()
+    );
 
-    // Step 9: Use case example
-    println!("9. Use Case - Mining Farm with Multiple Workers:");
-    println!("   A mining farm with 100 devices can use a single extended channel");
-    println!("   and track per-device hashrate by including the device worker_name in each share.");
-    println!("   This allows the pool to monitor individual device performance while");
-    println!("   reducing connection overhead compared to 100 separate channels.\n");
+    // Step 8: Usage context
+    println!("8. Usage in Stratum V2:\n");
+    println!("   When the Worker-Specific Hashrate Tracking extension (0x0002) is negotiated,");
+    println!("   UserIdentity can be included as a TLV field in SubmitSharesExtended messages.");
+    println!("   This allows pools to track per-worker hashrate within aggregated channels.\n");
+    println!("   For full TLV encoding/decoding examples, use the parsers_sv2 crate which");
+    println!("   implements the TlvField trait for UserIdentity.\n");
 
     println!("=== Example Complete ===");
 }
