version: bump version number

* feature: add luxos tuner support to config.

* feature: add luxos temp control support to config.

* bug: fix failure to identify luxOS miners sometimes.

* feature: add get_config with temperature parsing.

* bug: fix some handling in hashboards.

* feature: add API version and fw version.

* refactor: improve RPC api handling.

* refactor: remove useless code, and tag bug.

* feature: add fault light check support.

* refactor: improve fanset compatibility.

* feature: add fan config parsing.

* feature: add pools parsing from luxos.

---------

Co-authored-by: Upstream Data <brett@upstreamdata.ca>

.pre-commit-config.yaml

@@ -1,12 +1,15 @@
+ci:
+  skip:
+    - unittest
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v5.0.0
     hooks:
     -   id: trailing-whitespace
     -   id: check-yaml
     -   id: check-added-large-files
 -   repo: https://github.com/psf/black
-    rev: 24.3.0
+    rev: 24.10.0
     hooks:
     -   id: black
 -   repo: https://github.com/pycqa/isort
@@ -24,4 +27,3 @@ repos:
         'types': [python]
         args: ["-p '*test.py'"] # Probably this option is absolutely not needed.
         pass_filenames: false
-        stages: [commit]

docs/miners/antminer/X15.md

@@ -8,3 +8,10 @@
         show_root_heading: false
         heading_level: 4
 
+## Z15 Pro (Stock)
+::: pyasic.miners.antminer.bmminer.X15.Z15.BMMinerZ15Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X19.md

@@ -274,6 +274,13 @@
         show_root_heading: false
         heading_level: 4
 
+## S19j Pro (VNish)
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19jPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## S19a (VNish)
 ::: pyasic.miners.antminer.vnish.X19.S19.VNishS19a
     handler: python

docs/miners/antminer/X21.md

@@ -29,6 +29,13 @@
         show_root_heading: false
         heading_level: 4
 
+## T21 (BOS+)
+::: pyasic.miners.antminer.bosminer.X21.T21.BOSMinerT21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## S21 (VNish)
 ::: pyasic.miners.antminer.vnish.X21.S21.VNishS21
     handler: python

docs/miners/antminer/X3.md

@@ -22,6 +22,20 @@
         show_root_heading: false
         heading_level: 4
 
+## KA3 (Stock)
+::: pyasic.miners.antminer.bmminer.X3.KA3.BMMinerKA3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3 (Stock)
+::: pyasic.miners.antminer.bmminer.X3.KS3.BMMinerKS3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## L3+ (VNish)
 ::: pyasic.miners.antminer.vnish.X3.L3.VnishL3Plus
     handler: python

docs/miners/antminer/X5.md

@@ -8,3 +8,10 @@
         show_root_heading: false
         heading_level: 4
 
+## KS5 (Stock)
+::: pyasic.miners.antminer.bmminer.X5.KS5.BMMinerKS5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/antminer/X7.md

@@ -8,6 +8,13 @@
         show_root_heading: false
         heading_level: 4
 
+## K7 (Stock)
+::: pyasic.miners.antminer.bmminer.X7.K7.BMMinerK7
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## L7 (VNish)
 ::: pyasic.miners.antminer.vnish.X7.L7.VnishL7
     handler: python

docs/miners/avalonminer/nano.md

@@ -0,0 +1,10 @@
+# pyasic
+## nano Models
+
+## Avalon Nano 3 (Stock)
+::: pyasic.miners.avalonminer.cgminer.nano.nano3.CGMinerAvalonNano3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/iceriver/KSX.md

@@ -1,6 +1,20 @@
 # pyasic
 ## KSX Models
 
+## KS0 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS0.IceRiverKS0
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS1 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS1.IceRiverKS1
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## KS2 (Stock)
 ::: pyasic.miners.iceriver.iceminer.KSX.KS2.IceRiverKS2
     handler: python
@@ -8,3 +22,45 @@
         show_root_heading: false
         heading_level: 4
 
+## KS3 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3L (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3L
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS3M (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS3.IceRiverKS3M
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5 (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5L (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5L
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## KS5M (Stock)
+::: pyasic.miners.iceriver.iceminer.KSX.KS5.IceRiverKS5M
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/innosilicon/A11X.md

@@ -0,0 +1,17 @@
+# pyasic
+## A11X Models
+
+## A11 (Stock)
+::: pyasic.miners.innosilicon.cgminer.A11X.A11.InnosiliconA11
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
+## A11MX (Stock)
+::: pyasic.miners.innosilicon.cgminer.A11X.A11M.InnosiliconA11MX
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+

docs/miners/supported_types.md

@@ -21,18 +21,22 @@ details {
                     <li><a href="../antminer/X3#d3-stock">D3 (Stock)</a></li>
                     <li><a href="../antminer/X3#hs3-stock">HS3 (Stock)</a></li>
                     <li><a href="../antminer/X3#l3_1-stock">L3+ (Stock)</a></li>
+                    <li><a href="../antminer/X3#ka3-stock">KA3 (Stock)</a></li>
+                    <li><a href="../antminer/X3#ks3-stock">KS3 (Stock)</a></li>
                 </ul>
         </details>
         <details>
             <summary>X5 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X5#dr5-stock">DR5 (Stock)</a></li>
+                    <li><a href="../antminer/X5#ks5-stock">KS5 (Stock)</a></li>
                 </ul>
         </details>
         <details>
             <summary>X7 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X7#l7-stock">L7 (Stock)</a></li>
+                    <li><a href="../antminer/X7#k7-stock">K7 (Stock)</a></li>
                 </ul>
         </details>
         <details>
@@ -49,6 +53,7 @@ details {
             <summary>X15 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X15#z15-stock">Z15 (Stock)</a></li>
+                    <li><a href="../antminer/X15#z15-pro-stock">Z15 Pro (Stock)</a></li>
                 </ul>
         </details>
         <details>
@@ -278,6 +283,7 @@ details {
                     <li><a href="../whatsminer/M5X#m50-vh60-stock">M50 VH60 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vh70-stock">M50 VH70 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vh80-stock">M50 VH80 (Stock)</a></li>
+                    <li><a href="../whatsminer/M5X#m50-vh90-stock">M50 VH90 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vj10-stock">M50 VJ10 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vj20-stock">M50 VJ20 (Stock)</a></li>
                     <li><a href="../whatsminer/M5X#m50-vj30-stock">M50 VJ30 (Stock)</a></li>
@@ -378,6 +384,12 @@ details {
                     <li><a href="../avalonminer/A12X#avalon-1246-stock">Avalon 1246 (Stock)</a></li>
                 </ul>
         </details>
+        <details>
+            <summary>nano Series:</summary>
+                <ul>
+                    <li><a href="../avalonminer/nano#avalon-nano-3-stock">Avalon Nano 3 (Stock)</a></li>
+                </ul>
+        </details>
     </ul>
 </details>
 <details>
@@ -395,6 +407,13 @@ details {
                     <li><a href="../innosilicon/A10X#a10x-stock">A10X (Stock)</a></li>
                 </ul>
         </details>
+        <details>
+            <summary>A11X Series:</summary>
+                <ul>
+                    <li><a href="../innosilicon/A11X#a11-stock">A11 (Stock)</a></li>
+                    <li><a href="../innosilicon/A11X#a11mx-stock">A11MX (Stock)</a></li>
+                </ul>
+        </details>
     </ul>
 </details>
 <details>
@@ -470,6 +489,7 @@ details {
             <summary>X21 Series:</summary>
                 <ul>
                     <li><a href="../antminer/X21#s21-bos_1">S21 (BOS+)</a></li>
+                    <li><a href="../antminer/X21#t21-bos_1">T21 (BOS+)</a></li>
                 </ul>
         </details>
     </ul>
@@ -505,6 +525,7 @@ details {
                     <li><a href="../antminer/X19#s19-pro-vnish">S19 Pro (VNish)</a></li>
                     <li><a href="../antminer/X19#s19j-vnish">S19j (VNish)</a></li>
                     <li><a href="../antminer/X19#s19j-pro-vnish">S19j Pro (VNish)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro-vnish">S19j Pro (VNish)</a></li>
                     <li><a href="../antminer/X19#s19a-vnish">S19a (VNish)</a></li>
                     <li><a href="../antminer/X19#s19a-pro-vnish">S19a Pro (VNish)</a></li>
                     <li><a href="../antminer/X19#s19-pro-hydro-vnish">S19 Pro Hydro (VNish)</a></li>
@@ -661,7 +682,15 @@ details {
         <details>
             <summary>KSX Series:</summary>
                 <ul>
+                    <li><a href="../iceriver/KSX#ks0-stock">KS0 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks1-stock">KS1 (Stock)</a></li>
                     <li><a href="../iceriver/KSX#ks2-stock">KS2 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks3-stock">KS3 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks3l-stock">KS3L (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks3m-stock">KS3M (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks5-stock">KS5 (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks5l-stock">KS5L (Stock)</a></li>
+                    <li><a href="../iceriver/KSX#ks5m-stock">KS5M (Stock)</a></li>
                 </ul>
         </details>
     </ul>

docs/miners/whatsminer/M5X.md

@@ -71,6 +71,13 @@
         show_root_heading: false
         heading_level: 4
 
+## M50 VH90 (Stock)
+::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VH90
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 4
+
 ## M50 VJ10 (Stock)
 ::: pyasic.miners.whatsminer.btminer.M5X.M50.BTMinerM50VJ10
     handler: python

pyasic/config/__init__.py

@@ -148,6 +148,14 @@ class MinerConfig:
             **self.pools.as_bitaxe(user_suffix=user_suffix),
         }
 
+    def as_luxos(self, user_suffix: str = None) -> dict:
+        return {
+            **self.fan_mode.as_luxos(),
+            **self.temperature.as_luxos(),
+            **self.mining_mode.as_luxos(),
+            **self.pools.as_luxos(user_suffix=user_suffix),
+        }
+
     @classmethod
     def from_dict(cls, dict_conf: dict) -> "MinerConfig":
         """Constructs a MinerConfig object from a dictionary."""
@@ -250,3 +258,21 @@ class MinerConfig:
             pools=PoolConfig.from_bitaxe(web_system_info),
             fan_mode=FanModeConfig.from_bitaxe(web_system_info),
         )
+
+    @classmethod
+    def from_iceriver(cls, web_userpanel: dict) -> "MinerConfig":
+        return cls(
+            pools=PoolConfig.from_iceriver(web_userpanel),
+        )
+
+    @classmethod
+    def from_luxos(
+        cls, rpc_tempctrl: dict, rpc_fans: dict, rpc_pools: dict, rpc_groups: dict
+    ) -> "MinerConfig":
+        return cls(
+            temperature=TemperatureConfig.from_luxos(rpc_tempctrl=rpc_tempctrl),
+            fan_mode=FanModeConfig.from_luxos(
+                rpc_tempctrl=rpc_tempctrl, rpc_fans=rpc_fans
+            ),
+            pools=PoolConfig.from_luxos(rpc_pools=rpc_pools, rpc_groups=rpc_groups),
+        )

pyasic/config/base.py

@@ -63,6 +63,9 @@ class MinerConfigOption(Enum):
     def as_bitaxe(self) -> dict:
         return self.value.as_bitaxe()
 
+    def as_luxos(self) -> dict:
+        return self.value.as_luxos()
+
     def __call__(self, *args, **kwargs):
         return self.value(*args, **kwargs)
 
@@ -125,6 +128,9 @@ class MinerConfigValue:
     def as_bitaxe(self) -> dict:
         return {}
 
+    def as_luxos(self) -> dict:
+        return {}
+
     def __getitem__(self, item):
         try:
             return getattr(self, item)

pyasic/config/fans.py

@@ -83,6 +83,9 @@ class FanModeNormal(MinerConfigValue):
     def as_bitaxe(self) -> dict:
         return {"autoFanspeed": 1}
 
+    def as_luxos(self) -> dict:
+        return {"fanset": {"speed": -1, "min_fans": self.minimum_fans}}
+
 
 @dataclass
 class FanModeManual(MinerConfigValue):
@@ -144,6 +147,9 @@ class FanModeManual(MinerConfigValue):
     def as_bitaxe(self) -> dict:
         return {"autoFanspeed": 0, "fanspeed": self.speed}
 
+    def as_luxos(self) -> dict:
+        return {"fanset": {"speed": self.speed, "min_fans": self.minimum_fans}}
+
 
 @dataclass
 class FanModeImmersion(MinerConfigValue):
@@ -167,6 +173,9 @@ class FanModeImmersion(MinerConfigValue):
     def as_mara(self) -> dict:
         return {"general-config": {"environment-profile": "OilImmersionCooling"}}
 
+    def as_luxos(self) -> dict:
+        return {"fanset": {"speed": 0, "min_fans": 0}}
+
 
 class FanModeConfig(MinerConfigOption):
     normal = FanModeNormal
@@ -304,3 +313,23 @@ class FanModeConfig(MinerConfigOption):
             return cls.normal()
         else:
             return cls.manual(speed=web_system_info["fanspeed"])
+
+    @classmethod
+    def from_luxos(cls, rpc_fans: dict, rpc_tempctrl: dict):
+        try:
+            mode = rpc_tempctrl["TEMPCTRL"][0]["Mode"]
+            if mode == "Manual":
+                speed = rpc_fans["FANS"][0]["Speed"]
+                min_fans = rpc_fans["FANCTRL"][0]["MinFans"]
+                if min_fans == 0 and speed == 0:
+                    return cls.immersion()
+                return cls.manual(
+                    speed=speed,
+                    minimum_fans=min_fans,
+                )
+            return cls.normal(
+                minimum_fans=rpc_fans["FANCTRL"][0]["MinFans"],
+            )
+        except LookupError:
+            pass
+        return cls.default()

pyasic/config/mining/__init__.py

@@ -70,6 +70,9 @@ class MiningModeNormal(MinerConfigValue):
             }
         }
 
+    def as_luxos(self) -> dict:
+        return {"autotunerset": {"enabled": False}}
+
 
 @dataclass
 class MiningModeSleep(MinerConfigValue):
@@ -198,7 +201,7 @@ class MiningModePowerTune(MinerConfigValue):
     def as_boser(self) -> dict:
         cfg = {
             "set_performance_mode": SetPerformanceModeRequest(
-                save_action=SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+                save_action=SaveAction.SAVE_AND_APPLY,
                 mode=PerformanceMode(
                     tuner_mode=TunerPerformanceMode(
                         power_target=PowerTargetMode(
@@ -240,6 +243,9 @@ class MiningModePowerTune(MinerConfigValue):
             }
         }
 
+    def as_luxos(self) -> dict:
+        return {"autotunerset": {"enabled": True}}
+
 
 @dataclass
 class MiningModeHashrateTune(MinerConfigValue):
@@ -275,7 +281,7 @@ class MiningModeHashrateTune(MinerConfigValue):
     def as_boser(self) -> dict:
         cfg = {
             "set_performance_mode": SetPerformanceModeRequest(
-                save_action=SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+                save_action=SaveAction.SAVE_AND_APPLY,
                 mode=PerformanceMode(
                     tuner_mode=TunerPerformanceMode(
                         hashrate_target=HashrateTargetMode(
@@ -333,6 +339,9 @@ class MiningModeHashrateTune(MinerConfigValue):
             }
         }
 
+    def as_luxos(self) -> dict:
+        return {"autotunerset": {"enabled": True}}
+
 
 @dataclass
 class ManualBoardSettings(MinerConfigValue):

pyasic/config/pools.py

@@ -222,6 +222,18 @@ class Pool(MinerConfigValue):
             password=web_system_info.get("stratumPassword", ""),
         )
 
+    @classmethod
+    def from_luxos(cls, rpc_pools: dict) -> "Pool":
+        return cls.from_api(rpc_pools)
+
+    @classmethod
+    def from_iceriver(cls, web_pool: dict) -> "Pool":
+        return cls(
+            url=web_pool["addr"],
+            user=web_pool["user"],
+            password=web_pool["pass"],
+        )
+
 
 @dataclass
 class PoolGroup(MinerConfigValue):
@@ -402,6 +414,15 @@ class PoolGroup(MinerConfigValue):
     def from_bitaxe(cls, web_system_info: dict) -> "PoolGroup":
         return cls(pools=[Pool.from_bitaxe(web_system_info)])
 
+    @classmethod
+    def from_iceriver(cls, web_userpanel: dict) -> "PoolGroup":
+        return cls(
+            pools=[
+                Pool.from_iceriver(web_pool)
+                for web_pool in web_userpanel["data"]["pools"]
+            ]
+        )
+
 
 @dataclass
 class PoolConfig(MinerConfigValue):
@@ -467,7 +488,7 @@ class PoolConfig(MinerConfigValue):
     def as_boser(self, user_suffix: str = None) -> dict:
         return {
             "set_pool_groups": SetPoolGroupsRequest(
-                save_action=SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+                save_action=SaveAction.SAVE_AND_APPLY,
                 pool_groups=[g.as_boser(user_suffix=user_suffix) for g in self.groups],
             )
         }
@@ -506,6 +527,9 @@ class PoolConfig(MinerConfigValue):
     def as_bitaxe(self, user_suffix: str = None) -> dict:
         return self.groups[0].as_bitaxe(user_suffix=user_suffix)
 
+    def as_luxos(self, user_suffix: str = None) -> dict:
+        return {}
+
     @classmethod
     def from_api(cls, api_pools: dict) -> "PoolConfig":
         try:
@@ -568,3 +592,24 @@ class PoolConfig(MinerConfigValue):
     @classmethod
     def from_bitaxe(cls, web_system_info: dict) -> "PoolConfig":
         return cls(groups=[PoolGroup.from_bitaxe(web_system_info)])
+
+    @classmethod
+    def from_iceriver(cls, web_userpanel: dict) -> "PoolConfig":
+        return cls(groups=[PoolGroup.from_iceriver(web_userpanel)])
+
+    @classmethod
+    def from_luxos(cls, rpc_groups: dict, rpc_pools: dict) -> "PoolConfig":
+        return cls(
+            groups=[
+                PoolGroup(
+                    pools=[
+                        Pool.from_luxos(pool)
+                        for pool in rpc_pools["POOLS"]
+                        if pool["GROUP"] == group["GROUP"]
+                    ],
+                    name=group["Name"],
+                    quota=group["Quota"],
+                )
+                for group in rpc_groups["GROUPS"]
+            ]
+        )

pyasic/config/temperature.py

@@ -54,6 +54,9 @@ class TemperatureConfig(MinerConfigValue):
             temps_config["temps"]["shutdown"] = self.hot
         return temps_config
 
+    def as_luxos(self) -> dict:
+        return {"tempctrlset": [self.target or "", self.hot or "", self.danger or ""]}
+
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "TemperatureConfig":
         return cls(
@@ -130,3 +133,16 @@ class TemperatureConfig(MinerConfigValue):
 
             return cls(**conf)
         return cls.default()
+
+    @classmethod
+    def from_luxos(cls, rpc_tempctrl: dict) -> "TemperatureConfig":
+        try:
+            tempctrl_config = rpc_tempctrl["TEMPCTRL"][0]
+            return cls(
+                target=tempctrl_config.get("Target"),
+                hot=tempctrl_config.get("Hot"),
+                danger=tempctrl_config.get("Dangerous"),
+            )
+        except LookupError:
+            pass
+        return cls.default()

pyasic/data/__init__.py

@@ -23,13 +23,13 @@ from typing import Any, List, Union
 
 from pyasic.config import MinerConfig
 from pyasic.config.mining import MiningModePowerTune
+from pyasic.data.pools import PoolMetrics, Scheme
 
 from .boards import HashBoard
 from .device import DeviceInfo
 from .error_codes import BraiinsOSError, InnosiliconError, WhatsminerError, X19Error
 from .fans import Fan
 from .hashrate import AlgoHashRate, HashUnit
-from pyasic.data.pools import PoolMetrics
 
 
 @dataclass
@@ -154,7 +154,11 @@ class MinerData:
 
     @staticmethod
     def dict_factory(x):
-        return {k: v for (k, v) in x if not k.startswith("_")}
+        return {
+            k: v.value if isinstance(v, Scheme) else v
+            for (k, v) in x
+            if not k.startswith("_")
+        }
 
     def __post_init__(self):
         self._datetime = datetime.now(timezone.utc).astimezone()

pyasic/data/pools.py

@@ -7,6 +7,7 @@ from urllib.parse import urlparse
 class Scheme(Enum):
     STRATUM_V1 = "stratum+tcp"
     STRATUM_V2 = "stratum2+tcp"
+    STRATUM_V1_SSL = "stratum+ssl"
 
 
 @dataclass
@@ -25,7 +26,10 @@ class PoolUrl:
     @classmethod
     def from_str(cls, url: str) -> "PoolUrl":
         parsed_url = urlparse(url)
-        scheme = Scheme(parsed_url.scheme)
+        if not parsed_url.scheme.strip() == "":
+            scheme = Scheme(parsed_url.scheme)
+        else:
+            scheme = Scheme.STRATUM_V1
         host = parsed_url.hostname
         port = parsed_url.port
         pubkey = parsed_url.path.lstrip("/") if scheme == Scheme.STRATUM_V2 else None
@@ -85,6 +89,8 @@ class PoolMetrics:
     @staticmethod
     def _calculate_percentage(value: int, total: int) -> float:
         """Calculate the percentage."""
+        if value is None or total is None:
+            return 0
         if total == 0:
             return 0
         return (value / total) * 100

pyasic/device/makes.py

@@ -26,6 +26,7 @@ class MinerMake(str, Enum):
     AURADINE = "Auradine"
     EPIC = "ePIC"
     BITAXE = "BitAxe"
+    ICERIVER = "IceRiver"
 
     def __str__(self):
         return self.value

pyasic/device/models.py

@@ -5,14 +5,20 @@ class AntminerModels(str, Enum):
     D3 = "D3"
     HS3 = "HS3"
     L3Plus = "L3+"
+    KA3 = "KA3"
+    KS3 = "KS3"
     DR5 = "DR5"
+    KS5 = "KS5"
     L7 = "L7"
+    K7 = "K7"
     E9Pro = "E9Pro"
     S9 = "S9"
     S9i = "S9i"
     S9j = "S9j"
     T9 = "T9"
+    D9 = "D9"
     Z15 = "Z15"
+    Z15Pro = "Z15 Pro"
     S17 = "S17"
     S17Plus = "S17+"
     S17Pro = "S17 Pro"
@@ -220,6 +226,7 @@ class WhatsminerModels(str, Enum):
     M50VH60 = "M50 VH60"
     M50VH70 = "M50 VH70"
     M50VH80 = "M50 VH80"
+    M50VH90 = "M50 VH90"
     M50VJ10 = "M50 VJ10"
     M50VJ20 = "M50 VJ20"
     M50VJ30 = "M50 VJ30"
@@ -284,6 +291,7 @@ class AvalonminerModels(str, Enum):
     Avalon1066 = "Avalon 1066"
     Avalon1166Pro = "Avalon 1166 Pro"
     Avalon1246 = "Avalon 1246"
+    AvalonNano3 = "Avalon Nano 3"
 
     def __str__(self):
         return self.value
@@ -292,6 +300,8 @@ class AvalonminerModels(str, Enum):
 class InnosiliconModels(str, Enum):
     T3HPlus = "T3H+"
     A10X = "A10X"
+    A11 = "A11"
+    A11MX = "A11MX"
 
     def __str__(self):
         return self.value
@@ -340,7 +350,15 @@ class BitAxeModels(str, Enum):
 
 
 class IceRiverModels(str, Enum):
+    KS0 = "KS0"
+    KS1 = "KS1"
     KS2 = "KS2"
+    KS3 = "KS3"
+    KS3L = "KS3L"
+    KS3M = "KS3M"
+    KS5 = "KS5"
+    KS5L = "KS5L"
+    KS5M = "KS5M"
 
     def __str__(self):
         return self.value

pyasic/miners/antminer/bmminer/X15/Z15.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from pyasic.miners.backends import AntminerModern
+from pyasic.miners.device.models import Z15Pro
+
+
+class BMMinerZ15Pro(AntminerModern, Z15Pro):
+    pass

pyasic/miners/antminer/bmminer/X15/__init__.py

@@ -0,0 +1,16 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from .Z15 import BMMinerZ15Pro

pyasic/miners/antminer/bmminer/X19/__init__.py

@@ -23,6 +23,7 @@ from .S19 import (
     BMMinerS19j,
     BMMinerS19jNoPIC,
     BMMinerS19jPro,
+    BMMinerS19KPro,
     BMMinerS19L,
     BMMinerS19Plus,
     BMMinerS19Pro,
@@ -30,6 +31,5 @@ from .S19 import (
     BMMinerS19ProPlus,
     BMMinerS19ProPlusHydro,
     BMMinerS19XP,
-    BMMinerS19KPro,
 )
 from .T19 import BMMinerT19

pyasic/miners/antminer/bmminer/X3/KA3.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from pyasic.miners.backends import AntminerModern
+from pyasic.miners.device.models import KA3
+
+
+class BMMinerKA3(AntminerModern, KA3):
+    pass

pyasic/miners/antminer/bmminer/X3/KS3.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from pyasic.miners.backends import AntminerModern
+from pyasic.miners.device.models.antminer import KS3
+
+
+class BMMinerKS3(AntminerModern, KS3):
+    pass

pyasic/miners/antminer/bmminer/X3/__init__.py

@@ -14,4 +14,6 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 from .HS3 import BMMinerHS3
+from .KA3 import BMMinerKA3
+from .KS3 import BMMinerKS3
 from .L3 import BMMinerL3Plus

pyasic/miners/antminer/bmminer/X5/KS5.py

@@ -0,0 +1,21 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.miners.backends import AntminerModern
+from pyasic.miners.device.models import KS5
+
+
+class BMMinerKS5(AntminerModern, KS5):
+    supports_shutdown = False

pyasic/miners/antminer/bmminer/X5/__init__.py

@@ -0,0 +1,16 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from .KS5 import BMMinerKS5

pyasic/miners/antminer/bmminer/X7/K7.py

@@ -0,0 +1,21 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.miners.backends import AntminerModern
+from pyasic.miners.device.models import K7
+
+
+class BMMinerK7(AntminerModern, K7):
+    pass

pyasic/miners/antminer/bmminer/X7/__init__.py

@@ -13,4 +13,5 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
+from .K7 import BMMinerK7
 from .L7 import BMMinerL7

pyasic/miners/antminer/bmminer/X9/D9.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from pyasic.miners.backends import AntminerModern
+from pyasic.miners.device.models import D9
+
+
+class BMMinerD9(AntminerModern, D9):
+    pass

pyasic/miners/antminer/bmminer/X9/__init__.py

@@ -14,6 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
+from .D9 import BMMinerD9
 from .E9 import BMMinerE9Pro
 from .S9 import BMMinerS9, BMMinerS9i, BMMinerS9j
 from .T9 import BMMinerT9

pyasic/miners/antminer/bmminer/__init__.py

@@ -14,8 +14,10 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 from .X3 import *
+from .X5 import *
 from .X7 import *
 from .X9 import *
+from .X15 import *
 from .X17 import *
 from .X19 import *
 from .X21 import *

pyasic/miners/antminer/bosminer/X21/T21.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from pyasic.miners.backends import BOSer
+from pyasic.miners.device.models import T21
+
+
+class BOSMinerT21(BOSer, T21):
+    pass

pyasic/miners/antminer/bosminer/X21/__init__.py

@@ -15,3 +15,4 @@
 # ------------------------------------------------------------------------------
 
 from .S21 import BOSMinerS21
+from .T21 import BOSMinerT21

pyasic/miners/antminer/epic/X21/__init__.py

@@ -15,7 +15,4 @@
 # ------------------------------------------------------------------------------
 
 from .S21 import ePICS21, ePICS21Pro
-
+from .T21 import ePICT21
-from .T21 import (
-    ePICT21,
-)

pyasic/miners/avalonminer/cgminer/__init__.py

@@ -20,3 +20,4 @@ from .A9X import *
 from .A10X import *
 from .A11X import *
 from .A12X import *
+from .nano import *

pyasic/miners/avalonminer/cgminer/nano/__init__.py

@@ -0,0 +1,17 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from .nano3 import CGMinerAvalonNano3

pyasic/miners/avalonminer/cgminer/nano/nano3.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from pyasic.miners.backends import AvalonMiner
+from pyasic.miners.device.models import AvalonNano3
+
+
+class CGMinerAvalonNano3(AvalonMiner, AvalonNano3):
+    pass

pyasic/miners/backends/antminer.py

@@ -14,9 +14,9 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from typing import List, Optional, Union
-from pathlib import Path
 import logging
+from pathlib import Path
+from typing import List, Optional, Union
 
 from pyasic.config import MinerConfig, MiningModeConfig
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
@@ -141,17 +141,24 @@ class AntminerModern(BMMiner):
             raise ValueError("File location must be provided for firmware upgrade.")
 
         try:
-            result = await self.web.update_firmware(file=file, keep_settings=keep_settings)
+            result = await self.web.update_firmware(
+                file=file, keep_settings=keep_settings
+            )
 
             if result.get("success"):
-                logging.info("Firmware upgrade process completed successfully for AntMiner.")
+                logging.info(
+                    "Firmware upgrade process completed successfully for AntMiner."
+                )
                 return "Firmware upgrade completed successfully."
             else:
                 error_message = result.get("message", "Unknown error")
                 logging.error(f"Firmware upgrade failed. Response: {error_message}")
                 return f"Firmware upgrade failed. Response: {error_message}"
         except Exception as e:
-            logging.error(f"An error occurred during the firmware upgrade process: {e}", exc_info=True)
+            logging.error(
+                f"An error occurred during the firmware upgrade process: {e}",
+                exc_info=True,
+            )
             raise
 
     async def fault_light_on(self) -> bool:
@@ -367,7 +374,7 @@ class AntminerModern(BMMiner):
 
         if web_get_conf is not None:
             try:
-                if web_get_conf["bitmain-work-mode"].isdigit():
+                if str(web_get_conf["bitmain-work-mode"]).isdigit():
                     return (
                         False if int(web_get_conf["bitmain-work-mode"]) == 1 else True
                     )
@@ -590,49 +597,44 @@ class AntminerOld(CGMiner):
                 pass
 
         if rpc_stats is not None:
-            try:
+            board_offset = -1
-                board_offset = -1
+            boards = rpc_stats["STATS"]
-                boards = rpc_stats["STATS"]
+            if len(boards) > 1:
-                if len(boards) > 1:
+                for board_num in range(1, 16, 5):
-                    for board_num in range(1, 16, 5):
+                    for _b_num in range(5):
-                        for _b_num in range(5):
+                        b = boards[1].get(f"chain_acn{board_num + _b_num}")
-                            b = boards[1].get(f"chain_acn{board_num + _b_num}")
 
-                            if b and not b == 0 and board_offset == -1:
+                        if b and not b == 0 and board_offset == -1:
-                                board_offset = board_num
+                            board_offset = board_num
-                    if board_offset == -1:
+                if board_offset == -1:
-                        board_offset = 1
+                    board_offset = 1
 
-                    for i in range(
+                for i in range(board_offset, board_offset + self.expected_hashboards):
-                        board_offset, board_offset + self.expected_hashboards
+                    hashboard = HashBoard(
-                    ):
+                        slot=i - board_offset, expected_chips=self.expected_chips
-                        hashboard = HashBoard(
+                    )
-                            slot=i - board_offset, expected_chips=self.expected_chips
-                        )
 
-                        chip_temp = boards[1].get(f"temp{i}")
+                    chip_temp = boards[1].get(f"temp{i}")
-                        if chip_temp:
+                    if chip_temp:
-                            hashboard.chip_temp = round(chip_temp)
+                        hashboard.chip_temp = round(chip_temp)
 
-                        temp = boards[1].get(f"temp2_{i}")
+                    temp = boards[1].get(f"temp2_{i}")
-                        if temp:
+                    if temp:
-                            hashboard.temp = round(temp)
+                        hashboard.temp = round(temp)
 
-                        hashrate = boards[1].get(f"chain_rate{i}")
+                    hashrate = boards[1].get(f"chain_rate{i}")
-                        if hashrate:
+                    if hashrate:
-                            hashboard.hashrate = AlgoHashRate.SHA256(
+                        hashboard.hashrate = AlgoHashRate.SHA256(
-                                hashrate, HashUnit.SHA256.GH
+                            float(hashrate), HashUnit.SHA256.GH
-                            ).into(self.algo.unit.default)
+                        ).into(self.algo.unit.default)
 
-                        chips = boards[1].get(f"chain_acn{i}")
+                    chips = boards[1].get(f"chain_acn{i}")
-                        if chips:
+                    if chips:
-                            hashboard.chips = chips
+                        hashboard.chips = chips
-                            hashboard.missing = False
+                        hashboard.missing = False
-                        if (not chips) or (not chips > 0):
+                    if (not chips) or (not chips > 0):
-                            hashboard.missing = True
+                        hashboard.missing = True
-                        hashboards.append(hashboard)
+                    hashboards.append(hashboard)
-            except (LookupError, ValueError, TypeError):
-                pass
 
         return hashboards
 

pyasic/miners/backends/auradine.py

@@ -193,7 +193,14 @@ class Auradine(StockFirmware):
         for key in conf.keys():
             await self.web.send_command(command=key, **conf[key])
 
-    async def upgrade_firmware(self, *, url: str = None, version: str = "latest", keep_settings: bool = False, **kwargs) -> bool:
+    async def upgrade_firmware(
+        self,
+        *,
+        url: str = None,
+        version: str = "latest",
+        keep_settings: bool = False,
+        **kwargs,
+    ) -> bool:
         """
         Upgrade the firmware of the Auradine device.
 
@@ -209,7 +216,9 @@ class Auradine(StockFirmware):
             logging.info("Starting firmware upgrade process.")
 
             if not url and not version:
-                raise ValueError("Either URL or version must be provided for firmware upgrade.")
+                raise ValueError(
+                    "Either URL or version must be provided for firmware upgrade."
+                )
 
             if url:
                 result = await self.web.firmware_upgrade(url=url)
@@ -220,11 +229,15 @@ class Auradine(StockFirmware):
                 logging.info("Firmware upgrade process completed successfully.")
                 return True
             else:
-                logging.error(f"Firmware upgrade failed: {result.get('error', 'Unknown error')}")
+                logging.error(
+                    f"Firmware upgrade failed: {result.get('error', 'Unknown error')}"
+                )
                 return False
 
         except Exception as e:
-            logging.error(f"An error occurred during the firmware upgrade process: {str(e)}")
+            logging.error(
+                f"An error occurred during the firmware upgrade process: {str(e)}"
+            )
             return False
 
     ##################################################

pyasic/miners/backends/avalonminer.py

@@ -118,7 +118,7 @@ class AvalonMiner(CGMiner):
         stats_items = []
         stats_dict = {}
         for item in _stats_items:
-            if ":" in item:
+            if ": " in item:
                 data = item.replace("]", "").split("[")
                 data_list = [i.split(": ") for i in data[1].strip().split(", ")]
                 data_dict = {}
@@ -147,10 +147,7 @@ class AvalonMiner(CGMiner):
             if raw_data[0] == "":
                 raw_data = raw_data[1:]
 
-            if len(raw_data) == 2:
+            stats_dict[raw_data[0]] = raw_data[1:]
-                stats_dict[raw_data[0]] = raw_data[1]
-            else:
-                stats_dict[raw_data[0]] = raw_data[1:]
             stats_items.append(raw_data)
 
         return stats_dict
@@ -220,7 +217,7 @@ class AvalonMiner(CGMiner):
                 try:
                     board_hr = parsed_stats["MGHS"][board]
                     hashboards[board].hashrate = AlgoHashRate.SHA256(
-                        board_hr, HashUnit.SHA256.GH
+                        float(board_hr), HashUnit.SHA256.GH
                     ).into(self.algo.unit.default)
                 except LookupError:
                     pass
@@ -256,7 +253,7 @@ class AvalonMiner(CGMiner):
                 unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
                 return AlgoHashRate.SHA256(
-                    parsed_stats["GHSmm"], HashUnit.SHA256.GH
+                    float(parsed_stats["GHSmm"][0]), HashUnit.SHA256.GH
                 ).into(self.algo.unit.default)
             except (IndexError, KeyError, ValueError, TypeError):
                 pass
@@ -272,7 +269,7 @@ class AvalonMiner(CGMiner):
             try:
                 unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
-                return float(parsed_stats["Temp"])
+                return float(parsed_stats["Temp"][0])
             except (IndexError, KeyError, ValueError, TypeError):
                 pass
 
@@ -287,7 +284,7 @@ class AvalonMiner(CGMiner):
             try:
                 unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
-                return int(parsed_stats["MPO"])
+                return int(parsed_stats["MPO"][0])
             except (IndexError, KeyError, ValueError, TypeError):
                 pass
 
@@ -308,7 +305,7 @@ class AvalonMiner(CGMiner):
 
             for fan in range(self.expected_fans):
                 try:
-                    fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"])
+                    fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"][0])
                 except (IndexError, KeyError, ValueError, TypeError):
                     pass
         return fans_data
@@ -326,7 +323,7 @@ class AvalonMiner(CGMiner):
             try:
                 unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
                 parsed_stats = self.parse_stats(unparsed_stats)
-                led = int(parsed_stats["Led"])
+                led = int(parsed_stats["Led"][0])
                 return True if led == 1 else False
             except (IndexError, KeyError, ValueError, TypeError):
                 pass

pyasic/miners/backends/bfgminer.py

@@ -18,6 +18,7 @@ from typing import List, Optional
 
 from pyasic.config import MinerConfig
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
 from pyasic.miners.device.firmware import StockFirmware
@@ -49,6 +50,10 @@ BFGMINER_DATA_LOC = DataLocations(
             "_get_fans",
             [RPCAPICommand("rpc_stats", "stats")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
     }
 )
 
@@ -207,6 +212,36 @@ class BFGMiner(StockFirmware):
 
         return fans
 
+    async def _get_pools(self, rpc_pools: dict = None) -> List[PoolMetrics]:
+        if rpc_pools is None:
+            try:
+                rpc_pools = await self.rpc.pools()
+            except APIError:
+                pass
+
+        pools_data = []
+        if rpc_pools is not None:
+            try:
+                pools = rpc_pools.get("POOLS", [])
+                for pool_info in pools:
+                    url = pool_info.get("URL")
+                    pool_url = PoolUrl.from_str(url) if url else None
+                    pool_data = PoolMetrics(
+                        accepted=pool_info.get("Accepted"),
+                        rejected=pool_info.get("Rejected"),
+                        get_failures=pool_info.get("Get Failures"),
+                        remote_failures=pool_info.get("Remote Failures"),
+                        active=pool_info.get("Stratum Active"),
+                        alive=pool_info.get("Status") == "Alive",
+                        url=pool_url,
+                        user=pool_info.get("User"),
+                        index=pool_info.get("POOL"),
+                    )
+                    pools_data.append(pool_data)
+            except LookupError:
+                pass
+        return pools_data
+
     async def _get_expected_hashrate(
         self, rpc_stats: dict = None
     ) -> Optional[AlgoHashRate]:
@@ -228,4 +263,4 @@ class BFGMiner(StockFirmware):
                     expected_rate, HashUnit.SHA256.from_str(rate_unit)
                 ).into(self.algo.unit.default)
             except LookupError:
-                pass
+                pass

pyasic/miners/backends/bitaxe.py

@@ -41,6 +41,10 @@ BITAXE_DATA_LOC = DataLocations(
             "_get_api_ver",
             [WebAPICommand("web_system_info", "system/info")],
         ),
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [WebAPICommand("web_system_info", "system/info")],
+        ),
     }
 )
 
@@ -187,3 +191,16 @@ class BitAxe(BaseMiner):
                 return web_system_info["version"]
             except KeyError:
                 pass
+
+    async def _get_mac(self, web_system_info: dict = None) -> Optional[str]:
+        if web_system_info is None:
+            try:
+                web_system_info = await self.web.system_info()
+            except APIError:
+                pass
+
+        if web_system_info is not None:
+            try:
+                return web_system_info["macAddr"].upper()
+            except KeyError:
+                pass

pyasic/miners/backends/braiins_os.py

@@ -21,6 +21,7 @@ from typing import List, Optional, Union
 
 import aiofiles
 import tomli_w
+
 try:
     import tomllib
 except ImportError:
@@ -726,9 +727,8 @@ BOSER_DATA_LOC = DataLocations(
             [RPCAPICommand("rpc_summary", "summary")],
         ),
         str(DataOptions.POOLS): DataFunction(
-            "_get_pools",
+            "_get_pools", [WebAPICommand("grpc_pool_groups", "get_pool_groups")]
-            [WebAPICommand("grpc_pool_groups", "get_pool_groups")]
+        ),
-        )
     }
 )
 
@@ -798,7 +798,7 @@ class BOSer(BraiinsOSFirmware):
     async def set_power_limit(self, wattage: int) -> bool:
         try:
             result = await self.web.set_power_target(
-                wattage, save_action=SaveAction.SAVE_ACTION_SAVE_AND_FORCE_APPLY
+                wattage, save_action=SaveAction.SAVE_AND_FORCE_APPLY
             )
         except APIError:
             return False
@@ -926,8 +926,10 @@ class BOSer(BraiinsOSFirmware):
                 pass
 
         if grpc_hashboards is not None:
-            for board in grpc_hashboards["hashboards"]:
+            grpc_boards = sorted(
-                idx = int(board["id"]) - 1
+                grpc_hashboards["hashboards"], key=lambda x: int(x["id"])
+            )
+            for idx, board in enumerate(grpc_boards):
                 if board.get("chipsCount") is not None:
                     hashboards[idx].chips = board["chipsCount"]
                 if board.get("boardTemp") is not None:
@@ -951,7 +953,7 @@ class BOSer(BraiinsOSFirmware):
     async def _get_wattage(self, grpc_miner_stats: dict = None) -> Optional[int]:
         if grpc_miner_stats is None:
             try:
-                grpc_miner_stats = self.web.get_miner_stats()
+                grpc_miner_stats = await self.web.get_miner_stats()
             except APIError:
                 pass
 
@@ -983,7 +985,7 @@ class BOSer(BraiinsOSFirmware):
     async def _get_fans(self, grpc_cooling_state: dict = None) -> List[Fan]:
         if grpc_cooling_state is None:
             try:
-                grpc_cooling_state = self.web.get_cooling_state()
+                grpc_cooling_state = await self.web.get_cooling_state()
             except APIError:
                 pass
 
@@ -1086,12 +1088,12 @@ class BOSer(BraiinsOSFirmware):
                     url=pool_info["url"],
                     user=pool_info["user"],
                     index=idx,
-                    accepted=pool_info["stats"]["acceptedShares"],
+                    accepted=pool_info["stats"].get("acceptedShares", 0),
-                    rejected=pool_info["stats"]["rejectedShares"],
+                    rejected=pool_info["stats"].get("rejectedShares", 0),
-                    get_failures=pool_info["stats"]["stale_shares"],
+                    get_failures=0,
                     remote_failures=0,
-                    active=pool_info["active"],
+                    active=pool_info.get("active", False),
-                    alive=pool_info["alive"]
+                    alive=pool_info.get("alive"),
                 )
                 pools_data.append(pool_data)
 

pyasic/miners/backends/btminer.py

@@ -23,6 +23,7 @@ import aiofiles
 from pyasic.config import MinerConfig, MiningModeConfig
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
 from pyasic.data.error_codes import MinerErrorData, WhatsminerError
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
 from pyasic.miners.device.firmware import StockFirmware
@@ -109,6 +110,10 @@ BTMINER_DATA_LOC = DataLocations(
             "_get_uptime",
             [RPCAPICommand("rpc_summary", "summary")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
     }
 )
 
@@ -655,6 +660,36 @@ class BTMiner(StockFirmware):
             except LookupError:
                 pass
 
+    async def _get_pools(self, rpc_pools: dict = None) -> List[PoolMetrics]:
+        if rpc_pools is None:
+            try:
+                rpc_pools = await self.rpc.pools()
+            except APIError:
+                pass
+
+        pools_data = []
+        if rpc_pools is not None:
+            try:
+                pools = rpc_pools.get("POOLS", [])
+                for pool_info in pools:
+                    url = pool_info.get("URL")
+                    pool_url = PoolUrl.from_str(url) if url else None
+                    pool_data = PoolMetrics(
+                        accepted=pool_info.get("Accepted"),
+                        rejected=pool_info.get("Rejected"),
+                        get_failures=pool_info.get("Get Failures"),
+                        remote_failures=pool_info.get("Remote Failures"),
+                        active=pool_info.get("Stratum Active"),
+                        alive=pool_info.get("Status") == "Alive",
+                        url=pool_url,
+                        user=pool_info.get("User"),
+                        index=pool_info.get("POOL"),
+                    )
+                    pools_data.append(pool_data)
+            except LookupError:
+                pass
+        return pools_data
+
     async def upgrade_firmware(self, file: Path):
         """
         Upgrade the firmware of the Whatsminer device.

pyasic/miners/backends/cgminer.py

@@ -14,15 +14,15 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from typing import Optional, List
+from typing import List, Optional
 
 from pyasic.config import MinerConfig
 from pyasic.data import AlgoHashRate, HashUnit
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, RPCAPICommand
 from pyasic.miners.device.firmware import StockFirmware
 from pyasic.rpc.cgminer import CGMinerRPCAPI
-from pyasic.data.pools import PoolMetrics, PoolUrl
 
 CGMINER_DATA_LOC = DataLocations(
     **{

pyasic/miners/backends/epic.py

@@ -454,8 +454,9 @@ class ePIC(ePICFirmware):
         except LookupError:
             pass
 
-    async def upgrade_firmware(self, file: Path | str, keep_settings: bool = True) -> bool:
+    async def upgrade_firmware(
-
+        self, file: Path | str, keep_settings: bool = True
+    ) -> bool:
         """
         Upgrade the firmware of the ePIC miner device.
 
@@ -466,4 +467,4 @@ class ePIC(ePICFirmware):
         Returns:
             bool: Whether the firmware update succeeded.
         """
-        return await self.web.system_update(file=file, keep_settings=keep_settings)
+        return await self.web.system_update(file=file, keep_settings=keep_settings)

pyasic/miners/backends/goldshell.py

@@ -62,6 +62,10 @@ GOLDSHELL_DATA_LOC = DataLocations(
             "_get_fans",
             [RPCAPICommand("rpc_stats", "stats")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
     }
 )
 

pyasic/miners/backends/iceriver.py

@@ -1,6 +1,8 @@
 from typing import List, Optional
 
+from pyasic import MinerConfig
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.device import MinerAlgo
 from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, WebAPICommand
@@ -41,6 +43,10 @@ ICERIVER_DATA_LOC = DataLocations(
             "_get_uptime",
             [WebAPICommand("web_userpanel", "userpanel")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [WebAPICommand("web_userpanel", "userpanel")],
+        ),
     }
 )
 
@@ -67,6 +73,11 @@ class IceRiver(StockFirmware):
             return False
         return True
 
+    async def get_config(self) -> MinerConfig:
+        web_userpanel = await self.web.userpanel()
+
+        return MinerConfig.from_iceriver(web_userpanel)
+
     async def _get_fans(self, web_userpanel: dict = None) -> List[Fan]:
         if web_userpanel is None:
             try:
@@ -76,7 +87,7 @@ class IceRiver(StockFirmware):
 
         if web_userpanel is not None:
             try:
-                return [Fan(spd) for spd in web_userpanel["fans"]]
+                return [Fan(spd) for spd in web_userpanel["userpanel"]["data"]["fans"]]
             except (LookupError, ValueError, TypeError):
                 pass
 
@@ -89,7 +100,9 @@ class IceRiver(StockFirmware):
 
         if web_userpanel is not None:
             try:
-                return web_userpanel["mac"].upper().replace("-", ":")
+                return (
+                    web_userpanel["userpanel"]["data"]["mac"].upper().replace("-", ":")
+                )
             except (LookupError, ValueError, TypeError):
                 pass
 
@@ -102,7 +115,7 @@ class IceRiver(StockFirmware):
 
         if web_userpanel is not None:
             try:
-                return web_userpanel["host"]
+                return web_userpanel["userpanel"]["data"]["host"]
             except (LookupError, ValueError, TypeError):
                 pass
 
@@ -115,9 +128,13 @@ class IceRiver(StockFirmware):
 
         if web_userpanel is not None:
             try:
-                base_unit = web_userpanel["unit"]
+                base_unit = web_userpanel["userpanel"]["data"]["unit"]
                 return AlgoHashRate.SHA256(
-                    float(web_userpanel["rtpow"].replace(base_unit, "")),
+                    float(
+                        web_userpanel["userpanel"]["data"]["rtpow"].replace(
+                            base_unit, ""
+                        )
+                    ),
                     unit=MinerAlgo.SHA256.unit.from_str(base_unit + "H"),
                 ).into(MinerAlgo.SHA256.unit.default)
             except (LookupError, ValueError, TypeError):
@@ -132,7 +149,7 @@ class IceRiver(StockFirmware):
 
         if web_userpanel is not None:
             try:
-                return web_userpanel["locate"]
+                return web_userpanel["userpanel"]["data"]["locate"]
             except (LookupError, ValueError, TypeError):
                 pass
         return False
@@ -146,7 +163,7 @@ class IceRiver(StockFirmware):
 
         if web_userpanel is not None:
             try:
-                return web_userpanel["powstate"]
+                return web_userpanel["userpanel"]["data"]["powstate"]
             except (LookupError, ValueError, TypeError):
                 pass
 
@@ -164,14 +181,14 @@ class IceRiver(StockFirmware):
 
         if web_userpanel is not None:
             try:
-                for board in web_userpanel["boards"]:
+                for board in web_userpanel["userpanel"]["data"]["boards"]:
-                    idx = board["no"] - 1
+                    idx = int(board["no"] - 1)
                     hb_list[idx].chip_temp = round(board["outtmp"])
                     hb_list[idx].temp = round(board["intmp"])
                     hb_list[idx].hashrate = AlgoHashRate.SHA256(
                         float(board["rtpow"].replace("G", "")), HashUnit.SHA256.GH
                     ).into(self.algo.unit.default)
-                    hb_list[idx].chips = board["chipnum"]
+                    hb_list[idx].chips = int(board["chipnum"])
                     hb_list[idx].missing = False
             except LookupError:
                 pass
@@ -186,7 +203,7 @@ class IceRiver(StockFirmware):
 
         if web_userpanel is not None:
             try:
-                runtime = web_userpanel["runtime"]
+                runtime = web_userpanel["userpanel"]["data"]["runtime"]
                 days, hours, minutes, seconds = runtime.split(":")
                 return (
                     (int(days) * 24 * 60 * 60)
@@ -196,3 +213,36 @@ class IceRiver(StockFirmware):
                 )
             except (LookupError, ValueError, TypeError):
                 pass
+
+    async def _get_pools(self, web_userpanel: dict = None) -> List[PoolMetrics]:
+        if web_userpanel is None:
+            try:
+                web_userpanel = await self.web.userpanel()
+            except APIError:
+                pass
+
+        pools_data = []
+        if web_userpanel is not None:
+            try:
+                pools = web_userpanel["userpanel"]["data"]["pools"]
+                for pool_info in pools:
+                    pool_num = pool_info.get("no")
+                    if pool_num is not None:
+                        pool_num = int(pool_num)
+                    if pool_info["addr"] == "":
+                        continue
+                    url = pool_info.get("addr")
+                    pool_url = PoolUrl.from_str(url) if url else None
+                    pool_data = PoolMetrics(
+                        accepted=pool_info.get("accepted"),
+                        rejected=pool_info.get("rejected"),
+                        active=pool_info.get("connect"),
+                        alive=int(pool_info.get("state", 0)) == 1,
+                        url=pool_url,
+                        user=pool_info.get("user"),
+                        index=pool_num,
+                    )
+                    pools_data.append(pool_data)
+            except LookupError:
+                pass
+        return pools_data

pyasic/miners/backends/innosilicon.py

@@ -19,6 +19,7 @@ from pyasic.config import MinerConfig
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
 from pyasic.data.error_codes import MinerErrorData
 from pyasic.data.error_codes.innosilicon import InnosiliconError
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.errors import APIError
 from pyasic.miners.backends import CGMiner
 from pyasic.miners.data import (
@@ -29,7 +30,6 @@ from pyasic.miners.data import (
     WebAPICommand,
 )
 from pyasic.web.innosilicon import InnosiliconWebAPI
-from pyasic.data.pools import PoolMetrics, PoolUrl
 
 INNOSILICON_DATA_LOC = DataLocations(
     **{
@@ -92,9 +92,8 @@ INNOSILICON_DATA_LOC = DataLocations(
             [RPCAPICommand("rpc_stats", "stats")],
         ),
         str(DataOptions.POOLS): DataFunction(
-            "_get_pools",
+            "_get_pools", [RPCAPICommand("rpc_pools", "pools")]
-            [RPCAPICommand("rpc_pools", "pools")]
+        ),
-        )
     }
 )
 
@@ -116,7 +115,7 @@ class Innosilicon(CGMiner):
         except APIError:
             return self.config
 
-        self.config = MinerConfig.from_inno([pools])
+        self.config = MinerConfig.from_inno(pools["pools"])
         return self.config
 
     async def reboot(self) -> bool:

pyasic/miners/backends/luxminer.py

@@ -13,6 +13,7 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
+import logging
 from typing import List, Optional
 
 from pyasic.config import MinerConfig
@@ -55,6 +56,15 @@ LUXMINER_DATA_LOC = DataLocations(
         str(DataOptions.POOLS): DataFunction(
             "_get_pools", [RPCAPICommand("rpc_pools", "pools")]
         ),
+        str(DataOptions.FW_VERSION): DataFunction(
+            "_get_fw_ver", [RPCAPICommand("rpc_version", "version")]
+        ),
+        str(DataOptions.API_VERSION): DataFunction(
+            "_get_api_ver", [RPCAPICommand("rpc_version", "version")]
+        ),
+        str(DataOptions.FAULT_LIGHT): DataFunction(
+            "_get_fault_light", [RPCAPICommand("rpc_config", "config")]
+        ),
     }
 )
 
@@ -67,25 +77,9 @@ class LUXMiner(LuxOSFirmware):
 
     data_locations = LUXMINER_DATA_LOC
 
-    async def _get_session(self) -> Optional[str]:
-        try:
-            data = await self.rpc.session()
-            if not data["SESSION"][0]["SessionID"] == "":
-                return data["SESSION"][0]["SessionID"]
-        except APIError:
-            pass
-
-        try:
-            data = await self.rpc.logon()
-            return data["SESSION"][0]["SessionID"]
-        except (LookupError, APIError):
-            return
-
     async def fault_light_on(self) -> bool:
         try:
-            session_id = await self._get_session()
+            await self.rpc.ledset("red", "blink")
-            if session_id:
-                await self.rpc.ledset(session_id, "red", "blink")
             return True
         except (APIError, LookupError):
             pass
@@ -93,9 +87,7 @@ class LUXMiner(LuxOSFirmware):
 
     async def fault_light_off(self) -> bool:
         try:
-            session_id = await self._get_session()
+            await self.rpc.ledset("red", "off")
-            if session_id:
-                await self.rpc.ledset(session_id, "red", "off")
             return True
         except (APIError, LookupError):
             pass
@@ -106,9 +98,7 @@ class LUXMiner(LuxOSFirmware):
 
     async def restart_luxminer(self) -> bool:
         try:
-            session_id = await self._get_session()
+            await self.rpc.resetminer()
-            if session_id:
-                await self.rpc.resetminer(session_id)
             return True
         except (APIError, LookupError):
             pass
@@ -116,9 +106,7 @@ class LUXMiner(LuxOSFirmware):
 
     async def stop_mining(self) -> bool:
         try:
-            session_id = await self._get_session()
+            await self.rpc.sleep()
-            if session_id:
-                await self.rpc.curtail(session_id)
             return True
         except (APIError, LookupError):
             pass
@@ -126,45 +114,60 @@ class LUXMiner(LuxOSFirmware):
 
     async def resume_mining(self) -> bool:
         try:
-            session_id = await self._get_session()
+            await self.rpc.wakeup()
-            if session_id:
-                await self.rpc.wakeup(session_id)
             return True
         except (APIError, LookupError):
             pass
 
     async def reboot(self) -> bool:
         try:
-            session_id = await self._get_session()
+            await self.rpc.rebootdevice()
-            if session_id:
-                await self.rpc.rebootdevice(session_id)
             return True
         except (APIError, LookupError):
             pass
         return False
 
     async def get_config(self) -> MinerConfig:
-        return self.config
+        data = await self.rpc.multicommand("tempctrl", "fans", "pools", "groups")
+        return MinerConfig.from_luxos(
+            rpc_tempctrl=data.get("tempctrl", [{}])[0],
+            rpc_fans=data.get("fans", [{}])[0],
+            rpc_pools=data.get("pools", [{}])[0],
+            rpc_groups=data.get("groups", [{}])[0],
+        )
+
+    async def upgrade_firmware(self) -> bool:
+        """
+        Upgrade the firmware on a LuxOS miner by calling the 'updaterun' API command.
+        Returns:
+            bool: True if the firmware upgrade was successfully initiated, False otherwise.
+        """
+        try:
+            await self.rpc.upgraderun()
+            logging.info(f"{self.ip}: Firmware upgrade initiated successfully.")
+            return True
+
+        except APIError as e:
+            logging.error(f"{self.ip}: Firmware upgrade failed: {e}")
+
+        return False
 
     ##################################################
     ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
     ##################################################
 
     async def _get_mac(self, rpc_config: dict = None) -> Optional[str]:
-        mac = None
         if rpc_config is None:
             try:
                 rpc_config = await self.rpc.config()
             except APIError:
-                return None
+                pass
 
         if rpc_config is not None:
             try:
-                mac = rpc_config["CONFIG"][0]["MACAddr"]
+                return rpc_config["CONFIG"][0]["MACAddr"].upper()
             except KeyError:
-                return None
+                pass
-
-        return mac
 
     async def _get_hashrate(self, rpc_summary: dict = None) -> Optional[AlgoHashRate]:
         if rpc_summary is None:
@@ -182,59 +185,47 @@ class LUXMiner(LuxOSFirmware):
                 pass
 
     async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
-        hashboards = []
+        hashboards = [
+            HashBoard(idx, expected_chips=self.expected_chips)
+            for idx in range(self.expected_hashboards)
+        ]
 
         if rpc_stats is None:
             try:
                 rpc_stats = await self.rpc.stats()
             except APIError:
                 pass
-
         if rpc_stats is not None:
             try:
-                board_offset = -1
+                # TODO: bugged on S9 because of index issues, fix later.
-                boards = rpc_stats["STATS"]
+                board_stats = rpc_stats["STATS"][1]
-                if len(boards) > 1:
+                for idx in range(3):
-                    for board_num in range(1, 16, 5):
+                    board_n = idx + 1
-                        for _b_num in range(5):
+                    hashboards[idx].hashrate = AlgoHashRate.SHA256(
-                            b = boards[1].get(f"chain_acn{board_num + _b_num}")
+                        float(board_stats[f"chain_rate{board_n}"]), HashUnit.SHA256.GH
-
+                    ).into(self.algo.unit.default)
-                            if b and not b == 0 and board_offset == -1:
+                    hashboards[idx].chips = int(board_stats[f"chain_acn{board_n}"])
-                                board_offset = board_num
+                    chip_temp_data = list(
-                    if board_offset == -1:
+                        filter(
-                        board_offset = 1
+                            lambda x: not x == 0,
-
+                            map(int, board_stats[f"temp_chip{board_n}"].split("-")),
-                    for i in range(
-                        board_offset, board_offset + self.expected_hashboards
-                    ):
-                        hashboard = HashBoard(
-                            slot=i - board_offset, expected_chips=self.expected_chips
                         )
-
+                    )
-                        chip_temp = boards[1].get(f"temp{i}")
+                    hashboards[idx].chip_temp = (
-                        if chip_temp:
+                        sum([chip_temp_data[0], chip_temp_data[3]]) / 2
-                            hashboard.chip_temp = round(chip_temp)
+                    )
-
+                    board_temp_data = list(
-                        temp = boards[1].get(f"temp2_{i}")
+                        filter(
-                        if temp:
+                            lambda x: not x == 0,
-                            hashboard.temp = round(temp)
+                            map(int, board_stats[f"temp_pcb{board_n}"].split("-")),
-
+                        )
-                        hashrate = boards[1].get(f"chain_rate{i}")
+                    )
-                        if hashrate:
+                    hashboards[idx].temp = (
-                            hashboard.hashrate = AlgoHashRate.SHA256(
+                        sum([board_temp_data[1], board_temp_data[2]]) / 2
-                                hashrate, HashUnit.SHA256.GH
+                    )
-                            ).into(self.algo.unit.default)
+                    hashboards[idx].missing = False
-
+            except LookupError:
-                        chips = boards[1].get(f"chain_acn{i}")
-                        if chips:
-                            hashboard.chips = chips
-                            hashboard.missing = False
-                        if (not chips) or (not chips > 0):
-                            hashboard.missing = True
-                        hashboards.append(hashboard)
-            except (LookupError, ValueError, TypeError):
                 pass
-
         return hashboards
 
     async def _get_wattage(self, rpc_power: dict = None) -> Optional[int]:
@@ -302,6 +293,45 @@ class LUXMiner(LuxOSFirmware):
             except LookupError:
                 pass
 
+    async def _get_fw_ver(self, rpc_version: dict = None) -> Optional[str]:
+        if rpc_version is None:
+            try:
+                rpc_version = await self.rpc.version()
+            except APIError:
+                pass
+
+        if rpc_version is not None:
+            try:
+                return rpc_version["VERSION"][0]["Miner"]
+            except LookupError:
+                pass
+
+    async def _get_api_ver(self, rpc_version: dict = None) -> Optional[str]:
+        if rpc_version is None:
+            try:
+                rpc_version = await self.rpc.version()
+            except APIError:
+                pass
+
+        if rpc_version is not None:
+            try:
+                return rpc_version["VERSION"][0]["API"]
+            except LookupError:
+                pass
+
+    async def _get_fault_light(self, rpc_config: dict = None) -> Optional[bool]:
+        if rpc_config is None:
+            try:
+                rpc_config = await self.rpc.config()
+            except APIError:
+                pass
+
+        if rpc_config is not None:
+            try:
+                return not rpc_config["CONFIG"][0]["RedLed"] == "off"
+            except LookupError:
+                pass
+
     async def _get_pools(self, rpc_pools: dict = None) -> List[PoolMetrics]:
         if rpc_pools is None:
             try:

pyasic/miners/backends/marathon.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 from pyasic import MinerConfig
 from pyasic.config import MiningModeConfig
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.errors import APIError
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, WebAPICommand
 from pyasic.miners.device.firmware import MaraFirmware
@@ -60,6 +61,10 @@ MARA_DATA_LOC = DataLocations(
             "_get_uptime",
             [WebAPICommand("web_brief", "brief")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [WebAPICommand("web_pools", "pools")],
+        ),
     }
 )
 
@@ -305,3 +310,43 @@ class MaraMiner(MaraFirmware):
                 return web_miner_config["mode"]["concorde"]["power-target"]
             except LookupError:
                 pass
+
+    async def _get_pools(self, web_pools: list = None) -> List[PoolMetrics]:
+        if web_pools is None:
+            try:
+                web_pools = await self.web.pools()
+            except APIError:
+                return []
+
+        active_pool_index = None
+        highest_priority = float("inf")
+
+        for pool_info in web_pools:
+            if (
+                pool_info.get("status") == "Alive"
+                and pool_info.get("priority", float("inf")) < highest_priority
+            ):
+                highest_priority = pool_info["priority"]
+                active_pool_index = pool_info["index"]
+
+        pools_data = []
+        if web_pools is not None:
+            try:
+                for pool_info in web_pools:
+                    url = pool_info.get("url")
+                    pool_url = PoolUrl.from_str(url) if url else None
+                    pool_data = PoolMetrics(
+                        accepted=pool_info.get("accepted"),
+                        rejected=pool_info.get("rejected"),
+                        get_failures=pool_info.get("stale"),
+                        remote_failures=pool_info.get("discarded"),
+                        active=pool_info.get("index") == active_pool_index,
+                        alive=pool_info.get("status") == "Alive",
+                        url=pool_url,
+                        user=pool_info.get("user"),
+                        index=pool_info.get("index"),
+                    )
+                    pools_data.append(pool_data)
+            except LookupError:
+                pass
+        return pools_data

pyasic/miners/backends/vnish.py

@@ -237,13 +237,17 @@ class VNish(VNishFirmware, BMMiner):
 
     async def _is_mining(self, web_summary: dict = None) -> Optional[bool]:
         if web_summary is None:
-            web_summary = await self.web.summary()
+            try:
+                web_summary = await self.web.summary()
+            except APIError:
+                pass
 
         if web_summary is not None:
             try:
                 is_mining = not web_summary["miner"]["miner_status"]["miner_state"] in [
                     "stopped",
                     "shutting-down",
+                    "failure",
                 ]
                 return is_mining
             except LookupError:

pyasic/miners/base.py

@@ -560,7 +560,14 @@ class BaseMiner(MinerProtocol):
         if self._ssh_cls is not None:
             self.ssh = self._ssh_cls(ip)
 
-    async def upgrade_firmware(self, *, file: str = None, url: str = None, version: str = None, keep_settings: bool = True) -> bool:
+    async def upgrade_firmware(
+        self,
+        *,
+        file: str = None,
+        url: str = None,
+        version: str = None,
+        keep_settings: bool = True,
+    ) -> bool:
         """Upgrade the firmware of the miner.
 
         Parameters:
@@ -574,4 +581,5 @@ class BaseMiner(MinerProtocol):
         """
         return False
 
+
 AnyMiner = TypeVar("AnyMiner", bound=BaseMiner)

pyasic/miners/blockminer/epic/blockminer/__init__.py

@@ -14,7 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from .blockminer import (
+from .blockminer import ePICBlockMiner520i, ePICBlockMiner720i
-    ePICBlockMiner520i,
-    ePICBlockMiner720i,
-)

pyasic/miners/device/firmware.py

@@ -43,4 +43,4 @@ class LuxOSFirmware(BaseMiner):
 
 
 class MaraFirmware(BaseMiner):
-    firmware = MinerFirmware.MARATHON
+    firmware = MinerFirmware.MARATHON

pyasic/miners/device/makes.py

@@ -51,4 +51,4 @@ class BitAxeMake(BaseMiner):
 
 
 class IceRiverMake(BaseMiner):
-    make = MinerMake.BITAXE
+    make = MinerMake.ICERIVER

pyasic/miners/device/models/antminer/X15/Z15.py

@@ -21,3 +21,9 @@ class Z15(AntMinerMake):
     raw_model = MinerModel.ANTMINER.Z15
 
     expected_chips = 3
+
+
+class Z15Pro(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.Z15Pro
+
+    expected_chips = 6

pyasic/miners/device/models/antminer/X15/__init__.py

@@ -13,4 +13,4 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .Z15 import Z15
+from .Z15 import Z15, Z15Pro

pyasic/miners/device/models/antminer/X3/KA3.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class KA3(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.KA3
+
+    expected_chips = 92

pyasic/miners/device/models/antminer/X3/KS3.py

@@ -0,0 +1,24 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class KS3(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.KS3
+
+    expected_chips = 92
+    expected_fans = 2

pyasic/miners/device/models/antminer/X3/__init__.py

@@ -15,4 +15,6 @@
 # ------------------------------------------------------------------------------
 from .D3 import D3
 from .HS3 import HS3
+from .KA3 import KA3
+from .KS3 import KS3
 from .L3 import L3Plus

pyasic/miners/device/models/antminer/X5/KS5.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class KS5(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.KS5
+
+    expected_chips = 92

pyasic/miners/device/models/antminer/X5/__init__.py

@@ -14,3 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 from .DR5 import DR5
+from .KS5 import KS5

pyasic/miners/device/models/antminer/X7/K7.py

@@ -0,0 +1,24 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class K7(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.K7
+
+    expected_chips = 92
+    expected_fans = 4

pyasic/miners/device/models/antminer/X7/__init__.py

@@ -13,4 +13,5 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
+from .K7 import K7
 from .L7 import L7

pyasic/miners/device/models/antminer/X9/D9.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import AntMinerMake
+
+
+class D9(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.D9
+
+    expected_chips = 126

pyasic/miners/device/models/antminer/X9/__init__.py

@@ -14,6 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
+from .D9 import D9
 from .E9 import E9Pro
 from .S9 import S9, S9i, S9j
 from .T9 import T9

pyasic/miners/device/models/avalonminer/__init__.py

@@ -20,3 +20,4 @@ from .A9X import *
 from .A10X import *
 from .A11X import *
 from .A12X import *
+from .nano import *

pyasic/miners/device/models/avalonminer/nano/__init__.py

@@ -0,0 +1 @@
+from .nano3 import AvalonNano3

pyasic/miners/device/models/avalonminer/nano/nano3.py

@@ -0,0 +1,10 @@
+from pyasic.device import MinerModel
+from pyasic.miners.device.makes import AvalonMinerMake
+
+
+class AvalonNano3(AvalonMinerMake):
+    raw_model = MinerModel.AVALONMINER.AvalonNano3
+
+    expected_hashboards = 1
+    expected_chips = 10
+    expected_fans = 1

pyasic/miners/device/models/iceriver/KSX/KS0.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2024 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class KS0(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS0
+
+    expected_fans = 0

pyasic/miners/device/models/iceriver/KSX/KS1.py

@@ -0,0 +1,23 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2024 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class KS1(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS1
+
+    expected_fans = 4

pyasic/miners/device/models/iceriver/KSX/KS2.py

@@ -21,3 +21,4 @@ class KS2(IceRiverMake):
     raw_model = MinerModel.ICERIVER.KS2
 
     expected_fans = 4
+    expected_chips = 18

pyasic/miners/device/models/iceriver/KSX/KS3.py

@@ -0,0 +1,36 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2024 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class KS3(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS3
+
+    expected_fans = 4
+
+
+class KS3L(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS3L
+
+    expected_fans = 4
+
+
+class KS3M(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS3M
+
+    expected_fans = 4
+    expected_chips = 18

pyasic/miners/device/models/iceriver/KSX/KS5.py

@@ -0,0 +1,37 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2024 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class KS5(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS5
+
+    expected_fans = 4
+    expected_chips = 92
+
+
+class KS5L(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS5L
+
+    expected_fans = 4
+    expected_chips = 18
+
+
+class KS5M(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.KS5M
+
+    expected_fans = 4

pyasic/miners/device/models/iceriver/KSX/__init__.py

@@ -1 +1,5 @@
+from .KS0 import KS0
+from .KS1 import KS1
 from .KS2 import KS2
+from .KS3 import KS3, KS3L, KS3M
+from .KS5 import KS5, KS5L, KS5M

pyasic/miners/device/models/innosilicon/A11X/A11.py

@@ -0,0 +1,24 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import InnosiliconMake
+
+
+class A11(InnosiliconMake):
+    raw_model = MinerModel.INNOSILICON.A11
+
+    expected_hashboards = 4
+    expected_chips = 8

pyasic/miners/device/models/innosilicon/A11X/A11M.py

@@ -0,0 +1,24 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import InnosiliconMake
+
+
+class A11MX(InnosiliconMake):
+    raw_model = MinerModel.INNOSILICON.A11MX
+
+    expected_hashboards = 4
+    expected_chips = 8

pyasic/miners/device/models/innosilicon/A11X/__init__.py

@@ -0,0 +1,17 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from .A11 import *
+from .A11M import *

pyasic/miners/device/models/innosilicon/__init__.py

@@ -15,4 +15,5 @@
 # ------------------------------------------------------------------------------
 
 from .A10X import *
+from .A11X import *
 from .T3X import *

pyasic/miners/device/models/whatsminer/M5X/M50.py

@@ -69,6 +69,8 @@ class M50VH60(WhatsMinerMake):
 class M50VH70(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VH70
 
+    expected_chips = 105
+
 
 class M50VH80(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VH80
@@ -76,6 +78,12 @@ class M50VH80(WhatsMinerMake):
     expected_chips = 111
 
 
+class M50VH90(WhatsMinerMake):
+    raw_model = MinerModel.WHATSMINER.M50VH90
+
+    expected_chips = 117
+
+
 class M50VJ10(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VJ10
 
@@ -83,6 +91,10 @@ class M50VJ10(WhatsMinerMake):
 class M50VJ20(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VJ20
 
+    expected_chips = 111
+
 
 class M50VJ30(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50VJ30
+
+    expected_chips = 117

pyasic/miners/device/models/whatsminer/M5X/M50S.py

@@ -51,3 +51,5 @@ class M50SVH40(WhatsMinerMake):
 
 class M50SVH50(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M50SVH50
+
+    expected_chips = 135

pyasic/miners/device/models/whatsminer/M5X/__init__.py

@@ -25,6 +25,7 @@ from .M50 import (
     M50VH60,
     M50VH70,
     M50VH80,
+    M50VH90,
     M50VJ10,
     M50VJ20,
     M50VJ30,

pyasic/miners/device/models/whatsminer/M6X/M60.py

@@ -24,6 +24,8 @@ class M60VK10(WhatsMinerMake):
 class M60VK20(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M60VK20
 
+    expected_chips = 172
+
 
 class M60VK30(WhatsMinerMake):
     raw_model = MinerModel.WHATSMINER.M60VK30

pyasic/miners/factory.py

@@ -20,6 +20,7 @@ import enum
 import ipaddress
 import json
 import re
+import warnings
 from typing import Any, AsyncGenerator, Callable
 
 import anyio
@@ -66,14 +67,20 @@ MINER_CLASSES = {
         "ANTMINER D3": CGMinerD3,
         "ANTMINER HS3": BMMinerHS3,
         "ANTMINER L3+": BMMinerL3Plus,
+        "ANTMINER KA3": BMMinerKA3,
+        "ANTMINER KS3": BMMinerKS3,
         "ANTMINER DR5": CGMinerDR5,
+        "ANTMINER KS5": BMMinerKS5,
         "ANTMINER L7": BMMinerL7,
+        "ANTMINER K7": BMMinerK7,
         "ANTMINER E9 PRO": BMMinerE9Pro,
+        "ANTMINER D9": BMMinerD9,
         "ANTMINER S9": BMMinerS9,
         "ANTMINER S9I": BMMinerS9i,
         "ANTMINER S9J": BMMinerS9j,
         "ANTMINER T9": BMMinerT9,
         "ANTMINER Z15": CGMinerZ15,
+        "ANTMINER Z15 PRO": BMMinerZ15Pro,
         "ANTMINER S17": BMMinerS17,
         "ANTMINER S17+": BMMinerS17Plus,
         "ANTMINER S17 PRO": BMMinerS17Pro,
@@ -271,6 +278,7 @@ MINER_CLASSES = {
         "M50VH60": BTMinerM50VH60,
         "M50VH70": BTMinerM50VH70,
         "M50VH80": BTMinerM50VH80,
+        "M50VH90": BTMinerM50VH90,
         "M50VJ10": BTMinerM50VJ10,
         "M50VJ20": BTMinerM50VJ20,
         "M50VJ30": BTMinerM50VJ30,
@@ -332,11 +340,14 @@ MINER_CLASSES = {
         "AVALONMINER 1066": CGMinerAvalon1066,
         "AVALONMINER 1166PRO": CGMinerAvalon1166Pro,
         "AVALONMINER 1246": CGMinerAvalon1246,
+        "AVALONMINER NANO3": CGMinerAvalonNano3,
     },
     MinerTypes.INNOSILICON: {
         None: type("InnosiliconUnknown", (Innosilicon, InnosiliconMake), {}),
         "T3H+": InnosiliconT3HPlus,
         "A10X": InnosiliconA10X,
+        "A11": InnosiliconA11,
+        "A11MX": InnosiliconA11MX,
     },
     MinerTypes.GOLDSHELL: {
         None: type("GoldshellUnknown", (GoldshellMiner, GoldshellMake), {}),
@@ -375,6 +386,7 @@ MINER_CLASSES = {
         "ANTMINER S19 PRO+ HYD.": BOSMinerS19ProPlusHydro,
         "ANTMINER T19": BOSMinerT19,
         "ANTMINER S21": BOSMinerS21,
+        "ANTMINER T21": BOSMinerT21,
     },
     MinerTypes.VNISH: {
         None: VNish,
@@ -388,6 +400,7 @@ MINER_CLASSES = {
         "ANTMINER S19 PRO": VNishS19Pro,
         "ANTMINER S19J": VNishS19j,
         "ANTMINER S19J PRO": VNishS19jPro,
+        "ANTMINER S19J PRO BB": VNishS19jPro,
         "ANTMINER S19A": VNishS19a,
         "ANTMINER S19A PRO": VNishS19aPro,
         "ANTMINER S19 PRO HYD.": VNishS19ProHydro,
@@ -455,7 +468,15 @@ MINER_CLASSES = {
     },
     MinerTypes.ICERIVER: {
         None: type("IceRiverUnknown", (IceRiver, IceRiverMake), {}),
+        "KS0": IceRiverKS0,
+        "KS1": IceRiverKS1,
         "KS2": IceRiverKS2,
+        "KS3": IceRiverKS3,
+        "KS3L": IceRiverKS3L,
+        "KS3M": IceRiverKS3M,
+        "KS5": IceRiverKS5,
+        "KS5L": IceRiverKS5L,
+        "KS5M": IceRiverKS5M,
     },
 }
 
@@ -534,6 +555,7 @@ class MinerFactory:
                 MinerTypes.AURADINE: self.get_miner_model_auradine,
                 MinerTypes.MARATHON: self.get_miner_model_marathon,
                 MinerTypes.BITAXE: self.get_miner_model_bitaxe,
+                MinerTypes.ICERIVER: self.get_miner_model_iceriver,
             }
             fn = miner_model_fns.get(miner_type)
 
@@ -615,6 +637,10 @@ class MinerFactory:
                 return MinerTypes.WHATSMINER
         if "Braiins OS" in web_text:
             return MinerTypes.BRAIINS_OS
+        if "Luxor Firmware" in web_text:
+            return MinerTypes.LUX_OS
+        if "<TITLE>用户界面</TITLE>" in web_text:
+            return MinerTypes.ICERIVER
         if "AxeOS" in web_text:
             return MinerTypes.BITAXE
         if "cloud-box" in web_text:
@@ -629,8 +655,6 @@ class MinerFactory:
             return MinerTypes.INNOSILICON
         if "Miner UI" in web_text:
             return MinerTypes.AURADINE
-        if "<TITLE>用户界面</TITLE>" in web_text:
-            return MinerTypes.ICERIVER
 
     async def _get_miner_socket(self, ip: str) -> MinerTypes | None:
         commands = ["version", "devdetails"]
@@ -697,10 +721,10 @@ class MinerFactory:
             return MinerTypes.BRAIINS_OS
         if "BTMINER" in upper_data or "BITMICRO" in upper_data:
             return MinerTypes.WHATSMINER
-        if "HIVEON" in upper_data:
-            return MinerTypes.HIVEON
         if "LUXMINER" in upper_data:
             return MinerTypes.LUX_OS
+        if "HIVEON" in upper_data:
+            return MinerTypes.HIVEON
         if "KAONSU" in upper_data:
             return MinerTypes.MARATHON
         if "ANTMINER" in upper_data and "DEVDETAILS" not in upper_data:
@@ -711,11 +735,13 @@ class MinerFactory:
             or "BFGMINER" in upper_data
         ):
             return MinerTypes.GOLDSHELL
+        if "INNOMINER" in upper_data:
+            return MinerTypes.INNOSILICON
         if "AVALON" in upper_data:
             return MinerTypes.AVALONMINER
         if "GCMINER" in upper_data or "FLUXOS" in upper_data:
             return MinerTypes.AURADINE
-        if "VNISH" in upper_data or "DEVICE PATH" in upper_data:
+        if "VNISH" in upper_data:
             return MinerTypes.VNISH
 
     async def send_web_command(
@@ -803,10 +829,8 @@ class MinerFactory:
         # fix an error with a btminer return having a missing comma. (2023-01-06 version)
         str_data = str_data.replace('""temp0', '","temp0')
         # fix an error with Avalonminers returning inf and nan
-        str_data = str_data.replace("info", "1nfo")
+        str_data = str_data.replace('"inf"', "0")
-        str_data = str_data.replace("inf", "0")
+        str_data = str_data.replace('"nan"', "0")
-        str_data = str_data.replace("1nfo", "info")
-        str_data = str_data.replace("nan", "0")
         # fix whatever this garbage from avalonminers is `,"id":1}`
         if str_data.startswith(","):
             str_data = f"{{{str_data[1:]}"
@@ -831,6 +855,10 @@ class MinerFactory:
             return MINER_CLASSES[miner_type][str(miner_model).upper()](ip)
         except LookupError:
             if miner_type in MINER_CLASSES:
+                warnings.warn(
+                    f"Partially supported miner found: {miner_model}, please open an issue with miner data "
+                    f"and this model on GitHub (https://github.com/UpstreamData/pyasic/issues)."
+                )
                 return MINER_CLASSES[miner_type][None](ip)
             return UnknownMiner(str(ip))
 
@@ -906,10 +934,12 @@ class MinerFactory:
     async def get_miner_model_avalonminer(self, ip: str) -> str | None:
         sock_json_data = await self.send_api_command(ip, "version")
         try:
-            miner_model = sock_json_data["VERSION"][0]["PROD"]
+            miner_model = sock_json_data["VERSION"][0]["PROD"].upper()
             if "-" in miner_model:
                 miner_model = miner_model.split("-")[0]
-
+            if miner_model in ["AVALONNANO", "AVALON0O"]:
+                nano_subtype = sock_json_data["VERSION"][0]["MODEL"].upper()
+                miner_model = f"AVALONMINER {nano_subtype}"
             return miner_model
         except (TypeError, LookupError):
             pass
@@ -919,10 +949,19 @@ class MinerFactory:
             async with httpx.AsyncClient(transport=settings.transport()) as session:
                 auth_req = await session.post(
                     f"http://{ip}/api/auth",
-                    data={"username": "admin", "password": "admin"},
+                    data={
+                        "username": "admin",
+                        "password": settings.get(
+                            "default_innosilicon_web_password", "admin"
+                        ),
+                    },
                 )
                 auth = auth_req.json()["jwt"]
+        except (httpx.HTTPError, LookupError):
+            return
 
+        try:
+            async with httpx.AsyncClient(transport=settings.transport()) as session:
                 web_data = (
                     await session.post(
                         f"http://{ip}/api/type",
@@ -933,6 +972,18 @@ class MinerFactory:
                 return web_data["type"]
         except (httpx.HTTPError, LookupError):
             pass
+        try:
+            async with httpx.AsyncClient(transport=settings.transport()) as session:
+                web_data = (
+                    await session.post(
+                        f"http://{ip}/overview",
+                        headers={"Authorization": "Bearer " + auth},
+                        data={},
+                    )
+                ).json()
+                return web_data["type"]
+        except (httpx.HTTPError, LookupError):
+            pass
 
     async def get_miner_model_braiins_os(self, ip: str) -> str | None:
         sock_json_data = await self.send_api_command(ip, "devdetails")
@@ -1046,6 +1097,39 @@ class MinerFactory:
         except (TypeError, LookupError):
             pass
 
+    async def get_miner_model_iceriver(self, ip: str) -> str | None:
+        async with httpx.AsyncClient(transport=settings.transport()) as client:
+            try:
+                # auth
+                await client.post(
+                    f"http://{ip}/user/loginpost",
+                    params={
+                        "post": "6",
+                        "user": "admin",
+                        "pwd": settings.get(
+                            "default_iceriver_web_password", "12345678"
+                        ),
+                    },
+                )
+            except httpx.HTTPError:
+                return None
+            try:
+                resp = await client.post(
+                    f"http://{ip}:/user/userpanel", params={"post": "4"}
+                )
+                if not resp.status_code == 200:
+                    return
+                result = resp.json()
+                software_ver = result["data"]["softver1"]
+                split_ver = software_ver.split("_")
+                if split_ver[-1] == "miner":
+                    miner_ver = split_ver[-2]
+                else:
+                    miner_ver = split_ver[-1].replace("miner", "")
+                return miner_ver.upper()
+            except httpx.HTTPError:
+                pass
+
 
 miner_factory = MinerFactory()
 

pyasic/miners/iceriver/iceminer/KSX/KS0.py

@@ -0,0 +1,6 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models import KS0
+
+
+class IceRiverKS0(IceRiver, KS0):
+    pass

pyasic/miners/iceriver/iceminer/KSX/KS1.py

@@ -0,0 +1,6 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models import KS1
+
+
+class IceRiverKS1(IceRiver, KS1):
+    pass

pyasic/miners/iceriver/iceminer/KSX/KS3.py

@@ -0,0 +1,14 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models.iceriver import KS3, KS3L, KS3M
+
+
+class IceRiverKS3(IceRiver, KS3):
+    pass
+
+
+class IceRiverKS3L(IceRiver, KS3L):
+    pass
+
+
+class IceRiverKS3M(IceRiver, KS3M):
+    pass

pyasic/miners/iceriver/iceminer/KSX/KS5.py

@@ -0,0 +1,14 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models.iceriver import KS5, KS5L, KS5M
+
+
+class IceRiverKS5(IceRiver, KS5):
+    pass
+
+
+class IceRiverKS5L(IceRiver, KS5L):
+    pass
+
+
+class IceRiverKS5M(IceRiver, KS5M):
+    pass

pyasic/miners/iceriver/iceminer/KSX/__init__.py

@@ -1 +1,5 @@
+from .KS0 import IceRiverKS0
+from .KS1 import IceRiverKS1
 from .KS2 import IceRiverKS2
+from .KS3 import IceRiverKS3, IceRiverKS3L, IceRiverKS3M
+from .KS5 import IceRiverKS5, IceRiverKS5L, IceRiverKS5M

pyasic/miners/innosilicon/cgminer/A11X/A11.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from pyasic.miners.backends.innosilicon import Innosilicon
+from pyasic.miners.device.models import A11
+
+
+class InnosiliconA11(Innosilicon, A11):
+    pass

pyasic/miners/innosilicon/cgminer/A11X/A11M.py

@@ -0,0 +1,22 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from pyasic.miners.backends.innosilicon import Innosilicon
+from pyasic.miners.device.models import A11MX
+
+
+class InnosiliconA11MX(Innosilicon, A11MX):
+    pass

pyasic/miners/innosilicon/cgminer/A11X/__init__.py

@@ -0,0 +1,2 @@
+from .A11 import InnosiliconA11
+from .A11M import InnosiliconA11MX

pyasic/miners/innosilicon/cgminer/__init__.py

@@ -15,4 +15,5 @@
 # ------------------------------------------------------------------------------
 
 from .A10X import *
+from .A11X import *
 from .T3X import *

pyasic/miners/whatsminer/btminer/M5X/M50.py

@@ -26,6 +26,7 @@ from pyasic.miners.device.models import (
     M50VH60,
     M50VH70,
     M50VH80,
+    M50VH90,
     M50VJ10,
     M50VJ20,
     M50VJ30,
@@ -72,6 +73,10 @@ class BTMinerM50VH80(M5X, M50VH80):
     pass
 
 
+class BTMinerM50VH90(M5X, M50VH90):
+    pass
+
+
 class BTMinerM50VJ10(M5X, M50VJ10):
     pass