version: bump version number.

documentation: Changed settings key in readme to reflect default values

README.md

@@ -255,7 +255,7 @@ if __name__ == "__main__":
 ```python
 from pyasic import settings
 
-settings.update("default_antminer_password", "my_pwd")
+settings.update("default_antminer_web_password", "my_pwd")
 ```
 
 ##### Default values:

docs/index.md

@@ -249,7 +249,7 @@ if __name__ == "__main__":
 ```python
 from pyasic import settings
 
-settings.update("default_antminer_password", "my_pwd")
+settings.update("default_antminer_web_password", "my_pwd")
 ```
 
 ##### Default values:

docs/requirements.txt

@@ -1,3 +1,4 @@
 jinja2<3.1.4
 mkdocs
 mkdocstrings[python]
+zipp>=3.19.1 # not directly required, pinned by Snyk to avoid a vulnerability

docs/settings/settings.md

@@ -13,12 +13,17 @@ Settings options:
 - `get_data_retries`
 - `api_function_timeout`
 - `antminer_mining_mode_as_str`
-- `default_whatsminer_password`
-- `default_innosilicon_password`
-- `default_antminer_password`
-- `default_bosminer_password`
-- `default_vnish_password`
-- `default_goldshell_password`
+- `default_whatsminer_rpc_password`
+- `default_innosilicon_web_password`
+- `default_antminer_web_password`
+- `default_bosminer_web_password`
+- `default_vnish_web_password`
+- `default_goldshell_web_password`
+- `default_auradine_web_password`
+- `default_epic_web_password`
+- `default_hive_web_password`
+- `default_antminer_ssh_password`
+- `default_bosminer_ssh_password`
 - `socket_linger_time`
 
 

pyasic/config/mining/__init__.py

@@ -593,6 +593,8 @@ class MiningModeConfig(MinerConfigOption):
                 scaling=ScalingConfig.from_boser(grpc_miner_conf, mode="hashrate"),
             )
 
+        return cls.default()
+
     @classmethod
     def from_auradine(cls, web_mode: dict):
         try:

pyasic/config/pools.py

@@ -21,6 +21,13 @@ from dataclasses import dataclass, field
 from typing import List
 
 from pyasic.config.base import MinerConfigValue
+from pyasic.web.braiins_os.proto.braiins.bos.v1 import (
+    PoolConfiguration,
+    PoolGroupConfiguration,
+    Quota,
+    SaveAction,
+    SetPoolGroupsRequest,
+)
 
 
 @dataclass
@@ -134,6 +141,11 @@ class Pool(MinerConfigValue):
             "stratumPassword": self.password,
         }
 
+    def as_boser(self) -> PoolConfiguration:
+        return PoolConfiguration(
+            url=self.url, user=self.user, password=self.password, enabled=True
+        )
+
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "Pool":
         return cls(
@@ -306,6 +318,13 @@ class PoolGroup(MinerConfigValue):
     def as_bitaxe(self, user_suffix: str = None) -> dict:
         return self.pools[0].as_bitaxe(user_suffix=user_suffix)
 
+    def as_boser(self, user_suffix: str = None) -> PoolGroupConfiguration:
+        return PoolGroupConfiguration(
+            name=self.name,
+            quota=Quota(value=self.quota),
+            pools=[p.as_boser() for p in self.pools],
+        )
+
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "PoolGroup":
         cls_conf = {}
@@ -446,7 +465,12 @@ class PoolConfig(MinerConfigValue):
         return {"group": [PoolGroup().as_bosminer()]}
 
     def as_boser(self, user_suffix: str = None) -> dict:
-        return {}
+        return {
+            "set_pool_groups": SetPoolGroupsRequest(
+                save_action=SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+                pool_groups=[g.as_boser(user_suffix=user_suffix) for g in self.groups],
+            )
+        }
 
     def as_auradine(self, user_suffix: str = None) -> dict:
         if len(self.groups) > 0:

pyasic/data/pools.py

@@ -4,7 +4,7 @@ from typing import Optional
 from urllib.parse import urlparse
 
 
-class Scheme (Enum):
+class Scheme(Enum):
     STRATUM_V1 = "stratum+tcp"
     STRATUM_V2 = "stratum2+tcp"
 
@@ -23,12 +23,12 @@ class PoolUrl:
             return f"{self.scheme.value}://{self.host}:{self.port}"
 
     @classmethod
-    def from_str(cls, url: str) -> 'PoolUrl':
+    def from_str(cls, url: str) -> "PoolUrl":
         parsed_url = urlparse(url)
         scheme = Scheme(parsed_url.scheme)
         host = parsed_url.hostname
         port = parsed_url.port
-        pubkey = parsed_url.path.lstrip('/') if scheme == Scheme.STRATUM_V2 else None
+        pubkey = parsed_url.path.lstrip("/") if scheme == Scheme.STRATUM_V2 else None
         return cls(scheme=scheme, host=host, port=port, pubkey=pubkey)
 
 
@@ -50,8 +50,6 @@ class PoolMetrics:
     pool_stale_percent: Percentage of stale shares by the pool.
     """
 
-    pool_rejected_percent: float = field(init=False)
-    pool_stale_percent: float = field(init=False)
     url: PoolUrl
     accepted: int = None
     rejected: int = None
@@ -61,6 +59,8 @@ class PoolMetrics:
     alive: bool = None
     index: int = None
     user: str = None
+    pool_rejected_percent: float = field(init=False)
+    pool_stale_percent: float = field(init=False)
 
     @property
     def pool_rejected_percent(self) -> float:  # noqa - Skip PyCharm inspection

pyasic/miners/antminer/bosminer/X19/S19.py

@@ -29,6 +29,7 @@ from pyasic.miners.device.models import (
     S19kProNoPIC,
     S19Plus,
     S19Pro,
+    S19ProPlusHydro,
 )
 
 
@@ -82,3 +83,7 @@ class BOSMinerS19jProPlusNoPIC(BOSer, S19jProPlusNoPIC):
 
 class BOSMinerS19XP(BOSer, S19XP):
     pass
+
+
+class BOSMinerS19ProPlusHydro(BOSer, S19ProPlusHydro):
+    pass

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

@@ -27,6 +27,7 @@ from .S19 import (
     BOSMinerS19kProNoPIC,
     BOSMinerS19Plus,
     BOSMinerS19Pro,
+    BOSMinerS19ProPlusHydro,
     BOSMinerS19XP,
 )
 from .T19 import BOSMinerT19

pyasic/miners/antminer/vnish/X19/S19.py

@@ -24,6 +24,7 @@ from pyasic.miners.device.models import (
     S19jPro,
     S19NoPIC,
     S19Pro,
+    S19ProHydro,
 )
 
 
@@ -57,3 +58,7 @@ class VNishS19j(VNish, S19j):
 
 class VNishS19jPro(VNish, S19jPro):
     pass
+
+
+class VNishS19ProHydro(VNish, S19ProHydro):
+    pass

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

@@ -22,6 +22,7 @@ from .S19 import (
     VNishS19jPro,
     VNishS19NoPIC,
     VNishS19Pro,
+    VNishS19ProHydro,
     VNishS19XP,
 )
 from .T19 import VNishT19

pyasic/miners/backends/antminer.py

@@ -19,7 +19,7 @@ from typing import List, Optional, Union
 from pyasic.config import MinerConfig, MiningModeConfig
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
 from pyasic.data.error_codes import MinerErrorData, X19Error
-from pyasic.data.pools import PoolMetrics
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.errors import APIError
 from pyasic.miners.backends.bmminer import BMMiner
 from pyasic.miners.backends.cgminer import CGMiner
@@ -370,6 +370,8 @@ class AntminerModern(BMMiner):
             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"),
@@ -377,7 +379,7 @@ class AntminerModern(BMMiner):
                         remote_failures=pool_info.get("Remote Failures"),
                         active=pool_info.get("Stratum Active"),
                         alive=pool_info.get("Status") == "Alive",
-                        url=pool_info.get("URL"),
+                        url=pool_url,
                         user=pool_info.get("User"),
                         index=pool_info.get("POOL"),
                     )

pyasic/miners/backends/bitaxe.py

@@ -25,6 +25,10 @@ BITAXE_DATA_LOC = DataLocations(
             "_get_hashboards",
             [WebAPICommand("web_system_info", "system/info")],
         ),
+        str(DataOptions.HOSTNAME): DataFunction(
+            "_get_hostname",
+            [WebAPICommand("web_system_info", "system/info")],
+        ),
         str(DataOptions.FANS): DataFunction(
             "_get_fans",
             [WebAPICommand("web_system_info", "system/info")],

pyasic/miners/backends/braiins_os.py

@@ -26,7 +26,7 @@ from pyasic.config import MinerConfig
 from pyasic.config.mining import MiningModePowerTune
 from pyasic.data import AlgoHashRate, Fan, HashBoard, HashUnit
 from pyasic.data.error_codes import BraiinsOSError, MinerErrorData
-from pyasic.data.pools import PoolMetrics
+from pyasic.data.pools import PoolMetrics, PoolUrl
 from pyasic.errors import APIError
 from pyasic.miners.data import (
     DataFunction,
@@ -189,7 +189,6 @@ class BOSMiner(BraiinsOSFirmware):
 
     async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
         self.config = config
-        print(config)
         parsed_cfg = config.as_bosminer(user_suffix=user_suffix)
 
         toml_conf = toml.dumps(
@@ -592,6 +591,8 @@ class BOSMiner(BraiinsOSFirmware):
             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"),
@@ -599,7 +600,7 @@ class BOSMiner(BraiinsOSFirmware):
                         remote_failures=pool_info.get("Remote Failures"),
                         active=pool_info.get("Stratum Active"),
                         alive=pool_info.get("Status") == "Alive",
-                        url=pool_info.get("URL"),
+                        url=pool_url,
                         user=pool_info.get("User"),
                         index=pool_info.get("POOL"),
                     )
@@ -781,6 +782,11 @@ class BOSer(BraiinsOSFirmware):
 
         return MinerConfig.from_boser(grpc_conf)
 
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        boser_cfg = config.as_boser(user_suffix=user_suffix)
+        for key in boser_cfg:
+            await self.web.send_command(key, message=boser_cfg[key])
+
     async def set_power_limit(self, wattage: int) -> bool:
         try:
             result = await self.web.set_power_target(

pyasic/miners/backends/epic.py

@@ -14,6 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
+from pathlib import Path
 from typing import List, Optional
 
 from pyasic.config import MinerConfig
@@ -452,3 +453,17 @@ class ePIC(ePICFirmware):
                 return pool_data
         except LookupError:
             pass
+
+    async def upgrade_firmware(self, file: Path | str, keep_settings: bool = True) -> bool:
+
+        """
+        Upgrade the firmware of the ePIC miner device.
+
+        Args:
+            file (Path | str): The local file path of the firmware to be uploaded.
+            keep_settings (bool): Whether to keep the current settings after the update.
+
+        Returns:
+            bool: Whether the firmware update succeeded.
+        """
+        return await self.web.system_update(file=file, keep_settings=keep_settings)

pyasic/miners/backends/innosilicon.py

@@ -29,6 +29,7 @@ from pyasic.miners.data import (
     WebAPICommand,
 )
 from pyasic.web.innosilicon import InnosiliconWebAPI
+from pyasic.data.pools import PoolMetrics, PoolUrl
 
 INNOSILICON_DATA_LOC = DataLocations(
     **{
@@ -90,6 +91,10 @@ INNOSILICON_DATA_LOC = DataLocations(
             "_get_uptime",
             [RPCAPICommand("rpc_stats", "stats")],
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")]
+        )
     }
 )
 
@@ -111,7 +116,7 @@ class Innosilicon(CGMiner):
         except APIError:
             return self.config
 
-        self.config = MinerConfig.from_inno(pools)
+        self.config = MinerConfig.from_inno([pools])
         return self.config
 
     async def reboot(self) -> bool:
@@ -365,3 +370,33 @@ class Innosilicon(CGMiner):
                 level = int(level)
                 limit = 1250 + (250 * level)
                 return limit
+
+    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

pyasic/miners/backends/luxminer.py

@@ -17,6 +17,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 LuxOSFirmware
@@ -51,6 +52,9 @@ LUXMINER_DATA_LOC = DataLocations(
         str(DataOptions.UPTIME): DataFunction(
             "_get_uptime", [RPCAPICommand("rpc_stats", "stats")]
         ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools", [RPCAPICommand("rpc_pools", "pools")]
+        ),
     }
 )
 
@@ -297,3 +301,33 @@ class LUXMiner(LuxOSFirmware):
                 return int(rpc_stats["STATS"][1]["Elapsed"])
             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

pyasic/miners/factory.py

@@ -369,6 +369,7 @@ MINER_CLASSES = {
         "ANTMINER S19K PRO NOPIC": BOSMinerS19kProNoPIC,
         "ANTMINER S19K PRO": BOSMinerS19kProNoPIC,
         "ANTMINER S19 XP": BOSMinerS19XP,
+        "ANTMINER S19 PRO+ HYD.": BOSMinerS19ProPlusHydro,
         "ANTMINER T19": BOSMinerT19,
         "ANTMINER S21": BOSMinerS21,
     },
@@ -386,6 +387,7 @@ MINER_CLASSES = {
         "ANTMINER S19J PRO": VNishS19jPro,
         "ANTMINER S19A": VNishS19a,
         "ANTMINER S19A PRO": VNishS19aPro,
+        "ANTMINER S19 PRO HYD.": VNishS19ProHydro,
         "ANTMINER T19": VNishT19,
         "ANTMINER S21": VNishS21,
     },
@@ -832,7 +834,9 @@ class MinerFactory:
 
     async def _get_model_antminer_web(self, ip: str) -> str | None:
         # last resort, this is slow
-        auth = httpx.DigestAuth("root", "root")
+        auth = httpx.DigestAuth(
+            "root", settings.get("default_antminer_web_password", "root")
+        )
         web_json_data = await self.send_web_command(
             ip, "/cgi-bin/get_system_info.cgi", auth=auth
         )

pyasic/web/braiins_os/boser.py

@@ -414,15 +414,6 @@ class BOSerWebAPI(BaseWebAPI):
             "get_pool_groups", message=GetPoolGroupsRequest(), privileged=True
         )
 
-    async def create_pool_group(self) -> dict:
-        raise NotImplementedError
-
-    async def update_pool_group(self) -> dict:
-        raise NotImplementedError
-
-    async def remove_pool_group(self) -> dict:
-        raise NotImplementedError
-
     async def get_miner_configuration(self) -> dict:
         return await self.send_command(
             "get_miner_configuration",
@@ -490,3 +481,15 @@ class BOSerWebAPI(BaseWebAPI):
             ),
             privileged=True,
         )
+
+    async def set_pool_groups(
+        self,
+        pool_groups: List[PoolGroupConfiguration],
+        save_action: SaveAction = SaveAction.SAVE_ACTION_SAVE_AND_APPLY,
+    ) -> dict:
+        return await self.send_command(
+            "set_pool_groups",
+            message=SetPoolGroupsRequest(
+                save_action=save_action, pool_groups=pool_groups
+            ),
+        )

pyasic/web/braiins_os/proto/braiins/bos/__init__.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 
 @dataclass(eq=False, repr=False)
 class ApiVersion(betterproto.Message):
-    """LATEST_API_VERSION=1.0.0-beta.4"""
+    """LATEST_API_VERSION=1.2.0"""
 
     major: int = betterproto.uint64_field(1)
     minor: int = betterproto.uint64_field(2)
@@ -52,6 +52,7 @@ class ApiVersionServiceStub(betterproto.ServiceStub):
 
 
 class ApiVersionServiceBase(ServiceBase):
+
     async def get_api_version(
         self, api_version_request: "ApiVersionRequest"
     ) -> "ApiVersion":

pyasic/web/braiins_os/proto/braiins/bos/v1/__init__.py

@@ -1,5 +1,5 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# sources: bos/v1/actions.proto, bos/v1/authentication.proto, bos/v1/common.proto, bos/v1/configuration.proto, bos/v1/constraints.proto, bos/v1/cooling.proto, bos/v1/license.proto, bos/v1/miner.proto, bos/v1/performance.proto, bos/v1/pool.proto, bos/v1/units.proto, bos/v1/work.proto
+# sources: bos/v1/actions.proto, bos/v1/authentication.proto, bos/v1/common.proto, bos/v1/configuration.proto, bos/v1/constraints.proto, bos/v1/cooling.proto, bos/v1/license.proto, bos/v1/miner.proto, bos/v1/network.proto, bos/v1/performance.proto, bos/v1/pool.proto, bos/v1/units.proto, bos/v1/work.proto
 # plugin: python-betterproto
 # This file has been @generated
 import warnings
@@ -69,6 +69,7 @@ class Platform(betterproto.Enum):
     PLATFORM_AM3_AML = 4
     PLATFORM_STM32MP157C_II1_AM2 = 5
     PLATFORM_CVITEK_BM1_AM2 = 6
+    PLATFORM_ZYNQ_BM3_AM2 = 7
 
 
 class BosMode(betterproto.Enum):
@@ -134,6 +135,12 @@ class SupportArchiveFormat(betterproto.Enum):
     """BOS custom format"""
 
 
+class NetworkProtocol(betterproto.Enum):
+    NETWORK_PROTOCOL_UNSPECIFIED = 0
+    NETWORK_PROTOCOL_DHCP = 1
+    NETWORK_PROTOCOL_STATIC = 2
+
+
 @dataclass(eq=False, repr=False)
 class StartRequest(betterproto.Message):
     """Request for start bosminer action."""
@@ -256,7 +263,14 @@ class LoginRequest(betterproto.Message):
 class LoginResponse(betterproto.Message):
     """Response for login action."""
 
-    pass
+    token: str = betterproto.string_field(1)
+    """Token to be used for authentication"""
+
+    timeout_s: int = betterproto.uint32_field(2)
+    """
+    Authentication token validity/timeout in seconds. Token validity refreshed
+    to this value with each request.
+    """
 
 
 @dataclass(eq=False, repr=False)
@@ -555,7 +569,16 @@ class TunerConfiguration(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class TunerConstraints(betterproto.Message):
     power_target: "PowerConstraints" = betterproto.message_field(1)
+    """Tuner power target mode constraints"""
+
     hashrate_target: "HashrateConstraints" = betterproto.message_field(2)
+    """Tuner hashrate target mode constraints"""
+
+    enabled: "BooleanConstraint" = betterproto.message_field(3)
+    """Tuner enabled enabled default value"""
+
+    default_mode: "TunerMode" = betterproto.enum_field(4)
+    """Default tuner mode"""
 
 
 @dataclass(eq=False, repr=False)
@@ -618,6 +641,9 @@ class DpsConstraints(betterproto.Message):
     shutdown_duration: "DurationConstraints" = betterproto.message_field(6)
     """Dynamic Performance Scaling shutdown duration constraints"""
 
+    enabled: "BooleanConstraint" = betterproto.message_field(7)
+    """Dynamic Performance Scaling enabled default value"""
+
 
 @dataclass(eq=False, repr=False)
 class HashboardConstraints(betterproto.Message):
@@ -1104,6 +1130,11 @@ class PoolStats(betterproto.Message):
     generated_work: int = betterproto.uint64_field(6)
     """Generated work"""
 
+    last_share_time: Optional[datetime] = betterproto.message_field(
+        7, optional=True, group="_last_share_time"
+    )
+    """Last share time"""
+
 
 @dataclass(eq=False, repr=False)
 class GetPoolGroupsRequest(betterproto.Message):
@@ -1184,6 +1215,33 @@ class RemovePoolGroupResponse(betterproto.Message):
     pass
 
 
+@dataclass(eq=False, repr=False)
+class SetPoolGroupsRequest(betterproto.Message):
+    """Request for setting pool groups"""
+
+    save_action: "SaveAction" = betterproto.enum_field(1)
+    """
+    Save action SAVE just update config but changes will not be applied
+    SAVE_AND_APPLY and SAVE_AND_FORCE_APPLY are equal for this method. Pools
+    config will be updated and changes will be applied that will trigger
+    restart.
+    """
+
+    pool_groups: List["PoolGroupConfiguration"] = betterproto.message_field(2)
+    """
+    Pool groups configuration `uid` must not be specified (it will be
+    generated)
+    """
+
+
+@dataclass(eq=False, repr=False)
+class SetPoolGroupsResponse(betterproto.Message):
+    """Response on setting pool groups"""
+
+    pool_groups: List["PoolGroupConfiguration"] = betterproto.message_field(1)
+    """Configured pool groups"""
+
+
 @dataclass(eq=False, repr=False)
 class GetMinerConfigurationRequest(betterproto.Message):
     pass
@@ -1234,8 +1292,9 @@ class NoneLicense(betterproto.Message):
     time_to_restricted: int = betterproto.uint32_field(1)
     """
     BOS Initialization timeout - number of seconds elapsed since bosminer start
-    i.e., number of seconds BOS will start mining in restricted mode burning
-    15% of hashrate
+    i.e., number of seconds BOS will start mining in restricted mode burning 5%
+    of hashrate For more, see Section 3.10 of
+    https://braiins.com/os/plus/license
     """
 
 
@@ -1350,6 +1409,27 @@ class BosVersion(betterproto.Message):
     bos_plus: bool = betterproto.bool_field(3)
 
 
+@dataclass(eq=False, repr=False)
+class ErrorCode(betterproto.Message):
+    code: str = betterproto.string_field(1)
+    reason: str = betterproto.string_field(2)
+    hint: str = betterproto.string_field(3)
+
+
+@dataclass(eq=False, repr=False)
+class Component(betterproto.Message):
+    name: str = betterproto.string_field(1)
+    index: int = betterproto.uint32_field(2)
+
+
+@dataclass(eq=False, repr=False)
+class MinerError(betterproto.Message):
+    timestamp: str = betterproto.string_field(1)
+    message: str = betterproto.string_field(2)
+    error_codes: List["ErrorCode"] = betterproto.message_field(3)
+    components: List["Component"] = betterproto.message_field(4)
+
+
 @dataclass(eq=False, repr=False)
 class GetMinerStatusRequest(betterproto.Message):
     pass
@@ -1402,6 +1482,12 @@ class GetMinerDetailsResponse(betterproto.Message):
     system_uptime_s: int = betterproto.uint64_field(11)
     """System uptime"""
 
+    status: "MinerStatus" = betterproto.enum_field(12)
+    """Miner status"""
+
+    kernel_version: str = betterproto.string_field(13)
+    """Kernel version"""
+
     def __post_init__(self) -> None:
         super().__post_init__()
         if self.is_set("system_uptime"):
@@ -1437,6 +1523,17 @@ class GetMinerStatsResponse(betterproto.Message):
     """Miner power stats"""
 
 
+@dataclass(eq=False, repr=False)
+class GetErrorsRequest(betterproto.Message):
+    pass
+
+
+@dataclass(eq=False, repr=False)
+class GetErrorsResponse(betterproto.Message):
+    errors: List["MinerError"] = betterproto.message_field(1)
+    """Array of errors"""
+
+
 @dataclass(eq=False, repr=False)
 class Hashboard(betterproto.Message):
     """Structure to handle HB details"""
@@ -1467,6 +1564,9 @@ class Hashboard(betterproto.Message):
     stats: "WorkSolverStats" = betterproto.message_field(8)
     """Hashboard stats"""
 
+    model: Optional[str] = betterproto.string_field(9, optional=True, group="_model")
+    """Hashboard model"""
+
 
 @dataclass(eq=False, repr=False)
 class GetSupportArchiveRequest(betterproto.Message):
@@ -1530,6 +1630,108 @@ class HashboardEnableState(betterproto.Message):
     """Flag if hashboard is enabled or not"""
 
 
+@dataclass(eq=False, repr=False)
+class GetNetworkConfigurationRequest(betterproto.Message):
+    pass
+
+
+@dataclass(eq=False, repr=False)
+class GetNetworkConfigurationResponse(betterproto.Message):
+    network: "NetworkConfiguration" = betterproto.message_field(1)
+
+
+@dataclass(eq=False, repr=False)
+class SetNetworkConfigurationRequest(betterproto.Message):
+    dhcp: "Dhcp" = betterproto.message_field(1, group="protocol")
+    static: "Static" = betterproto.message_field(2, group="protocol")
+    hostname: Optional[str] = betterproto.string_field(
+        3, optional=True, group="_hostname"
+    )
+    """Hostname. Existing value will be preserved if this field is not set."""
+
+
+@dataclass(eq=False, repr=False)
+class SetNetworkConfigurationResponse(betterproto.Message):
+    network: "NetworkConfiguration" = betterproto.message_field(1)
+
+
+@dataclass(eq=False, repr=False)
+class NetworkConfiguration(betterproto.Message):
+    dhcp: "Dhcp" = betterproto.message_field(1, group="protocol")
+    static: "Static" = betterproto.message_field(2, group="protocol")
+    hostname: str = betterproto.string_field(3)
+    """Hostname"""
+
+
+@dataclass(eq=False, repr=False)
+class Dhcp(betterproto.Message):
+    pass
+
+
+@dataclass(eq=False, repr=False)
+class Static(betterproto.Message):
+    address: str = betterproto.string_field(1)
+    """IP address"""
+
+    netmask: str = betterproto.string_field(2)
+    """Netmask"""
+
+    gateway: str = betterproto.string_field(3)
+    """Gateway"""
+
+    dns_servers: List[str] = betterproto.string_field(4)
+    """DNS servers"""
+
+
+@dataclass(eq=False, repr=False)
+class GetNetworkInfoRequest(betterproto.Message):
+    pass
+
+
+@dataclass(eq=False, repr=False)
+class GetNetworkInfoResponse(betterproto.Message):
+    """
+    Response message for GetCurrentNetworkConfiguration Represents the current
+    network configuration for the default network interface. Only IPv4 is
+    supported.
+    """
+
+    name: str = betterproto.string_field(1)
+    """Name of the network interface"""
+
+    mac_address: Optional[str] = betterproto.string_field(
+        2, optional=True, group="_mac_address"
+    )
+    """MAC address of the network interface"""
+
+    hostname: Optional[str] = betterproto.string_field(
+        3, optional=True, group="_hostname"
+    )
+    """Miner hostname"""
+
+    protocol: Optional["NetworkProtocol"] = betterproto.enum_field(
+        4, optional=True, group="_protocol"
+    )
+    """Network protocol"""
+
+    dns_servers: List[str] = betterproto.string_field(5)
+    """List of configured DNS servers"""
+
+    networks: List["IpNetwork"] = betterproto.message_field(6)
+    """List of assigned IP addresses"""
+
+    default_gateway: Optional[str] = betterproto.string_field(
+        7, optional=True, group="_default_gateway"
+    )
+    """Default gateway/route for the interface"""
+
+
+@dataclass(eq=False, repr=False)
+class IpNetwork(betterproto.Message):
+    address: str = betterproto.string_field(1)
+    netmask: str = betterproto.string_field(2)
+
+
 class ActionsServiceStub(betterproto.ServiceStub):
     async def start(
         self,
@@ -2049,6 +2251,23 @@ class PoolServiceStub(betterproto.ServiceStub):
             metadata=metadata,
         )
 
+    async def set_pool_groups(
+        self,
+        set_pool_groups_request: "SetPoolGroupsRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "SetPoolGroupsResponse":
+        return await self._unary_unary(
+            "/braiins.bos.v1.PoolService/SetPoolGroups",
+            set_pool_groups_request,
+            SetPoolGroupsResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
 
 class ConfigurationServiceStub(betterproto.ServiceStub):
     async def get_miner_configuration(
@@ -2158,6 +2377,23 @@ class MinerServiceStub(betterproto.ServiceStub):
             metadata=metadata,
         )
 
+    async def get_errors(
+        self,
+        get_errors_request: "GetErrorsRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetErrorsResponse":
+        return await self._unary_unary(
+            "/braiins.bos.v1.MinerService/GetErrors",
+            get_errors_request,
+            GetErrorsResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
     async def get_hashboards(
         self,
         get_hashboards_request: "GetHashboardsRequest",
@@ -2228,7 +2464,61 @@ class MinerServiceStub(betterproto.ServiceStub):
         )
 
 
+class NetworkServiceStub(betterproto.ServiceStub):
+    async def get_network_configuration(
+        self,
+        get_network_configuration_request: "GetNetworkConfigurationRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetNetworkConfigurationResponse":
+        return await self._unary_unary(
+            "/braiins.bos.v1.NetworkService/GetNetworkConfiguration",
+            get_network_configuration_request,
+            GetNetworkConfigurationResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+    async def set_network_configuration(
+        self,
+        set_network_configuration_request: "SetNetworkConfigurationRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "SetNetworkConfigurationResponse":
+        return await self._unary_unary(
+            "/braiins.bos.v1.NetworkService/SetNetworkConfiguration",
+            set_network_configuration_request,
+            SetNetworkConfigurationResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+    async def get_network_info(
+        self,
+        get_network_info_request: "GetNetworkInfoRequest",
+        *,
+        timeout: Optional[float] = None,
+        deadline: Optional["Deadline"] = None,
+        metadata: Optional["MetadataLike"] = None
+    ) -> "GetNetworkInfoResponse":
+        return await self._unary_unary(
+            "/braiins.bos.v1.NetworkService/GetNetworkInfo",
+            get_network_info_request,
+            GetNetworkInfoResponse,
+            timeout=timeout,
+            deadline=deadline,
+            metadata=metadata,
+        )
+
+
 class ActionsServiceBase(ServiceBase):
+
     async def start(self, start_request: "StartRequest") -> "StartResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
@@ -2357,26 +2647,23 @@ class ActionsServiceBase(ServiceBase):
                 RebootRequest,
                 RebootResponse,
             ),
-            "/braiins.bos.v1.ActionsService/SetLocateDeviceStatus": (
-                grpclib.const.Handler(
-                    self.__rpc_set_locate_device_status,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    SetLocateDeviceStatusRequest,
-                    LocateDeviceStatusResponse,
-                )
+            "/braiins.bos.v1.ActionsService/SetLocateDeviceStatus": grpclib.const.Handler(
+                self.__rpc_set_locate_device_status,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                SetLocateDeviceStatusRequest,
+                LocateDeviceStatusResponse,
             ),
-            "/braiins.bos.v1.ActionsService/GetLocateDeviceStatus": (
-                grpclib.const.Handler(
-                    self.__rpc_get_locate_device_status,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    GetLocateDeviceStatusRequest,
-                    LocateDeviceStatusResponse,
-                )
+            "/braiins.bos.v1.ActionsService/GetLocateDeviceStatus": grpclib.const.Handler(
+                self.__rpc_get_locate_device_status,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetLocateDeviceStatusRequest,
+                LocateDeviceStatusResponse,
             ),
         }
 
 
 class AuthenticationServiceBase(ServiceBase):
+
     async def login(self, login_request: "LoginRequest") -> "LoginResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
@@ -2417,6 +2704,7 @@ class AuthenticationServiceBase(ServiceBase):
 
 
 class CoolingServiceBase(ServiceBase):
+
     async def get_cooling_state(
         self, get_cooling_state_request: "GetCoolingStateRequest"
     ) -> "GetCoolingStateResponse":
@@ -2461,6 +2749,7 @@ class CoolingServiceBase(ServiceBase):
 
 
 class PerformanceServiceBase(ServiceBase):
+
     async def get_tuner_state(
         self, get_tuner_state_request: "GetTunerStateRequest"
     ) -> "GetTunerStateResponse":
@@ -2648,21 +2937,17 @@ class PerformanceServiceBase(ServiceBase):
                 GetTunerStateRequest,
                 GetTunerStateResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/ListTargetProfiles": (
-                grpclib.const.Handler(
-                    self.__rpc_list_target_profiles,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    ListTargetProfilesRequest,
-                    ListTargetProfilesResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/ListTargetProfiles": grpclib.const.Handler(
+                self.__rpc_list_target_profiles,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                ListTargetProfilesRequest,
+                ListTargetProfilesResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/SetDefaultPowerTarget": (
-                grpclib.const.Handler(
-                    self.__rpc_set_default_power_target,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    SetDefaultPowerTargetRequest,
-                    SetPowerTargetResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/SetDefaultPowerTarget": grpclib.const.Handler(
+                self.__rpc_set_default_power_target,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                SetDefaultPowerTargetRequest,
+                SetPowerTargetResponse,
             ),
             "/braiins.bos.v1.PerformanceService/SetPowerTarget": grpclib.const.Handler(
                 self.__rpc_set_power_target,
@@ -2670,53 +2955,41 @@ class PerformanceServiceBase(ServiceBase):
                 SetPowerTargetRequest,
                 SetPowerTargetResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/IncrementPowerTarget": (
-                grpclib.const.Handler(
-                    self.__rpc_increment_power_target,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    IncrementPowerTargetRequest,
-                    SetPowerTargetResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/IncrementPowerTarget": grpclib.const.Handler(
+                self.__rpc_increment_power_target,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                IncrementPowerTargetRequest,
+                SetPowerTargetResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/DecrementPowerTarget": (
-                grpclib.const.Handler(
-                    self.__rpc_decrement_power_target,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    DecrementPowerTargetRequest,
-                    SetPowerTargetResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/DecrementPowerTarget": grpclib.const.Handler(
+                self.__rpc_decrement_power_target,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                DecrementPowerTargetRequest,
+                SetPowerTargetResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/SetDefaultHashrateTarget": (
-                grpclib.const.Handler(
-                    self.__rpc_set_default_hashrate_target,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    SetDefaultHashrateTargetRequest,
-                    SetHashrateTargetResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/SetDefaultHashrateTarget": grpclib.const.Handler(
+                self.__rpc_set_default_hashrate_target,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                SetDefaultHashrateTargetRequest,
+                SetHashrateTargetResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/SetHashrateTarget": (
-                grpclib.const.Handler(
-                    self.__rpc_set_hashrate_target,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    SetHashrateTargetRequest,
-                    SetHashrateTargetResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/SetHashrateTarget": grpclib.const.Handler(
+                self.__rpc_set_hashrate_target,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                SetHashrateTargetRequest,
+                SetHashrateTargetResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/IncrementHashrateTarget": (
-                grpclib.const.Handler(
-                    self.__rpc_increment_hashrate_target,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    IncrementHashrateTargetRequest,
-                    SetHashrateTargetResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/IncrementHashrateTarget": grpclib.const.Handler(
+                self.__rpc_increment_hashrate_target,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                IncrementHashrateTargetRequest,
+                SetHashrateTargetResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/DecrementHashrateTarget": (
-                grpclib.const.Handler(
-                    self.__rpc_decrement_hashrate_target,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    DecrementHashrateTargetRequest,
-                    SetHashrateTargetResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/DecrementHashrateTarget": grpclib.const.Handler(
+                self.__rpc_decrement_hashrate_target,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                DecrementHashrateTargetRequest,
+                SetHashrateTargetResponse,
             ),
             "/braiins.bos.v1.PerformanceService/SetDPS": grpclib.const.Handler(
                 self.__rpc_set_dps,
@@ -2724,34 +2997,29 @@ class PerformanceServiceBase(ServiceBase):
                 SetDpsRequest,
                 SetDpsResponse,
             ),
-            "/braiins.bos.v1.PerformanceService/SetPerformanceMode": (
-                grpclib.const.Handler(
-                    self.__rpc_set_performance_mode,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    SetPerformanceModeRequest,
-                    PerformanceMode,
-                )
+            "/braiins.bos.v1.PerformanceService/SetPerformanceMode": grpclib.const.Handler(
+                self.__rpc_set_performance_mode,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                SetPerformanceModeRequest,
+                PerformanceMode,
             ),
-            "/braiins.bos.v1.PerformanceService/GetActivePerformanceMode": (
-                grpclib.const.Handler(
-                    self.__rpc_get_active_performance_mode,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    GetPerformanceModeRequest,
-                    PerformanceMode,
-                )
+            "/braiins.bos.v1.PerformanceService/GetActivePerformanceMode": grpclib.const.Handler(
+                self.__rpc_get_active_performance_mode,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetPerformanceModeRequest,
+                PerformanceMode,
             ),
-            "/braiins.bos.v1.PerformanceService/RemoveTunedProfiles": (
-                grpclib.const.Handler(
-                    self.__rpc_remove_tuned_profiles,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    RemoveTunedProfilesRequest,
-                    RemoveTunedProfilesResponse,
-                )
+            "/braiins.bos.v1.PerformanceService/RemoveTunedProfiles": grpclib.const.Handler(
+                self.__rpc_remove_tuned_profiles,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                RemoveTunedProfilesRequest,
+                RemoveTunedProfilesResponse,
             ),
         }
 
 
 class PoolServiceBase(ServiceBase):
+
     async def get_pool_groups(
         self, get_pool_groups_request: "GetPoolGroupsRequest"
     ) -> "GetPoolGroupsResponse":
@@ -2772,6 +3040,11 @@ class PoolServiceBase(ServiceBase):
     ) -> "RemovePoolGroupResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
+    async def set_pool_groups(
+        self, set_pool_groups_request: "SetPoolGroupsRequest"
+    ) -> "SetPoolGroupsResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
     async def __rpc_get_pool_groups(
         self,
         stream: "grpclib.server.Stream[GetPoolGroupsRequest, GetPoolGroupsResponse]",
@@ -2804,6 +3077,14 @@ class PoolServiceBase(ServiceBase):
         response = await self.remove_pool_group(request)
         await stream.send_message(response)
 
+    async def __rpc_set_pool_groups(
+        self,
+        stream: "grpclib.server.Stream[SetPoolGroupsRequest, SetPoolGroupsResponse]",
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.set_pool_groups(request)
+        await stream.send_message(response)
+
     def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
         return {
             "/braiins.bos.v1.PoolService/GetPoolGroups": grpclib.const.Handler(
@@ -2830,10 +3111,17 @@ class PoolServiceBase(ServiceBase):
                 RemovePoolGroupRequest,
                 RemovePoolGroupResponse,
             ),
+            "/braiins.bos.v1.PoolService/SetPoolGroups": grpclib.const.Handler(
+                self.__rpc_set_pool_groups,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                SetPoolGroupsRequest,
+                SetPoolGroupsResponse,
+            ),
         }
 
 
 class ConfigurationServiceBase(ServiceBase):
+
     async def get_miner_configuration(
         self, get_miner_configuration_request: "GetMinerConfigurationRequest"
     ) -> "GetMinerConfigurationResponse":
@@ -2862,26 +3150,23 @@ class ConfigurationServiceBase(ServiceBase):
 
     def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
         return {
-            "/braiins.bos.v1.ConfigurationService/GetMinerConfiguration": (
-                grpclib.const.Handler(
-                    self.__rpc_get_miner_configuration,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    GetMinerConfigurationRequest,
-                    GetMinerConfigurationResponse,
-                )
+            "/braiins.bos.v1.ConfigurationService/GetMinerConfiguration": grpclib.const.Handler(
+                self.__rpc_get_miner_configuration,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetMinerConfigurationRequest,
+                GetMinerConfigurationResponse,
             ),
-            "/braiins.bos.v1.ConfigurationService/GetConstraints": (
-                grpclib.const.Handler(
-                    self.__rpc_get_constraints,
-                    grpclib.const.Cardinality.UNARY_UNARY,
-                    GetConstraintsRequest,
-                    GetConstraintsResponse,
-                )
+            "/braiins.bos.v1.ConfigurationService/GetConstraints": grpclib.const.Handler(
+                self.__rpc_get_constraints,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetConstraintsRequest,
+                GetConstraintsResponse,
             ),
         }
 
 
 class LicenseServiceBase(ServiceBase):
+
     async def get_license_state(
         self, get_license_state_request: "GetLicenseStateRequest"
     ) -> "GetLicenseStateResponse":
@@ -2907,6 +3192,7 @@ class LicenseServiceBase(ServiceBase):
 
 
 class MinerServiceBase(ServiceBase):
+
     async def get_miner_status(
         self, get_miner_status_request: "GetMinerStatusRequest"
     ) -> AsyncIterator["GetMinerStatusResponse"]:
@@ -2923,6 +3209,11 @@ class MinerServiceBase(ServiceBase):
     ) -> "GetMinerStatsResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
+    async def get_errors(
+        self, get_errors_request: "GetErrorsRequest"
+    ) -> "GetErrorsResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
     async def get_hashboards(
         self, get_hashboards_request: "GetHashboardsRequest"
     ) -> "GetHashboardsResponse":
@@ -2971,6 +3262,13 @@ class MinerServiceBase(ServiceBase):
         response = await self.get_miner_stats(request)
         await stream.send_message(response)
 
+    async def __rpc_get_errors(
+        self, stream: "grpclib.server.Stream[GetErrorsRequest, GetErrorsResponse]"
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_errors(request)
+        await stream.send_message(response)
+
     async def __rpc_get_hashboards(
         self,
         stream: "grpclib.server.Stream[GetHashboardsRequest, GetHashboardsResponse]",
@@ -3026,6 +3324,12 @@ class MinerServiceBase(ServiceBase):
                 GetMinerStatsRequest,
                 GetMinerStatsResponse,
             ),
+            "/braiins.bos.v1.MinerService/GetErrors": grpclib.const.Handler(
+                self.__rpc_get_errors,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetErrorsRequest,
+                GetErrorsResponse,
+            ),
             "/braiins.bos.v1.MinerService/GetHashboards": grpclib.const.Handler(
                 self.__rpc_get_hashboards,
                 grpclib.const.Cardinality.UNARY_UNARY,
@@ -3051,3 +3355,67 @@ class MinerServiceBase(ServiceBase):
                 DisableHashboardsResponse,
             ),
         }
+
+
+class NetworkServiceBase(ServiceBase):
+
+    async def get_network_configuration(
+        self, get_network_configuration_request: "GetNetworkConfigurationRequest"
+    ) -> "GetNetworkConfigurationResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def set_network_configuration(
+        self, set_network_configuration_request: "SetNetworkConfigurationRequest"
+    ) -> "SetNetworkConfigurationResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def get_network_info(
+        self, get_network_info_request: "GetNetworkInfoRequest"
+    ) -> "GetNetworkInfoResponse":
+        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
+
+    async def __rpc_get_network_configuration(
+        self,
+        stream: "grpclib.server.Stream[GetNetworkConfigurationRequest, GetNetworkConfigurationResponse]",
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_network_configuration(request)
+        await stream.send_message(response)
+
+    async def __rpc_set_network_configuration(
+        self,
+        stream: "grpclib.server.Stream[SetNetworkConfigurationRequest, SetNetworkConfigurationResponse]",
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.set_network_configuration(request)
+        await stream.send_message(response)
+
+    async def __rpc_get_network_info(
+        self,
+        stream: "grpclib.server.Stream[GetNetworkInfoRequest, GetNetworkInfoResponse]",
+    ) -> None:
+        request = await stream.recv_message()
+        response = await self.get_network_info(request)
+        await stream.send_message(response)
+
+    def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
+        return {
+            "/braiins.bos.v1.NetworkService/GetNetworkConfiguration": grpclib.const.Handler(
+                self.__rpc_get_network_configuration,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetNetworkConfigurationRequest,
+                GetNetworkConfigurationResponse,
+            ),
+            "/braiins.bos.v1.NetworkService/SetNetworkConfiguration": grpclib.const.Handler(
+                self.__rpc_set_network_configuration,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                SetNetworkConfigurationRequest,
+                SetNetworkConfigurationResponse,
+            ),
+            "/braiins.bos.v1.NetworkService/GetNetworkInfo": grpclib.const.Handler(
+                self.__rpc_get_network_info,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                GetNetworkInfoRequest,
+                GetNetworkInfoResponse,
+            ),
+        }

pyasic/web/epic.py

@@ -15,9 +15,12 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
+import hashlib
 import json
+from pathlib import Path
 from typing import Any
 
+import aiofiles
 import httpx
 
 from pyasic import settings
@@ -46,6 +49,14 @@ class ePICWebAPI(BaseWebAPI):
         async with httpx.AsyncClient(transport=settings.transport()) as client:
             for retry_cnt in range(settings.get("get_data_retries", 1)):
                 try:
+                    if parameters.get("form") is not None:
+                        form_data = parameters["form"]
+                        form_data.add_field("password", self.pwd)
+                        response = await client.post(
+                            f"http://{self.ip}:{self.port}/{command}",
+                            timeout=5,
+                            data=form_data,
+                        )
                     if post:
                         response = await client.post(
                             f"http://{self.ip}:{self.port}/{command}",
@@ -135,3 +146,22 @@ class ePICWebAPI(BaseWebAPI):
 
     async def capabilities(self) -> dict:
         return await self.send_command("capabilities")
+
+    async def system_update(self, file: Path | str, keep_settings: bool = True):
+        """Perform a system update by uploading a firmware file and sending a
+        command to initiate the update."""
+
+        # calculate the SHA256 checksum of the firmware file
+        sha256_hash = hashlib.sha256()
+        async with aiofiles.open(str(file), "rb") as f:
+            while chunk := await f.read(8192):
+                sha256_hash.update(chunk)
+        checksum = sha256_hash.hexdigest()
+
+        # prepare the multipart/form-data request
+        form_data = aiohttp.FormData()
+        form_data.add_field("checksum", checksum)
+        form_data.add_field("keepsettings", str(keep_settings).lower())
+        form_data.add_field("update.zip", open(file, "rb"), filename="update.zip")
+
+        await self.send_command("systemupdate", form=form_data)

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyasic"
-version = "0.58.0"
+version = "0.59.0"
 description = "A simplified and standardized interface for Bitcoin ASICs."
 authors = ["UpstreamData <brett@upstreamdata.ca>"]
 repository = "https://github.com/UpstreamData/pyasic"