fix(whatsminer): correct inverted is_mining logic across all backends

V1/V2: The `btmineroff`/`mineroff` field means "miner is off", so
"true" means mining is OFF. The old code checked `l != "false"` which
returned true (mining) when the miner was actually paused. Also added
a fallback extractor at `/Msg/mineroff` for newer firmware responding
to the legacy API.

V3: Had no implementation (always returned true). Now extracts the
`working` field from `get.device.info` which directly indicates
whether the miner is active.

Verified against M60SVK40 hardware: pause() correctly flips
is_mining to false, resume() flips it back to true.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ankitgoswami

asic-rs-firmwares/whatsminer/src/backends/v1/mod.rs

@@ -218,14 +218,24 @@ impl GetDataLocations for WhatsMinerV1 {
                     tag: None,
                 },
             )],
-            DataField::IsMining => vec![(
-                RPC_STATUS,
-                DataExtractor {
-                    func: get_by_pointer,
-                    key: Some("/SUMMARY/0/btmineroff"),
-                    tag: None,
-                },
-            )],
+            DataField::IsMining => vec![
+                (
+                    RPC_STATUS,
+                    DataExtractor {
+                        func: get_by_pointer,
+                        key: Some("/SUMMARY/0/btmineroff"),
+                        tag: None,
+                    },
+                ),
+                (
+                    RPC_STATUS,
+                    DataExtractor {
+                        func: get_by_pointer,
+                        key: Some("/Msg/mineroff"),
+                        tag: None,
+                    },
+                ),
+            ],
             DataField::Messages => vec![(
                 RPC_SUMMARY,
                 DataExtractor {
@@ -473,8 +483,9 @@ impl GetUptime for WhatsMinerV1 {
 }
 impl GetIsMining for WhatsMinerV1 {
     fn parse_is_mining(&self, data: &HashMap<DataField, Value>) -> bool {
-        data.extract_map::<String, _>(DataField::IsMining, |l| l != "false")
-            .unwrap_or(true)
+        // Raw field is "mineroff" / "btmineroff": "true" means mining is OFF.
+        let miner_off = data.extract::<String>(DataField::IsMining);
+        miner_off.as_deref() != Some("true")
     }
 }
 impl GetPools for WhatsMinerV1 {
@@ -692,4 +703,45 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_parse_is_mining_when_miner_off() {
+        // Arrange - mineroff="true" means the miner is off
+        let miner = WhatsMinerV1::new(IpAddr::from([127, 0, 0, 1]), WhatsMinerModel::M20SV10);
+        let mut data = HashMap::new();
+        data.insert(DataField::IsMining, Value::String("true".to_string()));
+
+        // Act
+        let is_mining = miner.parse_is_mining(&data);
+
+        // Assert
+        assert!(!is_mining);
+    }
+
+    #[test]
+    fn test_parse_is_mining_when_miner_on() {
+        // Arrange - mineroff="false" means the miner is running
+        let miner = WhatsMinerV1::new(IpAddr::from([127, 0, 0, 1]), WhatsMinerModel::M20SV10);
+        let mut data = HashMap::new();
+        data.insert(DataField::IsMining, Value::String("false".to_string()));
+
+        // Act
+        let is_mining = miner.parse_is_mining(&data);
+
+        // Assert
+        assert!(is_mining);
+    }
+
+    #[test]
+    fn test_parse_is_mining_missing_defaults_to_mining() {
+        // Arrange - no status data available
+        let miner = WhatsMinerV1::new(IpAddr::from([127, 0, 0, 1]), WhatsMinerModel::M20SV10);
+        let data = HashMap::new();
+
+        // Act
+        let is_mining = miner.parse_is_mining(&data);
+
+        // Assert
+        assert!(is_mining);
+    }
 }

asic-rs-firmwares/whatsminer/src/backends/v2/mod.rs

@@ -243,14 +243,24 @@ impl GetDataLocations for WhatsMinerV2 {
                     tag: None,
                 },
             )],
-            DataField::IsMining => vec![(
-                RPC_STATUS,
-                DataExtractor {
-                    func: get_by_pointer,
-                    key: Some("/SUMMARY/0/btmineroff"),
-                    tag: None,
-                },
-            )],
+            DataField::IsMining => vec![
+                (
+                    RPC_STATUS,
+                    DataExtractor {
+                        func: get_by_pointer,
+                        key: Some("/SUMMARY/0/btmineroff"),
+                        tag: None,
+                    },
+                ),
+                (
+                    RPC_STATUS,
+                    DataExtractor {
+                        func: get_by_pointer,
+                        key: Some("/Msg/mineroff"),
+                        tag: None,
+                    },
+                ),
+            ],
             DataField::Messages => vec![(
                 RPC_GET_ERROR_CODE,
                 DataExtractor {
@@ -507,8 +517,9 @@ impl GetUptime for WhatsMinerV2 {
 }
 impl GetIsMining for WhatsMinerV2 {
     fn parse_is_mining(&self, data: &HashMap<DataField, Value>) -> bool {
-        data.extract_map::<String, _>(DataField::IsMining, |l| l != "false")
-            .unwrap_or(true)
+        // Raw field is "mineroff" / "btmineroff": "true" means mining is OFF.
+        let miner_off = data.extract::<String>(DataField::IsMining);
+        miner_off.as_deref() != Some("true")
     }
 }
 impl GetPools for WhatsMinerV2 {

asic-rs-firmwares/whatsminer/src/backends/v3/mod.rs

@@ -244,6 +244,14 @@ impl GetDataLocations for WhatsMinerV3 {
                     tag: None,
                 },
             )],
+            DataField::IsMining => vec![(
+                RPC_GET_DEVICE_INFO,
+                DataExtractor {
+                    func: get_by_pointer,
+                    key: Some("/msg/miner/working"),
+                    tag: None,
+                },
+            )],
             _ => vec![],
         }
     }
@@ -449,7 +457,13 @@ impl GetUptime for WhatsMinerV3 {
         data.extract_map::<u64, _>(DataField::Uptime, Duration::from_secs)
     }
 }
-impl GetIsMining for WhatsMinerV3 {}
+impl GetIsMining for WhatsMinerV3 {
+    fn parse_is_mining(&self, data: &HashMap<DataField, Value>) -> bool {
+        // Raw field is "working": "true" means mining is ON.
+        let working = data.extract::<String>(DataField::IsMining);
+        working.as_deref() != Some("false")
+    }
+}
 impl GetPools for WhatsMinerV3 {
     fn parse_pools(&self, data: &HashMap<DataField, Value>) -> Vec<PoolGroupData> {
         let mut pools: Vec<PoolData> = Vec::new();