version: bump version number

feature: add support for Elphapex DG1 Home
Fixes: #311
2025-07-21 15:41:35 -06:00 · 2025-07-21 10:08:11 -06:00 · 2025-07-21 10:02:06 -06:00 · 2025-07-21 09:51:51 -06:00 · 2025-07-21 09:48:11 -06:00 · 2025-07-21 09:35:00 -06:00
97 changed files with 1956 additions and 594 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -5,7 +5,7 @@ ci:
    - generate-docs
 repos:
 -   repo: https://github.com/python-poetry/poetry
-    rev: 2.0.1
+    rev: 2.1.2
    hooks:
      - id: poetry-check
      - id: poetry-lock
@@ -27,7 +27,7 @@ repos:
    hooks:
    -   id: black
 -   repo: https://github.com/pycqa/isort
-    rev: 6.0.0
+    rev: 6.0.1
    hooks:
    -   id: isort
        name: isort (python)
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@ Welcome to `pyasic`!  `pyasic` uses an asynchronous method of communicating with
 ## Installation

 It is recommended to install `pyasic` in a [virtual environment](https://realpython.com/python-virtual-environments-a-primer/#what-other-popular-options-exist-aside-from-venv) to isolate it from the rest of your system. Options include:
-  - [pypoetry](https://python-poetry.org/): the reccommended way, since pyasic already uses it by default
+  - [pypoetry](https://python-poetry.org/): the reccommended way, since pyasic already uses it by default. Use version 2.0+

 ```
    poetry install
--- a/docs/miners/antminer/X19.md
+++ b/docs/miners/antminer/X19.md
@@ -157,6 +157,19 @@
        show_root_heading: false
        heading_level: 0

+## S19j Pro+ (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19jProPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19j XP (Stock)

 - [x] Shutdowns
@@ -170,6 +183,19 @@
        show_root_heading: false
        heading_level: 0

+## S19j+ (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bmminer.X19.S19.BMMinerS19jPlus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19j No PIC (Stock)

 - [x] Shutdowns
@@ -287,6 +313,19 @@
        show_root_heading: false
        heading_level: 0

+## S19 XP Hydro (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bosminer.X19.S19.BOSMinerS19XPHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19+ (BOS+)

 - [x] Shutdowns
@@ -443,6 +482,19 @@
        show_root_heading: false
        heading_level: 0

+## S19 Hydro (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19Hydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19 Pro (VNish)

 - [x] Shutdowns
@@ -456,6 +508,19 @@
        show_root_heading: false
        heading_level: 0

+## S19 Pro A (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19ProA
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19 Pro Hydro (VNish)

 - [x] Shutdowns
@@ -469,6 +534,32 @@
        show_root_heading: false
        heading_level: 0

+## S19 XP (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19XP
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
+## S19 XP Hydro (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X19.S19.VNishS19XPHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19a (VNish)

 - [x] Shutdowns
@@ -677,6 +768,19 @@
        show_root_heading: false
        heading_level: 0

+## S19k Pro Dual (ePIC)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.epic.X19.S19.ePICS19kProDual
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19 (Hive)

 - [ ] Shutdowns
@@ -703,6 +807,19 @@
        show_root_heading: false
        heading_level: 0

+## S19K Pro (Hive)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.hiveon.X19.S19.HiveonS19kPro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S19 No PIC (Hive)

 - [ ] Shutdowns
@@ -733,7 +850,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19
@@ -746,7 +863,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19Pro
@@ -759,7 +876,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19XP
@@ -772,7 +889,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19jPro
@@ -785,7 +902,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19jProPlus
@@ -798,7 +915,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X19.S19.LUXMinerS19kPro
@@ -811,7 +928,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X19.T19.LUXMinerT19
--- a/docs/miners/antminer/X21.md
+++ b/docs/miners/antminer/X21.md
@@ -40,6 +40,32 @@
        show_root_heading: false
        heading_level: 0

+## S21+ (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
+## S21+ Hydro (Stock)
+
+- [x] Shutdowns
+- [x] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bmminer.X21.S21.BMMinerS21PlusHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## T21 (Stock)

 - [x] Shutdowns
@@ -66,6 +92,19 @@
        show_root_heading: false
        heading_level: 0

+## S21 Hydro (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bosminer.X21.S21.BOSMinerS21Hydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S21 Pro (BOS+)

 - [x] Shutdowns
@@ -79,6 +118,32 @@
        show_root_heading: false
        heading_level: 0

+## S21+ (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bosminer.X21.S21.BOSMinerS21Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
+## S21+ Hydro (BOS+)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.antminer.bosminer.X21.S21.BOSMinerS21PlusHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## T21 (BOS+)

 - [x] Shutdowns
@@ -105,6 +170,58 @@
        show_root_heading: false
        heading_level: 0

+## S21 Hydro (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X21.S21.VNishS21Hydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
+## S21 Pro (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X21.S21.VNishS21Pro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
+## S21+ (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X21.S21.VNishS21Plus
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
+## S21+ Hydro (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X21.S21.VNishS21PlusHydro
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## T21 (VNish)

 - [x] Shutdowns
@@ -161,7 +278,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X21.S21.LUXMinerS21
@@ -170,6 +287,19 @@
        show_root_heading: false
        heading_level: 0

+## T21 (LuxOS)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.luxos.X21.T21.LUXMinerT21
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## S21 (MaraFW)

 - [ ] Shutdowns
--- a/docs/miners/antminer/X3.md
+++ b/docs/miners/antminer/X3.md
@@ -73,7 +73,7 @@
 - [x] Setpoints
 - [x] Presets

-::: pyasic.miners.antminer.vnish.X3.L3.VnishL3Plus
+::: pyasic.miners.antminer.vnish.X3.L3.VNishL3Plus
    handler: python
    options:
        show_root_heading: false
--- a/docs/miners/antminer/X7.md
+++ b/docs/miners/antminer/X7.md
@@ -47,7 +47,7 @@
 - [x] Setpoints
 - [x] Presets

-::: pyasic.miners.antminer.vnish.X7.L7.VnishL7
+::: pyasic.miners.antminer.vnish.X7.L7.VNishL7
    handler: python
    options:
        show_root_heading: false
--- a/docs/miners/antminer/X9.md
+++ b/docs/miners/antminer/X9.md
@@ -105,6 +105,19 @@
        show_root_heading: false
        heading_level: 0

+## L9 (VNish)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [x] Setpoints
+- [x] Presets
+
+::: pyasic.miners.antminer.vnish.X9.L9.VNishL9
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## T9 (Hive)

 - [ ] Shutdowns
@@ -122,7 +135,7 @@

 - [x] Shutdowns
 - [ ] Power Modes
- [ ] Setpoints
+- [x] Setpoints
 - [x] Presets

 ::: pyasic.miners.antminer.luxos.X9.S9.LUXMinerS9
--- a/docs/miners/avalonminer/nano.md
+++ b/docs/miners/avalonminer/nano.md
@@ -1,6 +1,19 @@
 # pyasic
 ## nano Models

+## Avalon Nano 3s (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.avalonminer.cgminer.nano.nano3.CGMinerAvalonNano3s
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## Avalon Nano 3 (Stock)

 - [ ] Shutdowns
--- a/docs/miners/blockminer/blockminer.md
+++ b/docs/miners/blockminer/blockminer.md
@@ -27,3 +27,16 @@
        show_root_heading: false
        heading_level: 0

+## BlockMiner eLITE 1.0 (ePIC)
+
+- [x] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.blockminer.epic.blockminer.blockminer.ePICBlockMinerELITE1
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
--- a/docs/miners/elphapex/DGX.md
+++ b/docs/miners/elphapex/DGX.md
@@ -1,6 +1,19 @@
 # pyasic
 ## DGX Models

+## DG1 (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.elphapex.daoge.DGX.DG1.ElphapexDG1
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
 ## DG1+ (Stock)

 - [ ] Shutdowns
@@ -14,3 +27,16 @@
        show_root_heading: false
        heading_level: 0

+## DG1Home (Stock)
+
+- [ ] Shutdowns
+- [ ] Power Modes
+- [ ] Setpoints
+- [ ] Presets
+
+::: pyasic.miners.elphapex.daoge.DGX.DG1.ElphapexDG1Home
+    handler: python
+    options:
+        show_root_heading: false
+        heading_level: 0
+
--- a/docs/miners/supported_types.md
+++ b/docs/miners/supported_types.md
@@ -86,6 +86,8 @@ details {
                    <li><a href="../antminer/X19#s19j-no-pic-stock">S19j No PIC (Stock)</a></li>
                    <li><a href="../antminer/X19#s19-pro_1-stock">S19 Pro+ (Stock)</a></li>
                    <li><a href="../antminer/X19#s19j-pro-stock">S19j Pro (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19j_1-stock">S19j+ (Stock)</a></li>
+                    <li><a href="../antminer/X19#s19j-pro_1-stock">S19j Pro+ (Stock)</a></li>
                    <li><a href="../antminer/X19#s19-xp-stock">S19 XP (Stock)</a></li>
                    <li><a href="../antminer/X19#s19a-stock">S19a (Stock)</a></li>
                    <li><a href="../antminer/X19#s19a-pro-stock">S19a Pro (Stock)</a></li>
@@ -103,6 +105,8 @@ details {
                    <li><a href="../antminer/X21#s21-stock">S21 (Stock)</a></li>
                    <li><a href="../antminer/X21#s21-stock">S21 (Stock)</a></li>
                    <li><a href="../antminer/X21#s21-stock">S21 (Stock)</a></li>
+                    <li><a href="../antminer/X21#s21_1-stock">S21+ (Stock)</a></li>
+                    <li><a href="../antminer/X21#s21_1-hydro-stock">S21+ Hydro (Stock)</a></li>
                    <li><a href="../antminer/X21#s21-pro-stock">S21 Pro (Stock)</a></li>
                    <li><a href="../antminer/X21#t21-stock">T21 (Stock)</a></li>
                    <li><a href="../antminer/X21#s21-hydro-stock">S21 Hydro (Stock)</a></li>
@@ -552,6 +556,7 @@ details {
            <summary>nano Series:</summary>
                <ul>
                    <li><a href="../avalonminer/nano#avalon-nano-3-stock">Avalon Nano 3 (Stock)</a></li>
+                    <li><a href="../avalonminer/nano#avalon-nano-3s-stock">Avalon Nano 3s (Stock)</a></li>
                </ul>
        </details>
        <details>
@@ -653,6 +658,7 @@ details {
                    <li><a href="../antminer/X19#s19-xp-bos_1">S19 XP (BOS+)</a></li>
                    <li><a href="../antminer/X19#s19-pro_1-hydro-bos_1">S19 Pro+ Hydro (BOS+)</a></li>
                    <li><a href="../antminer/X19#t19-bos_1">T19 (BOS+)</a></li>
+                    <li><a href="../antminer/X19#s19-xp-hydro-bos_1">S19 XP Hydro (BOS+)</a></li>
                </ul>
        </details>
        <details>
@@ -660,6 +666,9 @@ details {
                <ul>
                    <li><a href="../antminer/X21#s21-bos_1">S21 (BOS+)</a></li>
                    <li><a href="../antminer/X21#s21-pro-bos_1">S21 Pro (BOS+)</a></li>
+                    <li><a href="../antminer/X21#s21_1-bos_1">S21+ (BOS+)</a></li>
+                    <li><a href="../antminer/X21#s21_1-hydro-bos_1">S21+ Hydro (BOS+)</a></li>
+                    <li><a href="../antminer/X21#s21-hydro-bos_1">S21 Hydro (BOS+)</a></li>
                    <li><a href="../antminer/X21#t21-bos_1">T21 (BOS+)</a></li>
                </ul>
        </details>
@@ -688,6 +697,12 @@ details {
                    <li><a href="../antminer/X7#l7-vnish">L7 (VNish)</a></li>
                </ul>
        </details>
+        <details>
+            <summary>X9 Series:</summary>
+                <ul>
+                    <li><a href="../antminer/X9#l9-vnish">L9 (VNish)</a></li>
+                </ul>
+        </details>
        <details>
            <summary>X17 Series:</summary>
                <ul>
@@ -703,11 +718,15 @@ 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#s19i-vnish">S19i (VNish)</a></li>
+                    <li><a href="../antminer/X19#s19-xp-vnish">S19 XP (VNish)</a></li>
+                    <li><a href="../antminer/X19#s19-xp-hydro-vnish">S19 XP Hydro (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#s19j-pro-vnish">S19j Pro (VNish)</a></li>
                    <li><a href="../antminer/X19#s19a-vnish">S19a (VNish)</a></li>
+                    <li><a href="../antminer/X19#s19-hydro-vnish">S19 Hydro (VNish)</a></li>
                    <li><a href="../antminer/X19#s19a-pro-vnish">S19a Pro (VNish)</a></li>
+                    <li><a href="../antminer/X19#s19-pro-a-vnish">S19 Pro A (VNish)</a></li>
                    <li><a href="../antminer/X19#s19-pro-hydro-vnish">S19 Pro Hydro (VNish)</a></li>
                    <li><a href="../antminer/X19#s19k-pro-vnish">S19k Pro (VNish)</a></li>
                    <li><a href="../antminer/X19#t19-vnish">T19 (VNish)</a></li>
@@ -718,6 +737,10 @@ details {
                <ul>
                    <li><a href="../antminer/X21#t21-vnish">T21 (VNish)</a></li>
                    <li><a href="../antminer/X21#s21-vnish">S21 (VNish)</a></li>
+                    <li><a href="../antminer/X21#s21_1-vnish">S21+ (VNish)</a></li>
+                    <li><a href="../antminer/X21#s21_1-hydro-vnish">S21+ Hydro (VNish)</a></li>
+                    <li><a href="../antminer/X21#s21-pro-vnish">S21 Pro (VNish)</a></li>
+                    <li><a href="../antminer/X21#s21-hydro-vnish">S21 Hydro (VNish)</a></li>
                </ul>
        </details>
    </ul>
@@ -736,6 +759,7 @@ details {
                    <li><a href="../antminer/X19#s19k-pro-epic">S19k Pro (ePIC)</a></li>
                    <li><a href="../antminer/X19#s19-xp-epic">S19 XP (ePIC)</a></li>
                    <li><a href="../antminer/X19#s19j-pro-dual-epic">S19j Pro Dual (ePIC)</a></li>
+                    <li><a href="../antminer/X19#s19k-pro-dual-epic">S19k Pro Dual (ePIC)</a></li>
                </ul>
        </details>
        <details>
@@ -751,6 +775,7 @@ details {
                <ul>
                    <li><a href="../blockminer/blockminer#blockminer-520i-epic">BlockMiner 520i (ePIC)</a></li>
                    <li><a href="../blockminer/blockminer#blockminer-720i-epic">BlockMiner 720i (ePIC)</a></li>
+                    <li><a href="../blockminer/blockminer#blockminer-elite-1.0-epic">BlockMiner eLITE 1.0 (ePIC)</a></li>
                </ul>
        </details>
    </ul>
@@ -769,6 +794,7 @@ details {
                <ul>
                    <li><a href="../antminer/X19#s19j-pro-hive">S19j Pro (Hive)</a></li>
                    <li><a href="../antminer/X19#s19-hive">S19 (Hive)</a></li>
+                    <li><a href="../antminer/X19#s19k-pro-hive">S19K Pro (Hive)</a></li>
                    <li><a href="../antminer/X19#s19-no-pic-hive">S19 No PIC (Hive)</a></li>
                </ul>
        </details>
@@ -810,6 +836,7 @@ details {
            <summary>X21 Series:</summary>
                <ul>
                    <li><a href="../antminer/X21#s21-luxos">S21 (LuxOS)</a></li>
+                    <li><a href="../antminer/X21#t21-luxos">T21 (LuxOS)</a></li>
                </ul>
        </details>
    </ul>
@@ -908,6 +935,12 @@ details {
                    <li><a href="../iceriver/KSX#ks5m-stock">KS5M (Stock)</a></li>
                </ul>
        </details>
+        <details>
+            <summary>ALX Series:</summary>
+                <ul>
+                    <li><a href="../iceriver/ALX#al3-stock">AL3 (Stock)</a></li>
+                </ul>
+        </details>
    </ul>
 </details>
 <details>
@@ -939,6 +972,8 @@ details {
            <summary>DGX Series:</summary>
                <ul>
                    <li><a href="../elphapex/DGX#dg1_1-stock">DG1+ (Stock)</a></li>
+                    <li><a href="../elphapex/DGX#dg1-stock">DG1 (Stock)</a></li>
+                    <li><a href="../elphapex/DGX#dg1home-stock">DG1Home (Stock)</a></li>
                </ul>
        </details>
    </ul>
--- a/poetry.lock
+++ b/poetry.lock
--- a/pyasic/config/init.py
+++ b/pyasic/config/init.py
@@ -56,6 +56,16 @@ class MinerConfig(BaseModel):
            **self.temperature.as_am_modern(),
        }

+    def as_hiveon_modern(self, user_suffix: str | None = None) -> dict:
+        """Generates the configuration in the format suitable for modern Hiveon."""
+        return {
+            **self.fan_mode.as_hiveon_modern(),
+            "freq-level": "100",
+            **self.mining_mode.as_hiveon_modern(),
+            **self.pools.as_hiveon_modern(user_suffix=user_suffix),
+            **self.temperature.as_hiveon_modern(),
+        }
+
    def as_elphapex(self, user_suffix: str | None = None) -> dict:
        """Generates the configuration in the format suitable for modern Elphapex."""
        return {
@@ -209,6 +219,15 @@ class MinerConfig(BaseModel):
            fan_mode=FanModeConfig.from_am_modern(web_conf),
        )

+    @classmethod
+    def from_hiveon_modern(cls, web_conf: dict) -> "MinerConfig":
+        """Constructs a MinerConfig object from web configuration for Hiveon."""
+        return cls(
+            pools=PoolConfig.from_hiveon_modern(web_conf),
+            mining_mode=MiningModeConfig.from_hiveon_modern(web_conf),
+            fan_mode=FanModeConfig.from_hiveon_modern(web_conf),
+        )
+
    @classmethod
    def from_elphapex(cls, web_conf: dict) -> "MinerConfig":
        """Constructs a MinerConfig object from web configuration for modern Antminers."""
@@ -264,13 +283,17 @@ class MinerConfig(BaseModel):
        )

    @classmethod
-    def from_vnish(cls, web_settings: dict, web_presets: list[dict]) -> "MinerConfig":
+    def from_vnish(
+        cls, web_settings: dict, web_presets: list[dict], web_perf_summary: dict
+    ) -> "MinerConfig":
        """Constructs a MinerConfig object from web settings for VNish miners."""
        return cls(
            pools=PoolConfig.from_vnish(web_settings),
            fan_mode=FanModeConfig.from_vnish(web_settings),
            temperature=TemperatureConfig.from_vnish(web_settings),
-            mining_mode=MiningModeConfig.from_vnish(web_settings, web_presets),
+            mining_mode=MiningModeConfig.from_vnish(
+                web_settings, web_presets, web_perf_summary
+            ),
        )

    @classmethod
@@ -327,7 +350,3 @@ class MinerConfig(BaseModel):
    @classmethod
    def from_hammer(cls, *args, **kwargs) -> "MinerConfig":
        return cls.from_am_modern(*args, **kwargs)
-
-    @classmethod
-    def from_hiveon_modern(cls, web_conf: dict) -> "MinerConfig":
-        return cls.from_am_modern(web_conf)
--- a/pyasic/config/base.py
+++ b/pyasic/config/base.py
@@ -28,6 +28,9 @@ class MinerConfigOption(Enum):
    def as_am_modern(self) -> dict:
        return self.value.as_am_modern()

+    def as_hiveon_modern(self) -> dict:
+        return self.value.as_hiveon_modern()
+
    def as_am_old(self) -> dict:
        return self.value.as_am_old()

@@ -95,6 +98,9 @@ class MinerConfigValue(BaseModel):
    def as_am_modern(self) -> dict:
        return {}

+    def as_hiveon_modern(self) -> dict:
+        return {}
+
    def as_am_old(self) -> dict:
        return {}

--- a/pyasic/config/fans.py
+++ b/pyasic/config/fans.py
@@ -55,6 +55,9 @@ class FanModeNormal(MinerConfigValue):
    def as_am_modern(self) -> dict:
        return {"bitmain-fan-ctrl": False, "bitmain-fan-pwn": "100"}

+    def as_hiveon_modern(self) -> dict:
+        return {"bitmain-fan-ctrl": False, "bitmain-fan-pwn": "100"}
+
    def as_elphapex(self) -> dict:
        return {"fc-fan-ctrl": False, "fc-fan-pwn": "100"}

@@ -138,6 +141,9 @@ class FanModeManual(MinerConfigValue):
    def as_am_modern(self) -> dict:
        return {"bitmain-fan-ctrl": True, "bitmain-fan-pwm": str(self.speed)}

+    def as_hiveon_modern(self) -> dict:
+        return {"bitmain-fan-ctrl": True, "bitmain-fan-pwm": str(self.speed)}
+
    def as_elphapex(self) -> dict:
        return {"fc-fan-ctrl": True, "fc-fan-pwm": str(self.speed)}

@@ -191,6 +197,9 @@ class FanModeImmersion(MinerConfigValue):
    def as_am_modern(self) -> dict:
        return {"bitmain-fan-ctrl": True, "bitmain-fan-pwm": "0"}

+    def as_hiveon_modern(self) -> dict:
+        return {"bitmain-fan-ctrl": True, "bitmain-fan-pwm": "0"}
+
    def as_elphapex(self) -> dict:
        return {"fc-fan-ctrl": True, "fc-fan-pwm": "0"}

@@ -248,6 +257,20 @@ class FanModeConfig(MinerConfigOption):
        else:
            return cls.default()

+    @classmethod
+    def from_hiveon_modern(cls, web_conf: dict):
+        if web_conf.get("bitmain-fan-ctrl") is not None:
+            fan_manual = web_conf["bitmain-fan-ctrl"]
+            if fan_manual:
+                speed = int(web_conf["bitmain-fan-pwm"])
+                if speed == 0:
+                    return cls.immersion()
+                return cls.manual(speed=speed)
+            else:
+                return cls.normal()
+        else:
+            return cls.default()
+
    @classmethod
    def from_elphapex(cls, web_conf: dict):
        if web_conf.get("fc-fan-ctrl") is not None:
--- a/pyasic/config/mining/init.py
+++ b/pyasic/config/mining/init.py
@@ -52,6 +52,11 @@ class MiningModeNormal(MinerConfigValue):
            return {"miner-mode": "0"}
        return {"miner-mode": 0}

+    def as_hiveon_modern(self) -> dict:
+        if settings.get("antminer_mining_mode_as_str", False):
+            return {"miner-mode": "0"}
+        return {"miner-mode": 0}
+
    def as_elphapex(self) -> dict:
        return {"miner-mode": 0}

@@ -77,6 +82,9 @@ class MiningModeNormal(MinerConfigValue):
    def as_luxos(self) -> dict:
        return {"autotunerset": {"enabled": False}}

+    def as_bosminer(self) -> dict:
+        return {"autotuning": {"enabled": True}}
+

 class MiningModeSleep(MinerConfigValue):
    mode: str = field(init=False, default="sleep")
@@ -90,6 +98,11 @@ class MiningModeSleep(MinerConfigValue):
            return {"miner-mode": "1"}
        return {"miner-mode": 1}

+    def as_hiveon_modern(self) -> dict:
+        if settings.get("antminer_mining_mode_as_str", False):
+            return {"miner-mode": "1"}
+        return {"miner-mode": 1}
+
    def as_elphapex(self) -> dict:
        return {"miner-mode": 1}

@@ -125,6 +138,11 @@ class MiningModeLPM(MinerConfigValue):
            return {"miner-mode": "3"}
        return {"miner-mode": 3}

+    def as_hiveon_modern(self) -> dict:
+        if settings.get("antminer_mining_mode_as_str", False):
+            return {"miner-mode": "3"}
+        return {"miner-mode": 3}
+
    def as_elphapex(self) -> dict:
        return {"miner-mode": 3}

@@ -150,6 +168,11 @@ class MiningModeHPM(MinerConfigValue):
            return {"miner-mode": "0"}
        return {"miner-mode": 0}

+    def as_hiveon_modern(self) -> dict:
+        if settings.get("antminer_mining_mode_as_str", False):
+            return {"miner-mode": "0"}
+        return {"miner-mode": 0}
+
    def as_elphapex(self) -> dict:
        return {"miner-mode": 0}

@@ -186,6 +209,11 @@ class MiningModePowerTune(MinerConfigValue):
            return {"miner-mode": "0"}
        return {"miner-mode": 0}

+    def as_hiveon_modern(self) -> dict:
+        if settings.get("antminer_mining_mode_as_str", False):
+            return {"miner-mode": "0"}
+        return {"miner-mode": 0}
+
    def as_elphapex(self) -> dict:
        return {"miner-mode": 0}

@@ -230,18 +258,18 @@ class MiningModePowerTune(MinerConfigValue):
            sd_cfg = {}
            if self.scaling.shutdown is not None:
                sd_cfg = self.scaling.shutdown.as_boser()
-            cfg["set_dps"] = (
-                SetDpsRequest(
-                    enable=True,
-                    **sd_cfg,
-                    target=DpsTarget(
-                        power_target=DpsPowerTarget(
-                            power_step=Power(self.scaling.step),
-                            min_power_target=Power(self.scaling.minimum),
-                        )
-                    ),
-                ),
+            power_target_kwargs = {}
+            if self.scaling.step is not None:
+                power_target_kwargs["power_step"] = Power(self.scaling.step)
+            if self.scaling.minimum is not None:
+                power_target_kwargs["min_power_target"] = Power(self.scaling.minimum)
+            cfg["set_dps"] = SetDpsRequest(
+                save_action=SaveAction.SAVE_AND_APPLY,
+                enable=True,
+                **sd_cfg,
+                target=DpsTarget(power_target=DpsPowerTarget(**power_target_kwargs)),
            )
+
        return cfg

    def as_auradine(self) -> dict:
@@ -288,6 +316,11 @@ class MiningModeHashrateTune(MinerConfigValue):
            return {"miner-mode": "0"}
        return {"miner-mode": 0}

+    def as_hiveon_modern(self) -> dict:
+        if settings.get("antminer_mining_mode_as_str", False):
+            return {"miner-mode": "0"}
+        return {"miner-mode": 0}
+
    def as_elphapex(self) -> dict:
        return {"miner-mode": 0}

@@ -297,7 +330,6 @@ class MiningModeHashrateTune(MinerConfigValue):
            conf["hashrate_target"] = self.hashrate
        return {"autotuning": conf}

-    @property
    def as_boser(self) -> dict:
        cfg = {
            "set_performance_mode": SetPerformanceModeRequest(
@@ -317,18 +349,24 @@ class MiningModeHashrateTune(MinerConfigValue):
            sd_cfg = {}
            if self.scaling.shutdown is not None:
                sd_cfg = self.scaling.shutdown.as_boser()
-            cfg["set_dps"] = (
-                SetDpsRequest(
-                    enable=True,
-                    **sd_cfg,
-                    target=DpsTarget(
-                        hashrate_target=DpsHashrateTarget(
-                            hashrate_step=TeraHashrate(self.scaling.step),
-                            min_hashrate_target=TeraHashrate(self.scaling.minimum),
-                        )
-                    ),
+            hashrate_target_kwargs = {}
+            if self.scaling.step is not None:
+                hashrate_target_kwargs["hashrate_step"] = TeraHashrate(
+                    self.scaling.step
+                )
+            if self.scaling.minimum is not None:
+                hashrate_target_kwargs["min_hashrate_target"] = TeraHashrate(
+                    self.scaling.minimum
+                )
+            cfg["set_dps"] = SetDpsRequest(
+                save_action=SaveAction.SAVE_AND_APPLY,
+                enable=True,
+                **sd_cfg,
+                target=DpsTarget(
+                    hashrate_target=DpsHashrateTarget(**hashrate_target_kwargs)
                ),
            )
+
        return cfg

    def as_auradine(self) -> dict:
@@ -374,24 +412,28 @@ class MiningModePreset(MinerConfigValue):

    @classmethod
    def from_vnish(
-        cls, web_overclock_settings: dict, web_presets: list[dict]
+        cls,
+        web_overclock_settings: dict,
+        web_presets: list[dict],
+        web_perf_summary: dict,
    ) -> "MiningModePreset":
-        active_preset = None
-        for preset in web_presets:
-            if preset["name"] == web_overclock_settings["preset"]:
-                active_preset = preset
+        active_preset = web_perf_summary.get("current_preset")
+
+        if active_preset is None:
+            for preset in web_presets:
+                if preset["name"] == web_overclock_settings["preset"]:
+                    active_preset = preset
+
        return cls(
            active_preset=MiningPreset.from_vnish(active_preset),
            available_presets=[MiningPreset.from_vnish(p) for p in web_presets],
        )

    @classmethod
-    def from_luxos(
-        cls, rpc_config: dict, rpc_profiles: list[dict]
-    ) -> "MiningModePreset":
+    def from_luxos(cls, rpc_config: dict, rpc_profiles: dict) -> "MiningModePreset":
        active_preset = cls.get_active_preset_from_luxos(rpc_config, rpc_profiles)
        return cls(
-            active_preset=MiningPreset.from_luxos(active_preset),
+            active_preset=active_preset,
            available_presets=[
                MiningPreset.from_luxos(p) for p in rpc_profiles["PROFILES"]
            ],
@@ -399,14 +441,14 @@ class MiningModePreset(MinerConfigValue):

    @classmethod
    def get_active_preset_from_luxos(
-        cls, rpc_config: dict, rpc_profiles: list[dict]
-    ) -> dict:
+        cls, rpc_config: dict, rpc_profiles: dict
+    ) -> MiningPreset:
        active_preset = None
        active_profile = rpc_config["CONFIG"][0]["Profile"]
        for profile in rpc_profiles["PROFILES"]:
            if profile["Profile Name"] == active_profile:
                active_preset = profile
-        return active_preset
+        return MiningPreset.from_luxos(active_preset)


 class ManualBoardSettings(MinerConfigValue):
@@ -422,6 +464,11 @@ class ManualBoardSettings(MinerConfigValue):
            return {"miner-mode": "0"}
        return {"miner-mode": 0}

+    def as_hiveon_modern(self) -> dict:
+        if settings.get("antminer_mining_mode_as_str", False):
+            return {"miner-mode": "0"}
+        return {"miner-mode": 0}
+
    def as_elphapex(self) -> dict:
        return {"miner-mode": 0}

@@ -549,6 +596,20 @@ class MiningModeConfig(MinerConfigOption):
                return cls.low()
        return cls.default()

+    @classmethod
+    def from_hiveon_modern(cls, web_conf: dict):
+        if web_conf.get("bitmain-work-mode") is not None:
+            work_mode = web_conf["bitmain-work-mode"]
+            if work_mode == "":
+                return cls.default()
+            if int(work_mode) == 0:
+                return cls.normal()
+            elif int(work_mode) == 1:
+                return cls.sleep()
+            elif int(work_mode) == 3:
+                return cls.low()
+        return cls.default()
+
    @classmethod
    def from_elphapex(cls, web_conf: dict):
        if web_conf.get("fc-work-mode") is not None:
@@ -645,9 +706,12 @@ class MiningModeConfig(MinerConfigOption):
                return cls.hashrate_tuning(
                    scaling=ScalingConfig.from_bosminer(toml_conf, mode="hashrate"),
                )
+        return cls.default()

    @classmethod
-    def from_vnish(cls, web_settings: dict, web_presets: list[dict]):
+    def from_vnish(
+        cls, web_settings: dict, web_presets: list[dict], web_perf_summary: dict
+    ):
        try:
            mode_settings = web_settings["miner"]["overclock"]
        except KeyError:
@@ -656,7 +720,9 @@ class MiningModeConfig(MinerConfigOption):
        if mode_settings["preset"] == "disabled":
            return MiningModeManual.from_vnish(mode_settings)
        else:
-            return MiningModePreset.from_vnish(mode_settings, web_presets)
+            return MiningModePreset.from_vnish(
+                mode_settings, web_presets, web_perf_summary
+            )

    @classmethod
    def from_boser(cls, grpc_miner_conf: dict):
--- a/pyasic/config/pools.py
+++ b/pyasic/config/pools.py
@@ -43,6 +43,13 @@ class Pool(MinerConfigValue):
            "pass": self.password,
        }

+    def as_hiveon_modern(self, user_suffix: str | None = None) -> dict:
+        return {
+            "url": self.url,
+            "user": f"{self.user}{user_suffix or ''}",
+            "pass": self.password,
+        }
+
    def as_elphapex(self, user_suffix: str | None = None) -> dict:
        return {
            "url": self.url,
@@ -153,6 +160,12 @@ class Pool(MinerConfigValue):
            url=web_pool["url"], user=web_pool["user"], password=web_pool["pass"]
        )

+    @classmethod
+    def from_hiveon_modern(cls, web_pool: dict) -> "Pool":
+        return cls(
+            url=web_pool["url"], user=web_pool["user"], password=web_pool["pass"]
+        )
+
    @classmethod
    def from_elphapex(cls, web_pool: dict) -> "Pool":
        return cls(
@@ -177,7 +190,7 @@ class Pool(MinerConfigValue):
        return cls(
            url=toml_pool_conf["url"],
            user=toml_pool_conf["user"],
-            password=toml_pool_conf["password"],
+            password=toml_pool_conf.get("password", ""),
        )

    @classmethod
@@ -248,6 +261,17 @@ class PoolGroup(MinerConfigValue):
            idx += 1
        return pools

+    def as_hiveon_modern(self, user_suffix: str | None = None) -> list:
+        pools = []
+        idx = 0
+        while idx < 3:
+            if len(self.pools) > idx:
+                pools.append(self.pools[idx].as_hiveon_modern(user_suffix=user_suffix))
+            else:
+                pools.append(Pool(url="", user="", password="").as_hiveon_modern())
+            idx += 1
+        return pools
+
    def as_elphapex(self, user_suffix: str | None = None) -> list:
        pools = []
        idx = 0
@@ -375,6 +399,13 @@ class PoolGroup(MinerConfigValue):
            pools.append(Pool.from_am_modern(pool))
        return cls(pools=pools)

+    @classmethod
+    def from_hiveon_modern(cls, web_pool_list: list) -> "PoolGroup":
+        pools = []
+        for pool in web_pool_list:
+            pools.append(Pool.from_hiveon_modern(pool))
+        return cls(pools=pools)
+
    @classmethod
    def from_elphapex(cls, web_pool_list: list) -> "PoolGroup":
        pools = []
@@ -467,6 +498,11 @@ class PoolConfig(MinerConfigValue):
            return {"pools": self.groups[0].as_am_modern(user_suffix=user_suffix)}
        return {"pools": PoolGroup().as_am_modern()}

+    def as_hiveon_modern(self, user_suffix: str | None = None) -> dict:
+        if len(self.groups) > 0:
+            return {"pools": self.groups[0].as_hiveon_modern(user_suffix=user_suffix)}
+        return {"pools": PoolGroup().as_hiveon_modern()}
+
    def as_elphapex(self, user_suffix: str | None = None) -> dict:
        if len(self.groups) > 0:
            return {"pools": self.groups[0].as_elphapex(user_suffix=user_suffix)}
@@ -569,10 +605,22 @@ class PoolConfig(MinerConfigValue):

    @classmethod
    def from_am_modern(cls, web_conf: dict) -> "PoolConfig":
-        pool_data = web_conf["pools"]
+        try:
+            pool_data = web_conf["pools"]
+        except KeyError:
+            return cls(groups=[])

        return cls(groups=[PoolGroup.from_am_modern(pool_data)])

+    @classmethod
+    def from_hiveon_modern(cls, web_conf: dict) -> "PoolConfig":
+        try:
+            pool_data = web_conf["pools"]
+        except KeyError:
+            return cls(groups=[])
+
+        return cls(groups=[PoolGroup.from_hiveon_modern(pool_data)])
+
    @classmethod
    def from_elphapex(cls, web_conf: dict) -> "PoolConfig":
        pool_data = web_conf["pools"]
--- a/pyasic/data/init.py
+++ b/pyasic/data/init.py
@@ -16,7 +16,7 @@
 import copy
 import time
 from datetime import datetime, timezone
-from typing import Any, List, Union
+from typing import Any

 from pydantic import BaseModel, Field, computed_field

@@ -28,6 +28,7 @@ from pyasic.device.algorithm.hashrate import AlgoHashRateType
 from .boards import HashBoard
 from .device import DeviceInfo
 from .error_codes import BraiinsOSError, InnosiliconError, WhatsminerError, X19Error
+from .error_codes.base import BaseMinerError
 from .fans import Fan


@@ -69,6 +70,7 @@ class MinerData(BaseModel):
        errors: A list of errors on the miner.
        fault_light: Whether the fault light is on as a boolean.
        efficiency: Efficiency of the miner in J/TH (Watts per TH/s).  Calculated automatically.
+        efficiency_fract: Same as efficiency, but is not rounded to integer.  Calculated automatically.
        is_mining: Whether the miner is mining.
        pools: A list of PoolMetrics instances, each representing metrics for a pool.
    """
@@ -107,25 +109,18 @@ class MinerData(BaseModel):
    raw_wattage_limit: int | None = Field(exclude=True, default=None, repr=False)

    # fans
-    fans: List[Fan] = Field(default_factory=list)
+    fans: list[Fan] = Field(default_factory=list)
    fan_psu: int | None = None

    # boards
-    hashboards: List[HashBoard] = Field(default_factory=list)
+    hashboards: list[HashBoard] = Field(default_factory=list)

    # config
    config: MinerConfig | None = None
    fault_light: bool | None = None

    # errors
-    errors: List[
-        Union[
-            WhatsminerError,
-            BraiinsOSError,
-            X19Error,
-            InnosiliconError,
-        ]
-    ] = Field(default_factory=list)
+    errors: list[BaseMinerError] = Field(default_factory=list)

    # mining state
    is_mining: bool = True
@@ -135,8 +130,10 @@ class MinerData(BaseModel):
    pools: list[PoolMetrics] = Field(default_factory=list)

    @classmethod
-    def fields(cls):
-        return list(cls.model_fields.keys())
+    def fields(cls) -> set:
+        all_fields = set(cls.model_fields.keys())
+        all_fields.update(set(cls.model_computed_fields.keys()))
+        return all_fields

    def get(self, __key: str, default: Any = None):
        try:
@@ -288,12 +285,24 @@ class MinerData(BaseModel):
    @computed_field  # type: ignore[misc]
    @property
    def efficiency(self) -> int | None:
+        efficiency = self._efficiency(0)
+        if efficiency is None:
+            return None
+        else:
+            return int(efficiency)
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def efficiency_fract(self) -> float | None:
+        return self._efficiency(2)
+
+    def _efficiency(self, ndigits: int) -> float | None:
        if self.hashrate is None or self.wattage is None:
            return None
        try:
-            return round(self.wattage / float(self.hashrate))
+            return round(self.wattage / float(self.hashrate), ndigits)
        except ZeroDivisionError:
-            return 0
+            return 0.0

    @computed_field  # type: ignore[misc]
    @property
@@ -307,25 +316,25 @@ class MinerData(BaseModel):

    @computed_field  # type: ignore[misc]
    @property
-    def make(self) -> str:
+    def make(self) -> str | None:
        if self.device_info.make is not None:
            return str(self.device_info.make)

    @computed_field  # type: ignore[misc]
    @property
-    def model(self) -> str:
+    def model(self) -> str | None:
        if self.device_info.model is not None:
            return str(self.device_info.model)

    @computed_field  # type: ignore[misc]
    @property
-    def firmware(self) -> str:
+    def firmware(self) -> str | None:
        if self.device_info.firmware is not None:
            return str(self.device_info.firmware)

    @computed_field  # type: ignore[misc]
    @property
-    def algo(self) -> str:
+    def algo(self) -> str | None:
        if self.device_info.algo is not None:
            return str(self.device_info.algo)

@@ -365,7 +374,9 @@ class MinerData(BaseModel):
        data_list = [str(data[item]) for item in data]
        return ",".join(data_list)

-    def as_influxdb(self, measurement_name: str = "miner_data") -> str:
+    def as_influxdb(
+        self, measurement_name: str = "miner_data", level_delimiter: str = "."
+    ) -> str:
        """Get this dataclass as [influxdb line protocol](https://docs.influxdata.com/influxdb/v2.4/reference/syntax/line-protocol/).

        Parameters:
@@ -374,54 +385,127 @@ class MinerData(BaseModel):
        Returns:
            A influxdb line protocol version of this class.
        """
-        tag_data = [measurement_name]
+
+        def serialize_int(key: str, value: int) -> str:
+            return f"{key}={value}"
+
+        def serialize_float(key: str, value: float) -> str:
+            return f"{key}={value}"
+
+        def serialize_str(key: str, value: str) -> str:
+            return f'{key}="{value}"'
+
+        def serialize_algo_hash_rate(key: str, value: AlgoHashRateType) -> str:
+            return f"{key}={round(float(value), 2)}"
+
+        def serialize_list(key: str, value: list[Any]) -> str | None:
+            if len(value) == 0:
+                return None
+
+            list_field_data = []
+            for idx, list_field_val in enumerate(value):
+                item_serialization_func = serialization_map.get(
+                    type(list_field_val), lambda _k, _v: None
+                )
+                item_serialized = item_serialization_func(
+                    f"{key}{level_delimiter}{idx}", list_field_val
+                )
+                if item_serialized is not None:
+                    list_field_data.append(item_serialized)
+                    continue
+                for dt in serialization_map_instance:
+                    if item_serialized is None:
+                        if isinstance(list_field_val, dt):
+                            item_serialized = serialization_map_instance[dt](
+                                f"{key}{level_delimiter}{idx}", list_field_val
+                            )
+                if item_serialized is not None:
+                    list_field_data.append(item_serialized)
+            return ",".join(list_field_data)
+
+        def serialize_miner_error(key: str, value: BaseMinerError):
+            return value.as_influxdb(key, level_delimiter=level_delimiter)
+
+        def serialize_fan(key: str, value: Fan) -> str:
+            return f"{key}{level_delimiter}speed={value.speed}"
+
+        def serialize_hashboard(key: str, value: HashBoard) -> str:
+            return value.as_influxdb(key, level_delimiter=level_delimiter)
+
+        def serialize_bool(key: str, value: bool):
+            return f"{key}={str(value).lower()}"
+
+        def serialize_pool_metrics(key: str, value: PoolMetrics):
+            return value.as_influxdb(key, level_delimiter=level_delimiter)
+
+        include = [
+            "uptime",
+            "expected_hashrate",
+            "hashrate",
+            "hashboards",
+            "temperature_avg",
+            "env_temp",
+            "wattage",
+            "wattage_limit",
+            "voltage",
+            "fans",
+            "expected_fans",
+            "fan_psu",
+            "total_chips",
+            "expected_chips",
+            "efficiency",
+            "fault_light",
+            "is_mining",
+            "errors",
+            "pools",
+        ]
+
+        serialization_map_instance = {
+            AlgoHashRateType: serialize_algo_hash_rate,
+            BaseMinerError: serialize_miner_error,
+        }
+        serialization_map = {
+            int: serialize_int,
+            float: serialize_float,
+            str: serialize_str,
+            bool: serialize_bool,
+            list: serialize_list,
+            Fan: serialize_fan,
+            HashBoard: serialize_hashboard,
+            PoolMetrics: serialize_pool_metrics,
+        }
+
+        tag_data = [
+            measurement_name,
+            f"ip={str(self.ip)}",
+            f"mac={str(self.mac)}",
+            f"make={str(self.make)}",
+            f"model={str(self.model)}",
+            f"firmware={str(self.firmware)}",
+            f"algo={str(self.algo)}",
+        ]
        field_data = []

-        tags = ["ip", "mac", "model", "hostname"]
-        for attribute in self.fields():
-            if attribute in tags:
-                escaped_data = self.get(attribute, "Unknown").replace(" ", "\\ ")
-                tag_data.append(f"{attribute}={escaped_data}")
+        for field in include:
+            field_val = getattr(self, field)
+            serialization_func = serialization_map.get(
+                type(field_val), lambda _k, _v: None
+            )
+            serialized = serialization_func(field, field_val)
+            if serialized is not None:
+                field_data.append(serialized)
                continue
-            elif str(attribute).startswith("_"):
-                continue
-            elif isinstance(self[attribute], str):
-                field_data.append(f'{attribute}="{self[attribute]}"')
-                continue
-            elif isinstance(self[attribute], bool):
-                field_data.append(f"{attribute}={str(self[attribute]).lower()}")
-                continue
-            elif isinstance(self[attribute], int):
-                field_data.append(f"{attribute}={self[attribute]}")
-                continue
-            elif isinstance(self[attribute], float):
-                field_data.append(f"{attribute}={self[attribute]}")
-                continue
-            elif attribute == "errors":
-                for idx, item in enumerate(self[attribute]):
-                    field_data.append(f'error_{idx+1}="{item.error_message}"')
-            elif attribute == "hashboards":
-                for idx, item in enumerate(self[attribute]):
-                    field_data.append(
-                        f"hashboard_{idx+1}_hashrate={item.get('hashrate', 0.0)}"
-                    )
-                    field_data.append(
-                        f"hashboard_{idx+1}_temperature={item.get('temp', 0)}"
-                    )
-                    field_data.append(
-                        f"hashboard_{idx+1}_chip_temperature={item.get('chip_temp', 0)}"
-                    )
-                    field_data.append(f"hashboard_{idx+1}_chips={item.get('chips', 0)}")
-                    field_data.append(
-                        f"hashboard_{idx+1}_expected_chips={item.get('expected_chips', 0)}"
-                    )
-            elif attribute == "fans":
-                for idx, item in enumerate(self[attribute]):
-                    if item.speed is not None:
-                        field_data.append(f"fan_{idx+1}={item.speed}")
+            for datatype in serialization_map_instance:
+                if serialized is None:
+                    if isinstance(field_val, datatype):
+                        serialized = serialization_map_instance[datatype](
+                            field, field_val
+                        )
+            if serialized is not None:
+                field_data.append(serialized)

-        tags_str = ",".join(tag_data)
-        field_str = ",".join(field_data)
-        timestamp = str(self.timestamp * 1e9)
+        tags_str = ",".join(tag_data).replace(" ", "\\ ")
+        field_str = ",".join(field_data).replace(" ", "\\ ")
+        timestamp = str(self.timestamp * 10**9)

        return " ".join([tags_str, field_str, timestamp])
--- a/pyasic/data/boards.py
+++ b/pyasic/data/boards.py
@@ -28,6 +28,8 @@ class HashBoard(BaseModel):
    Attributes:
        slot: The slot of the board as an int.
        hashrate: The hashrate of the board in TH/s as a float.
+        inlet_temp: Inlet temperature for hydro asics as an int
+        outlet_temp: Outlet temperature for hydro asics as an int
        temp: The temperature of the PCB as an int.
        chip_temp: The temperature of the chips as an int.
        chips: The chip count of the board as an int.
@@ -41,6 +43,8 @@ class HashBoard(BaseModel):

    slot: int = 0
    hashrate: AlgoHashRateType | None = None
+    inlet_temp: float | None = None
+    outlet_temp: float | None = None
    temp: float | None = None
    chip_temp: float | None = None
    chips: int | None = None
@@ -51,6 +55,12 @@ class HashBoard(BaseModel):
    active: bool | None = None
    voltage: float | None = None

+    @classmethod
+    def fields(cls) -> set:
+        all_fields = set(cls.model_fields.keys())
+        all_fields.update(set(cls.model_computed_fields.keys()))
+        return all_fields
+
    def get(self, __key: str, default: Any = None):
        try:
            val = self.__getitem__(__key)
@@ -65,3 +75,63 @@ class HashBoard(BaseModel):
            return getattr(self, item)
        except AttributeError:
            raise KeyError(f"{item}")
+
+    def as_influxdb(self, key_root: str, level_delimiter: str = ".") -> str:
+
+        def serialize_int(key: str, value: int) -> str:
+            return f"{key}={value}"
+
+        def serialize_float(key: str, value: float) -> str:
+            return f"{key}={value}"
+
+        def serialize_str(key: str, value: str) -> str:
+            return f'{key}="{value}"'
+
+        def serialize_algo_hash_rate(key: str, value: AlgoHashRateType) -> str:
+            return f"{key}={round(float(value), 2)}"
+
+        def serialize_bool(key: str, value: bool):
+            return f"{key}={str(value).lower()}"
+
+        serialization_map_instance = {
+            AlgoHashRateType: serialize_algo_hash_rate,
+        }
+        serialization_map = {
+            int: serialize_int,
+            float: serialize_float,
+            str: serialize_str,
+            bool: serialize_bool,
+        }
+
+        include = [
+            "hashrate",
+            "temp",
+            "chip_temp",
+            "chips",
+            "expected_chips",
+            "tuned",
+            "active",
+            "voltage",
+        ]
+
+        field_data = []
+        for field in include:
+            field_val = getattr(self, field)
+            serialization_func = serialization_map.get(
+                type(field_val), lambda _k, _v: None
+            )
+            serialized = serialization_func(
+                f"{key_root}{level_delimiter}{field}", field_val
+            )
+            if serialized is not None:
+                field_data.append(serialized)
+                continue
+            for datatype in serialization_map_instance:
+                if serialized is None:
+                    if isinstance(field_val, datatype):
+                        serialized = serialization_map_instance[datatype](
+                            f"{key_root}{level_delimiter}{field}", field_val
+                        )
+            if serialized is not None:
+                field_data.append(serialized)
+        return ",".join(field_data)
--- a/pyasic/data/error_codes/base.py
+++ b/pyasic/data/error_codes/base.py
@@ -16,3 +16,17 @@ class BaseMinerError(BaseModel):
            A dictionary version of this class.
        """
        return self.asdict()
+
+    def as_influxdb(self, root_key: str, level_delimiter: str = ".") -> str:
+        field_data = []
+
+        if self.error_code is not None:
+            field_data.append(
+                f"{root_key}{level_delimiter}error_code={self.error_code}"
+            )
+        if self.error_message is not None:
+            field_data.append(
+                f'{root_key}{level_delimiter}error_message="{self.error_message}"'
+            )
+
+        return ",".join(field_data)
--- a/pyasic/data/pools.py
+++ b/pyasic/data/pools.py
@@ -92,3 +92,51 @@ class PoolMetrics(BaseModel):
        if total == 0:
            return 0
        return (value / total) * 100
+
+    def as_influxdb(self, key_root: str, level_delimiter: str = ".") -> str:
+
+        def serialize_int(key: str, value: int) -> str:
+            return f"{key}={value}"
+
+        def serialize_float(key: str, value: float) -> str:
+            return f"{key}={value}"
+
+        def serialize_str(key: str, value: str) -> str:
+            return f'{key}="{value}"'
+
+        def serialize_pool_url(key: str, value: str) -> str:
+            return f'{key}="{str(value)}"'
+
+        def serialize_bool(key: str, value: bool):
+            return f"{key}={str(value).lower()}"
+
+        serialization_map = {
+            int: serialize_int,
+            float: serialize_float,
+            str: serialize_str,
+            bool: serialize_bool,
+            PoolUrl: serialize_pool_url,
+        }
+
+        include = [
+            "url",
+            "accepted",
+            "rejected",
+            "active",
+            "alive",
+            "user",
+        ]
+
+        field_data = []
+        for field in include:
+            field_val = getattr(self, field)
+            serialization_func = serialization_map.get(
+                type(field_val), lambda _k, _v: None
+            )
+            serialized = serialization_func(
+                f"{key_root}{level_delimiter}{field}", field_val
+            )
+            if serialized is not None:
+                field_data.append(serialized)
+
+        return ",".join(field_data)
--- a/pyasic/device/algorithm/init.py
+++ b/pyasic/device/algorithm/init.py
@@ -1,5 +1,6 @@
 from .base import MinerAlgoType
 from .blake256 import Blake256Algo
+from .blockflow import BlockFlowAlgo
 from .eaglesong import EaglesongAlgo
 from .equihash import EquihashAlgo
 from .ethash import EtHashAlgo
@@ -24,3 +25,4 @@ class MinerAlgo:
    EAGLESONG = EaglesongAlgo
    ETHASH = EtHashAlgo
    EQUIHASH = EquihashAlgo
+    BLOCKFLOW = BlockFlowAlgo
--- a/pyasic/device/algorithm/blockflow.py
+++ b/pyasic/device/algorithm/blockflow.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .base import MinerAlgoType
+from .hashrate import BlockFlowHashRate
+from .hashrate.unit import BlockFlowUnit
+
+
+class BlockFlowAlgo(MinerAlgoType):
+    hashrate: type[BlockFlowHashRate] = BlockFlowHashRate
+    unit: type[BlockFlowUnit] = BlockFlowUnit
+
+    name = "BlockFlow"
--- a/pyasic/device/algorithm/hashrate/init.py
+++ b/pyasic/device/algorithm/hashrate/init.py
@@ -1,5 +1,6 @@
 from .base import AlgoHashRateType
 from .blake256 import Blake256HashRate
+from .blockflow import BlockFlowHashRate
 from .eaglesong import EaglesongHashRate
 from .equihash import EquihashHashRate
 from .ethash import EtHashHashRate
@@ -22,3 +23,4 @@ class AlgoHashRate:
    EAGLESONG = EaglesongHashRate
    ETHASH = EtHashHashRate
    EQUIHASH = EquihashHashRate
+    BLOCKFLOW = BlockFlowHashRate
--- a/pyasic/device/algorithm/hashrate/blockflow.py
+++ b/pyasic/device/algorithm/hashrate/blockflow.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing_extensions import Self
+
+from pyasic.device.algorithm.hashrate.base import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.unit.blockflow import BlockFlowUnit
+
+from .unit import HashUnit
+
+
+class BlockFlowHashRate(AlgoHashRateType):
+    rate: float
+    unit: BlockFlowUnit = HashUnit.BLOCKFLOW.default
+
+    def into(self, other: BlockFlowUnit) -> Self:
+        return self.__class__(
+            rate=self.rate / (other.value / self.unit.value), unit=other
+        )
--- a/pyasic/device/algorithm/hashrate/unit/init.py
+++ b/pyasic/device/algorithm/hashrate/unit/init.py
@@ -1,4 +1,5 @@
 from .blake256 import Blake256Unit
+from .blockflow import BlockFlowUnit
 from .eaglesong import EaglesongUnit
 from .equihash import EquihashUnit
 from .ethash import EtHashUnit
@@ -21,3 +22,4 @@ class HashUnit:
    EAGLESONG = EaglesongUnit
    ETHASH = EtHashUnit
    EQUIHASH = EquihashUnit
+    BLOCKFLOW = BlockFlowUnit
--- a/pyasic/device/algorithm/hashrate/unit/blockflow.py
+++ b/pyasic/device/algorithm/hashrate/unit/blockflow.py
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .base import AlgoHashRateUnitType
+
+
+class BlockFlowUnit(AlgoHashRateUnitType):
+    H = 1
+    KH = int(H) * 1000
+    MH = int(KH) * 1000
+    GH = int(MH) * 1000
+    TH = int(GH) * 1000
+    PH = int(TH) * 1000
+    EH = int(PH) * 1000
+    ZH = int(EH) * 1000
+
+    default = MH
--- a/pyasic/device/models.py
+++ b/pyasic/device/models.py
@@ -43,6 +43,7 @@ class AntminerModels(MinerModelType):
    S19jNoPIC = "S19j No PIC"
    S19ProPlus = "S19 Pro+"
    S19jPro = "S19j Pro"
+    S19jPlus = "S19j+"
    S19jProNoPIC = "S19j Pro No PIC"
    S19jProPlus = "S19j Pro+"
    S19jProPlusNoPIC = "S19j Pro+ No PIC"
@@ -54,13 +55,17 @@ class AntminerModels(MinerModelType):
    S19ProPlusHydro = "S19 Pro+ Hydro"
    S19KPro = "S19K Pro"
    S19kPro = "S19k Pro"
+    S19ProA = "S19 Pro A"
    S19kProNoPIC = "S19k Pro No PIC"
    S19jXP = "S19j XP"
    T19 = "T19"
    S21 = "S21"
+    S21Plus = "S21+"
+    S21PlusHydro = "S21+ Hydro"
    S21Pro = "S21 Pro"
    S21Hydro = "S21 Hydro"
    T21 = "T21"
+    S19XPHydro = "S19 XP Hydro"

    def __str__(self):
        return self.value
@@ -450,6 +455,7 @@ class AvalonminerModels(MinerModelType):
    Avalon1246 = "Avalon 1246"
    Avalon1566 = "Avalon 1566"
    AvalonNano3 = "Avalon Nano 3"
+    AvalonNano3s = "Avalon Nano 3s"

    def __str__(self):
        return self.value
@@ -480,7 +486,9 @@ class GoldshellModels(MinerModelType):
 class ePICModels(MinerModelType):
    BM520i = "BlockMiner 520i"
    BM720i = "BlockMiner 720i"
+    eLITE1 = "BlockMiner eLITE 1.0"
    S19jProDual = "S19j Pro Dual"
+    S19kProDual = "S19k Pro Dual"

    def __str__(self):
        return self.value
@@ -527,6 +535,7 @@ class IceRiverModels(MinerModelType):
    KS5 = "KS5"
    KS5L = "KS5L"
    KS5M = "KS5M"
+    AL3 = "AL3"

    def __str__(self):
        return self.value
@@ -552,7 +561,9 @@ class BraiinsModels(MinerModelType):


 class ElphapexModels(MinerModelType):
+    DG1 = "DG1"
    DG1Plus = "DG1+"
+    DG1Home = "DG1Home"


 class MinerModel:
--- a/pyasic/miners/antminer/bmminer/X19/S19.py
+++ b/pyasic/miners/antminer/bmminer/X19/S19.py
@@ -25,7 +25,9 @@ from pyasic.miners.device.models import (
    S19i,
    S19j,
    S19jNoPIC,
+    S19jPlus,
    S19jPro,
+    S19jProPlus,
    S19jXP,
    S19KPro,
    S19Plus,
@@ -80,6 +82,10 @@ class BMMinerS19jPro(AntminerModern, S19jPro):
    pass


+class BMMinerS19jPlus(AntminerModern, S19jPlus):
+    pass
+
+
 class BMMinerS19L(AntminerModern, S19L):
    pass

@@ -102,3 +108,7 @@ class BMMinerS19KPro(AntminerModern, S19KPro):

 class BMMinerS19jXP(AntminerModern, S19jXP):
    pass
+
+
+class BMMinerS19jProPlus(AntminerModern, S19jProPlus):
+    pass
--- a/pyasic/miners/antminer/bmminer/X19/init.py
+++ b/pyasic/miners/antminer/bmminer/X19/init.py
@@ -22,7 +22,9 @@ from .S19 import (
    BMMinerS19i,
    BMMinerS19j,
    BMMinerS19jNoPIC,
+    BMMinerS19jPlus,
    BMMinerS19jPro,
+    BMMinerS19jProPlus,
    BMMinerS19jXP,
    BMMinerS19KPro,
    BMMinerS19L,
--- a/pyasic/miners/antminer/bmminer/X21/S21.py
+++ b/pyasic/miners/antminer/bmminer/X21/S21.py
@@ -15,13 +15,21 @@
 # ------------------------------------------------------------------------------

 from pyasic.miners.backends import AntminerModern
-from pyasic.miners.device.models import S21, S21Hydro, S21Pro
+from pyasic.miners.device.models import S21, S21Hydro, S21Plus, S21PlusHydro, S21Pro


 class BMMinerS21(AntminerModern, S21):
    pass


+class BMMinerS21Plus(AntminerModern, S21Plus):
+    pass
+
+
+class BMMinerS21PlusHydro(AntminerModern, S21PlusHydro):
+    pass
+
+
 class BMMinerS21Pro(AntminerModern, S21Pro):
    pass

--- a/pyasic/miners/antminer/bmminer/X21/init.py
+++ b/pyasic/miners/antminer/bmminer/X21/init.py
@@ -13,5 +13,11 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from .S21 import BMMinerS21, BMMinerS21Hydro, BMMinerS21Pro
+from .S21 import (
+    BMMinerS21,
+    BMMinerS21Hydro,
+    BMMinerS21Plus,
+    BMMinerS21PlusHydro,
+    BMMinerS21Pro,
+)
 from .T21 import BMMinerT21
--- a/pyasic/miners/antminer/bosminer/X19/S19.py
+++ b/pyasic/miners/antminer/bosminer/X19/S19.py
@@ -30,6 +30,7 @@ from pyasic.miners.device.models import (
    S19Plus,
    S19Pro,
    S19ProPlusHydro,
+    S19XPHydro,
 )


@@ -87,3 +88,7 @@ class BOSMinerS19XP(BOSer, S19XP):

 class BOSMinerS19ProPlusHydro(BOSer, S19ProPlusHydro):
    pass
+
+
+class BOSMinerS19XPHydro(BOSer, S19XPHydro):
+    pass
--- a/pyasic/miners/antminer/bosminer/X19/init.py
+++ b/pyasic/miners/antminer/bosminer/X19/init.py
@@ -29,5 +29,6 @@ from .S19 import (
    BOSMinerS19Pro,
    BOSMinerS19ProPlusHydro,
    BOSMinerS19XP,
+    BOSMinerS19XPHydro,
 )
 from .T19 import BOSMinerT19
--- a/pyasic/miners/antminer/bosminer/X21/S21.py
+++ b/pyasic/miners/antminer/bosminer/X21/S21.py
@@ -15,12 +15,40 @@
 # ------------------------------------------------------------------------------

 from pyasic.miners.backends import BOSer
-from pyasic.miners.device.models import S21, S21Pro
+from pyasic.miners.device.models import S21, S21Hydro, S21Plus, S21PlusHydro, S21Pro
+
+# ------------------------------------------------------------------------------
+#  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.                                              -
+# ------------------------------------------------------------------------------


 class BOSMinerS21(BOSer, S21):
    pass


+class BOSMinerS21Plus(BOSer, S21Plus):
+    pass
+
+
+class BOSMinerS21PlusHydro(BOSer, S21PlusHydro):
+    pass
+
+
 class BOSMinerS21Pro(BOSer, S21Pro):
    pass
+
+
+class BOSMinerS21Hydro(BOSer, S21Hydro):
+    pass
--- a/pyasic/miners/antminer/bosminer/X21/init.py
+++ b/pyasic/miners/antminer/bosminer/X21/init.py
@@ -14,5 +14,11 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .S21 import BOSMinerS21, BOSMinerS21Pro
+from .S21 import (
+    BOSMinerS21,
+    BOSMinerS21Hydro,
+    BOSMinerS21Plus,
+    BOSMinerS21PlusHydro,
+    BOSMinerS21Pro,
+)
 from .T21 import BOSMinerT21
--- a/pyasic/miners/antminer/epic/X19/S19.py
+++ b/pyasic/miners/antminer/epic/X19/S19.py
@@ -59,3 +59,9 @@ class ePICS19jProDual(ePIC, S19jPro):
    raw_model = MinerModel.EPIC.S19jProDual
    expected_fans = S19jPro.expected_fans * 2
    expected_hashboards = S19jPro.expected_hashboards * 2
+
+
+class ePICS19kProDual(ePIC, S19kPro):
+    raw_model = MinerModel.EPIC.S19kProDual
+    expected_fans = S19kPro.expected_fans * 2
+    expected_hashboards = S19kPro.expected_hashboards * 2
--- a/pyasic/miners/antminer/epic/X19/init.py
+++ b/pyasic/miners/antminer/epic/X19/init.py
@@ -21,6 +21,7 @@ from .S19 import (
    ePICS19jProDual,
    ePICS19jProPlus,
    ePICS19kPro,
+    ePICS19kProDual,
    ePICS19Pro,
    ePICS19XP,
 )
--- a/pyasic/miners/antminer/hiveon/X19/S19.py
+++ b/pyasic/miners/antminer/hiveon/X19/S19.py
@@ -100,5 +100,5 @@ class HiveonS19ProPlusHydro(HiveonModern, S19ProPlusHydro):
    pass


-class HiveonS19KPro(HiveonModern, S19KPro):
+class HiveonS19kPro(HiveonModern, S19KPro):
    pass
--- a/pyasic/miners/antminer/hiveon/X19/init.py
+++ b/pyasic/miners/antminer/hiveon/X19/init.py
@@ -23,7 +23,7 @@ from .S19 import (
    HiveonS19j,
    HiveonS19jNoPIC,
    HiveonS19jPro,
-    HiveonS19KPro,
+    HiveonS19kPro,
    HiveonS19L,
    HiveonS19NoPIC,
    HiveonS19Plus,
--- a/pyasic/miners/antminer/luxos/X21/T21.py
+++ b/pyasic/miners/antminer/luxos/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 LUXMiner
+from pyasic.miners.device.models import S21, T21
+
+
+class LUXMinerT21(LUXMiner, T21):
+    pass
--- a/pyasic/miners/antminer/luxos/X21/init.py
+++ b/pyasic/miners/antminer/luxos/X21/init.py
@@ -15,3 +15,4 @@
 # ------------------------------------------------------------------------------

 from .S21 import LUXMinerS21
+from .T21 import LUXMinerT21
--- a/pyasic/miners/antminer/vnish/X19/S19.py
+++ b/pyasic/miners/antminer/vnish/X19/S19.py
@@ -20,13 +20,16 @@ from pyasic.miners.device.models import (
    S19XP,
    S19a,
    S19aPro,
+    S19Hydro,
    S19i,
    S19j,
    S19jPro,
    S19kPro,
    S19NoPIC,
    S19Pro,
+    S19ProA,
    S19ProHydro,
+    S19XPHydro,
 )


@@ -42,10 +45,18 @@ class VNishS19Pro(VNish, S19Pro):
    pass


+class VNishS19Hydro(VNish, S19Hydro):
+    pass
+
+
 class VNishS19XP(VNish, S19XP):
    pass


+class VNishS19XPHydro(VNish, S19XPHydro):
+    pass
+
+
 class VNishS19a(VNish, S19a):
    pass

@@ -54,6 +65,10 @@ class VNishS19aPro(VNish, S19aPro):
    pass


+class VNishS19ProA(VNish, S19ProA):
+    pass
+
+
 class VNishS19i(VNish, S19i):
    pass

@@ -72,3 +87,7 @@ class VNishS19ProHydro(VNish, S19ProHydro):

 class VNishS19kPro(VNish, S19kPro):
    pass
+
+
+class VNishS19ProA(VNish, S19ProA):
+    pass
--- a/pyasic/miners/antminer/vnish/X19/init.py
+++ b/pyasic/miners/antminer/vnish/X19/init.py
@@ -18,13 +18,16 @@ from .S19 import (
    VNishS19,
    VNishS19a,
    VNishS19aPro,
+    VNishS19Hydro,
    VNishS19i,
    VNishS19j,
    VNishS19jPro,
    VNishS19kPro,
    VNishS19NoPIC,
    VNishS19Pro,
+    VNishS19ProA,
    VNishS19ProHydro,
    VNishS19XP,
+    VNishS19XPHydro,
 )
 from .T19 import VNishT19
--- a/pyasic/miners/antminer/vnish/X21/S21.py
+++ b/pyasic/miners/antminer/vnish/X21/S21.py
@@ -15,8 +15,24 @@
 # ------------------------------------------------------------------------------

 from pyasic.miners.backends import VNish
-from pyasic.miners.device.models import S21
+from pyasic.miners.device.models import S21, S21Hydro, S21Plus, S21PlusHydro, S21Pro


 class VNishS21(VNish, S21):
    pass
+
+
+class VNishS21Plus(VNish, S21Plus):
+    pass
+
+
+class VNishS21PlusHydro(VNish, S21PlusHydro):
+    pass
+
+
+class VNishS21Pro(VNish, S21Pro):
+    pass
+
+
+class VNishS21Hydro(VNish, S21Hydro):
+    pass
--- a/pyasic/miners/antminer/vnish/X21/init.py
+++ b/pyasic/miners/antminer/vnish/X21/init.py
@@ -14,5 +14,11 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .S21 import VNishS21
+from .S21 import (
+    VNishS21,
+    VNishS21Hydro,
+    VNishS21Plus,
+    VNishS21PlusHydro,
+    VNishS21Pro,
+)
 from .T21 import VNishT21
--- a/pyasic/miners/antminer/vnish/X3/L3.py
+++ b/pyasic/miners/antminer/vnish/X3/L3.py
@@ -18,5 +18,5 @@ from pyasic.miners.backends import VNish
 from pyasic.miners.device.models import L3Plus


-class VnishL3Plus(VNish, L3Plus):
+class VNishL3Plus(VNish, L3Plus):
    pass
--- a/pyasic/miners/antminer/vnish/X3/init.py
+++ b/pyasic/miners/antminer/vnish/X3/init.py
@@ -14,4 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .L3 import VnishL3Plus
+from .L3 import VNishL3Plus
--- a/pyasic/miners/antminer/vnish/X7/L7.py
+++ b/pyasic/miners/antminer/vnish/X7/L7.py
@@ -18,5 +18,5 @@ from pyasic.miners.backends import VNish
 from pyasic.miners.device.models import L7


-class VnishL7(VNish, L7):
+class VNishL7(VNish, L7):
    pass
--- a/pyasic/miners/antminer/vnish/X7/init.py
+++ b/pyasic/miners/antminer/vnish/X7/init.py
@@ -14,4 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .L7 import VnishL7
+from .L7 import VNishL7
--- a/pyasic/miners/antminer/vnish/X9/L9.py
+++ b/pyasic/miners/antminer/vnish/X9/L9.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 VNish
+from pyasic.miners.device.models import L9
+
+
+class VNishL9(VNish, L9):
+    pass
--- a/pyasic/miners/antminer/vnish/X9/init.py
+++ b/pyasic/miners/antminer/vnish/X9/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 .L9 import VNishL9
--- a/pyasic/miners/antminer/vnish/init.py
+++ b/pyasic/miners/antminer/vnish/init.py
@@ -16,6 +16,7 @@

 from .X3 import *
 from .X7 import *
+from .X9 import *
 from .X17 import *
 from .X19 import *
 from .X21 import *
--- a/pyasic/miners/avalonminer/cgminer/nano/init.py
+++ b/pyasic/miners/avalonminer/cgminer/nano/init.py
@@ -14,4 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .nano3 import CGMinerAvalonNano3
+from .nano3 import CGMinerAvalonNano3, CGMinerAvalonNano3s
--- a/pyasic/miners/avalonminer/cgminer/nano/nano3.py
+++ b/pyasic/miners/avalonminer/cgminer/nano/nano3.py
@@ -13,9 +13,11 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
-from typing import Optional
+from typing import List, Optional

 from pyasic import APIError
+from pyasic.data.boards import HashBoard
+from pyasic.device.algorithm.hashrate import AlgoHashRate
 from pyasic.miners.backends import AvalonMiner
 from pyasic.miners.data import (
    DataFunction,
@@ -24,7 +26,7 @@ from pyasic.miners.data import (
    RPCAPICommand,
    WebAPICommand,
 )
-from pyasic.miners.device.models import AvalonNano3
+from pyasic.miners.device.models import AvalonNano3, AvalonNano3s
 from pyasic.web.avalonminer import AvalonMinerWebAPI

 AVALON_NANO_DATA_LOC = DataLocations(
@@ -84,6 +86,63 @@ AVALON_NANO_DATA_LOC = DataLocations(
    }
 )

+AVALON_NANO3S_DATA_LOC = DataLocations(
+    **{
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        str(DataOptions.API_VERSION): DataFunction(
+            "_get_api_ver",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        str(DataOptions.FW_VERSION): DataFunction(
+            "_get_fw_ver",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        str(DataOptions.HASHRATE): DataFunction(
+            "_get_hashrate",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
+            "_get_expected_hashrate",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.HASHBOARDS): DataFunction(
+            "_get_hashboards",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
+            "_get_env_temp",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.WATTAGE_LIMIT): DataFunction(
+            "_get_wattage_limit",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.WATTAGE): DataFunction(
+            "_get_wattage",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.FANS): DataFunction(
+            "_get_fans",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.FAULT_LIGHT): DataFunction(
+            "_get_fault_light",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.UPTIME): DataFunction(
+            "_get_uptime",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
+    }
+)
+

 class CGMinerAvalonNano3(AvalonMiner, AvalonNano3):
    _web_cls = AvalonMinerWebAPI
@@ -105,3 +164,68 @@ class CGMinerAvalonNano3(AvalonMiner, AvalonNano3):
                    return mac.upper()
            except (KeyError, ValueError):
                pass
+
+
+class CGMinerAvalonNano3s(AvalonMiner, AvalonNano3s):
+
+    data_locations = AVALON_NANO3S_DATA_LOC
+
+    async def _get_wattage(self, rpc_stats: dict = None) -> Optional[int]:
+        if rpc_stats is None:
+            try:
+                rpc_stats = await self.rpc.stats()
+            except APIError:
+                pass
+
+        if rpc_stats is not None:
+            try:
+                unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
+                parsed_stats = self.parse_stats(unparsed_stats)
+                return int(parsed_stats["PS"][6])
+            except (IndexError, KeyError, ValueError, TypeError):
+                pass
+
+    async def _get_hashrate(self, rpc_stats: dict = None) -> Optional[AlgoHashRate]:
+        if rpc_stats is None:
+            try:
+                rpc_stats = await self.rpc.stats()
+            except APIError:
+                pass
+
+        if rpc_stats is not None:
+            try:
+                unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
+                parsed_stats = self.parse_stats(unparsed_stats)
+                return self.algo.hashrate(
+                    rate=float(parsed_stats["GHSspd"][0]), unit=self.algo.unit.GH
+                ).into(self.algo.unit.default)
+            except (IndexError, KeyError, ValueError, TypeError):
+                pass
+
+    async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        hashboards = await AvalonMiner._get_hashboards(self, rpc_stats)
+
+        if rpc_stats is None:
+            try:
+                rpc_stats = await self.rpc.stats()
+            except APIError:
+                pass
+
+        if rpc_stats is not None:
+
+            try:
+                unparsed_stats = rpc_stats["STATS"][0]["MM ID0"]
+                parsed_stats = self.parse_stats(unparsed_stats)
+            except (IndexError, KeyError, ValueError, TypeError):
+                return hashboards
+
+            for board in range(len(hashboards)):
+                try:
+                    board_hr = parsed_stats["GHSspd"][board]
+                    hashboards[board].hashrate = self.algo.hashrate(
+                        rate=float(board_hr), unit=self.algo.unit.GH
+                    ).into(self.algo.unit.default)
+                except LookupError:
+                    pass
+
+        return hashboards
--- a/pyasic/miners/backends/antminer.py
+++ b/pyasic/miners/backends/antminer.py
@@ -252,6 +252,9 @@ class AntminerModern(BMMiner):
        return errors

    async def _get_hashboards(self) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=idx, expected_chips=self.expected_chips)
            for idx in range(self.expected_hashboards)
@@ -269,18 +272,47 @@ class AntminerModern(BMMiner):
                        rate=board["rate_real"], unit=self.algo.unit.GH
                    ).into(self.algo.unit.default)
                    hashboards[board["index"]].chips = board["asic_num"]
-                    board_temp_data = list(
-                        filter(lambda x: not x == 0, board["temp_pcb"])
-                    )
-                    hashboards[board["index"]].temp = sum(board_temp_data) / len(
-                        board_temp_data
-                    )
-                    chip_temp_data = list(
-                        filter(lambda x: not x == 0, board["temp_chip"])
-                    )
-                    hashboards[board["index"]].chip_temp = sum(chip_temp_data) / len(
-                        chip_temp_data
-                    )
+
+                    if "S21+ Hyd" in self.model:
+                        hashboards[board["index"]].inlet_temp = board["temp_pcb"][0]
+                        hashboards[board["index"]].outlet_temp = board["temp_pcb"][2]
+                        hashboards[board["index"]].chip_temp = board["temp_pic"][0]
+                        board_temp_data = list(
+                            filter(
+                                lambda x: not x == 0,
+                                [
+                                    board["temp_pic"][1],
+                                    board["temp_pic"][2],
+                                    board["temp_pic"][3],
+                                    board["temp_pcb"][1],
+                                    board["temp_pcb"][3],
+                                ],
+                            )
+                        )
+                        hashboards[board["index"]].temp = (
+                            sum(board_temp_data) / len(board_temp_data)
+                            if len(board_temp_data) > 0
+                            else 0
+                        )
+
+                    else:
+                        board_temp_data = list(
+                            filter(lambda x: not x == 0, board["temp_pcb"])
+                        )
+                        hashboards[board["index"]].temp = (
+                            sum(board_temp_data) / len(board_temp_data)
+                            if len(board_temp_data) > 0
+                            else 0
+                        )
+                        chip_temp_data = list(
+                            filter(lambda x: not x == 0, board["temp_chip"])
+                        )
+                        hashboards[board["index"]].chip_temp = (
+                            sum(chip_temp_data) / len(chip_temp_data)
+                            if len(chip_temp_data) > 0
+                            else 0
+                        )
+
                    hashboards[board["index"]].serial_number = board["sn"]
                    hashboards[board["index"]].missing = False
            except LookupError:
@@ -565,6 +597,9 @@ class AntminerOld(CGMiner):
                pass

    async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if rpc_stats is None:
            try:
                rpc_stats = await self.rpc.stats()
@@ -593,6 +628,8 @@ class AntminerOld(CGMiner):
        return fans_data

    async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
        hashboards = []

        if rpc_stats is None:
--- a/pyasic/miners/backends/auradine.py
+++ b/pyasic/miners/backends/auradine.py
@@ -303,6 +303,9 @@ class Auradine(StockFirmware):
    async def _get_hashboards(
        self, rpc_devs: dict = None, web_ipreport: dict = None
    ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -382,6 +385,9 @@ class Auradine(StockFirmware):
                pass

    async def _get_fans(self, web_fan: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if web_fan is None:
            try:
                web_fan = await self.web.get_fan()
--- a/pyasic/miners/backends/avalonminer.py
+++ b/pyasic/miners/backends/avalonminer.py
@@ -104,6 +104,23 @@ class AvalonMiner(CGMiner):
            return True
        return False

+    async def set_power_limit(self, wattage: int) -> bool:
+        try:
+            if wattage < 3:
+                limit = wattage
+            elif wattage > 100:
+                limit = 2
+            elif wattage > 80:
+                limit = 1
+            else:
+                limit = 0
+            data = await self.rpc.ascset(0, "worklevel,set", 1)
+        except APIError:
+            return False
+        if data["STATUS"][0]["Msg"] == "ASC 0 set OK":
+            return True
+        return False
+
    async def reboot(self) -> bool:
        try:
            data = await self.rpc.restart()
@@ -195,6 +212,9 @@ class AvalonMiner(CGMiner):
                pass

    async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -309,6 +329,9 @@ class AvalonMiner(CGMiner):
                pass

    async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if rpc_stats is None:
            try:
                rpc_stats = await self.rpc.stats()
--- a/pyasic/miners/backends/bfgminer.py
+++ b/pyasic/miners/backends/bfgminer.py
@@ -129,6 +129,9 @@ class BFGMiner(StockFirmware):
                pass

    async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = []

        if rpc_stats is None:
@@ -185,6 +188,9 @@ class BFGMiner(StockFirmware):
        return hashboards

    async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if rpc_stats is None:
            try:
                rpc_stats = await self.rpc.stats()
--- a/pyasic/miners/backends/bmminer.py
+++ b/pyasic/miners/backends/bmminer.py
@@ -133,6 +133,9 @@ class BMMiner(StockFirmware):
                pass

    async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = []

        if rpc_stats is None:
@@ -202,6 +205,9 @@ class BMMiner(StockFirmware):
        return hashboards

    async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if rpc_stats is None:
            try:
                rpc_stats = await self.rpc.stats()
--- a/pyasic/miners/backends/braiins_os.py
+++ b/pyasic/miners/backends/braiins_os.py
@@ -376,6 +376,9 @@ class BOSMiner(BraiinsOSFirmware):
        rpc_devdetails: dict = None,
        rpc_devs: dict = None,
    ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -473,6 +476,9 @@ class BOSMiner(BraiinsOSFirmware):
                pass

    async def _get_fans(self, rpc_fans: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if rpc_fans is None:
            try:
                rpc_fans = await self.rpc.fans()
@@ -926,6 +932,9 @@ class BOSer(BraiinsOSFirmware):
                pass

    async def _get_hashboards(self, grpc_hashboards: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -997,6 +1006,9 @@ class BOSer(BraiinsOSFirmware):
                pass

    async def _get_fans(self, grpc_cooling_state: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if grpc_cooling_state is None:
            try:
                grpc_cooling_state = await self.web.get_cooling_state()
--- a/pyasic/miners/backends/btminer.py
+++ b/pyasic/miners/backends/btminer.py
@@ -412,6 +412,9 @@ class BTMiner(StockFirmware):
                pass

    async def _get_hashboards(self, rpc_devs: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -490,6 +493,9 @@ class BTMiner(StockFirmware):
    async def _get_fans(
        self, rpc_summary: dict = None, rpc_get_psu: dict = None
    ) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if rpc_summary is None:
            try:
                rpc_summary = await self.rpc.summary()
--- a/pyasic/miners/backends/elphapex.py
+++ b/pyasic/miners/backends/elphapex.py
@@ -209,6 +209,9 @@ class ElphapexMiner(StockFirmware):
        return errors

    async def _get_hashboards(self, web_stats: dict | None = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=idx, expected_chips=self.expected_chips)
            for idx in range(self.expected_hashboards)
@@ -317,6 +320,9 @@ class ElphapexMiner(StockFirmware):
                pass

    async def _get_fans(self, web_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if web_stats is None:
            try:
                web_stats = await self.web.stats()
--- a/pyasic/miners/backends/epic.py
+++ b/pyasic/miners/backends/epic.py
@@ -21,7 +21,7 @@ from pyasic.config import MinerConfig
 from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import MinerErrorData, X19Error
 from pyasic.data.pools import PoolMetrics, PoolUrl
-from pyasic.device.algorithm import AlgoHashRate
+from pyasic.device.algorithm import AlgoHashRate, ScryptAlgo
 from pyasic.errors import APIError
 from pyasic.logger import logger
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, WebAPICommand
@@ -138,6 +138,8 @@ class ePIC(ePICFirmware):
                await self.web.set_ptune_algo(conf["ptune"])

            ## Pools
+            if self.algo == ScryptAlgo:
+                conf["pools"]["coin"] = "Ltc"
            await self.web.set_pools(conf["pools"])
        except APIError:
            pass
@@ -283,6 +285,9 @@ class ePIC(ePICFirmware):
                pass

    async def _get_fans(self, web_summary: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if web_summary is None:
            try:
                web_summary = await self.web.summary()
@@ -302,6 +307,9 @@ class ePIC(ePICFirmware):
    async def _get_hashboards(
        self, web_summary: dict = None, web_capabilities: dict = None
    ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        if web_summary is None:
            try:
                web_summary = await self.web.summary()
--- a/pyasic/miners/backends/espminer.py
+++ b/pyasic/miners/backends/espminer.py
@@ -115,11 +115,18 @@ class ESPMiner(BaseMiner):

        if web_system_info is not None:
            try:
-                expected_hashrate = (
-                    web_system_info.get("smallCoreCount")
-                    * web_system_info.get("asicCount")
-                    * web_system_info.get("frequency")
-                )
+                small_core_count = web_system_info.get("smallCoreCount")
+                asic_count = web_system_info.get("asicCount")
+                frequency = web_system_info.get("frequency")
+
+                if asic_count is None:
+                    try:
+                        asic_info = await self.web.asic_info()
+                        asic_count = asic_info.get("asicCount")
+                    except APIError:
+                        pass
+
+                expected_hashrate = small_core_count * asic_count * frequency

                return self.algo.hashrate(
                    rate=float(expected_hashrate), unit=self.algo.unit.MH
@@ -141,6 +148,9 @@ class ESPMiner(BaseMiner):
                pass

    async def _get_hashboards(self, web_system_info: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        if web_system_info is None:
            try:
                web_system_info = await self.web.system_info()
@@ -169,6 +179,9 @@ class ESPMiner(BaseMiner):
        return []

    async def _get_fans(self, web_system_info: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if web_system_info is None:
            try:
                web_system_info = await self.web.system_info()
--- a/pyasic/miners/backends/goldshell.py
+++ b/pyasic/miners/backends/goldshell.py
@@ -145,6 +145,9 @@ class GoldshellMiner(BFGMiner):
    async def _get_hashboards(
        self, rpc_devs: dict = None, rpc_devdetails: dict = None
    ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        if rpc_devs is None:
            try:
                rpc_devs = await self.rpc.devs()
--- a/pyasic/miners/backends/hammer.py
+++ b/pyasic/miners/backends/hammer.py
@@ -180,6 +180,9 @@ class BlackMiner(StockFirmware):
                pass

    async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = []

        if rpc_stats is None:
@@ -245,6 +248,9 @@ class BlackMiner(StockFirmware):
        return hashboards

    async def _get_fans(self, rpc_stats: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if rpc_stats is None:
            try:
                rpc_stats = await self.rpc.stats()
--- a/pyasic/miners/backends/iceriver.py
+++ b/pyasic/miners/backends/iceriver.py
@@ -79,6 +79,9 @@ class IceRiver(StockFirmware):
        return MinerConfig.from_iceriver(web_userpanel)

    async def _get_fans(self, web_userpanel: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if web_userpanel is None:
            try:
                web_userpanel = await self.web.userpanel()
@@ -170,6 +173,9 @@ class IceRiver(StockFirmware):
                pass

    async def _get_hashboards(self, web_userpanel: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        if web_userpanel is None:
            try:
                web_userpanel = await self.web.userpanel()
--- a/pyasic/miners/backends/innosilicon.py
+++ b/pyasic/miners/backends/innosilicon.py
@@ -211,6 +211,9 @@ class Innosilicon(CGMiner):
    async def _get_hashboards(
        self, rpc_stats: dict = None, web_get_all: dict = None
    ) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        if web_get_all:
            web_get_all = web_get_all["all"]

@@ -304,6 +307,9 @@ class Innosilicon(CGMiner):
                        return wattage

    async def _get_fans(self, web_get_all: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if web_get_all:
            web_get_all = web_get_all["all"]

--- a/pyasic/miners/backends/luxminer.py
+++ b/pyasic/miners/backends/luxminer.py
@@ -86,6 +86,7 @@ class LUXMiner(LuxOSFirmware):

    supports_shutdown = True
    supports_presets = True
+    supports_autotuning = True

    data_locations = LUXMINER_DATA_LOC

@@ -152,7 +153,7 @@ class LUXMiner(LuxOSFirmware):
            rpc_profiles=data.get("profiles", [{}])[0],
        )

-    async def upgrade_firmware(self) -> bool:
+    async def upgrade_firmware(self, *args, **kwargs) -> bool:
        """
        Upgrade the firmware on a LuxOS miner by calling the 'updaterun' API command.
        Returns:
@@ -191,10 +192,10 @@ class LUXMiner(LuxOSFirmware):
        try:
            if await self.atm_enabled():
                re_enable_atm = True
-                await self.rpc.atmset("enabled=false")
+                await self.rpc.atmset(enabled=False)
            result = await self.rpc.profileset(new_preset)
            if re_enable_atm:
-                await self.rpc.atmset("enabled=true")
+                await self.rpc.atmset(enabled=True)
        except APIError:
            raise
        except Exception as e:
@@ -240,6 +241,9 @@ class LUXMiner(LuxOSFirmware):
                pass

    async def _get_hashboards(self, rpc_stats: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=idx, expected_chips=self.expected_chips)
            for idx in range(self.expected_hashboards)
@@ -309,6 +313,9 @@ class LUXMiner(LuxOSFirmware):
            pass

    async def _get_fans(self, rpc_fans: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if rpc_fans is None:
            try:
                rpc_fans = await self.rpc.fans()
--- a/pyasic/miners/backends/marathon.py
+++ b/pyasic/miners/backends/marathon.py
@@ -164,6 +164,9 @@ class MaraMiner(MaraFirmware):
                pass

    async def _get_hashboards(self, web_hashboards: dict = None) -> List[HashBoard]:
+        if self.expected_hashboards is None:
+            return []
+
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -250,6 +253,9 @@ class MaraMiner(MaraFirmware):
                pass

    async def _get_fans(self, web_fans: dict = None) -> List[Fan]:
+        if self.expected_fans is None:
+            return []
+
        if web_fans is None:
            try:
                web_fans = await self.web.fans()
--- a/pyasic/miners/backends/unknown.py
+++ b/pyasic/miners/backends/unknown.py
@@ -97,7 +97,7 @@ class UnknownMiner(BaseMiner):
        return None

    async def _get_fans(self) -> List[Fan]:
-        return [Fan(), Fan(), Fan(), Fan()]
+        return []

    async def _get_fan_psu(self) -> Optional[int]:
        return None
--- a/pyasic/miners/backends/vnish.py
+++ b/pyasic/miners/backends/vnish.py
@@ -293,9 +293,12 @@ class VNish(VNishFirmware, BMMiner):
        try:
            web_settings = await self.web.settings()
            web_presets = await self.web.autotune_presets()
+            web_perf_summary = (await self.web.perf_summary()) or {}
        except APIError:
            return self.config
-        self.config = MinerConfig.from_vnish(web_settings, web_presets)
+        self.config = MinerConfig.from_vnish(
+            web_settings, web_presets, web_perf_summary
+        )
        return self.config

    async def set_power_limit(self, wattage: int) -> bool:
--- a/pyasic/miners/blockminer/epic/blockminer/init.py
+++ b/pyasic/miners/blockminer/epic/blockminer/init.py
@@ -14,4 +14,4 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .blockminer import ePICBlockMiner520i, ePICBlockMiner720i
+from .blockminer import *
--- a/pyasic/miners/blockminer/epic/blockminer/blockminer.py
+++ b/pyasic/miners/blockminer/epic/blockminer/blockminer.py
@@ -15,7 +15,11 @@
 # ------------------------------------------------------------------------------

 from pyasic.miners.backends import ePIC
-from pyasic.miners.device.models import BlockMiner520i, BlockMiner720i
+from pyasic.miners.device.models import (
+    BlockMiner520i,
+    BlockMiner720i,
+    BlockMinerELITE1,
+)


 class ePICBlockMiner520i(ePIC, BlockMiner520i):
@@ -24,3 +28,7 @@ class ePICBlockMiner520i(ePIC, BlockMiner520i):

 class ePICBlockMiner720i(ePIC, BlockMiner720i):
    pass
+
+
+class ePICBlockMinerELITE1(ePIC, BlockMinerELITE1):
+    pass
--- a/pyasic/miners/device/models/antminer/X19/S19.py
+++ b/pyasic/miners/device/models/antminer/X19/S19.py
@@ -126,6 +126,15 @@ class S19jPro(AntMinerMake):
    algo = MinerAlgo.SHA256


+class S19jPlus(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S19jPlus
+
+    expected_chips = 108
+    expected_fans = 4
+    expected_hashboards = 3
+    algo = MinerAlgo.SHA256
+
+
 class S19jProNoPIC(AntMinerMake):
    raw_model = MinerModel.ANTMINER.S19jProNoPIC

@@ -216,6 +225,15 @@ class S19KPro(AntMinerMake):
    algo = MinerAlgo.SHA256


+class S19ProA(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S19ProA
+
+    expected_chips = 114
+    expected_fans = 4
+    expected_hashboards = 3
+    algo = MinerAlgo.SHA256
+
+
 class S19jXP(AntMinerMake):
    raw_model = MinerModel.ANTMINER.S19jXP

@@ -223,3 +241,12 @@ class S19jXP(AntMinerMake):
    expected_fans = 4
    expected_hashboards = 3
    algo = MinerAlgo.SHA256
+
+
+class S19XPHydro(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S19XPHydro
+
+    expected_chips = 204
+    expected_fans = 0
+    expected_hashboards = 3
+    algo = MinerAlgo.SHA256
--- a/pyasic/miners/device/models/antminer/X19/init.py
+++ b/pyasic/miners/device/models/antminer/X19/init.py
@@ -24,6 +24,7 @@ from .S19 import (
    S19i,
    S19j,
    S19jNoPIC,
+    S19jPlus,
    S19jPro,
    S19jProNoPIC,
    S19jProPlus,
@@ -35,8 +36,10 @@ from .S19 import (
    S19NoPIC,
    S19Plus,
    S19Pro,
+    S19ProA,
    S19ProHydro,
    S19ProPlus,
    S19ProPlusHydro,
+    S19XPHydro,
 )
 from .T19 import T19
--- a/pyasic/miners/device/models/antminer/X21/S21.py
+++ b/pyasic/miners/device/models/antminer/X21/S21.py
@@ -27,6 +27,24 @@ class S21(AntMinerMake):
    algo = MinerAlgo.SHA256


+class S21Plus(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S21Plus
+
+    expected_chips = 55
+    expected_fans = 4
+    expected_hashboards = 3
+    algo = MinerAlgo.SHA256
+
+
+class S21PlusHydro(AntMinerMake):
+    raw_model = MinerModel.ANTMINER.S21PlusHydro
+
+    expected_chips = 95
+    expected_fans = 0
+    expected_hashboards = 3
+    algo = MinerAlgo.SHA256
+
+
 class S21Pro(AntMinerMake):
    raw_model = MinerModel.ANTMINER.S21Pro

@@ -40,6 +58,6 @@ class S21Hydro(AntMinerMake):
    raw_model = MinerModel.ANTMINER.S21Hydro

    expected_chips = 216
-    expected_hashboards = 2
+    expected_hashboards = 3
    expected_fans = 0
    algo = MinerAlgo.SHA256
--- a/pyasic/miners/device/models/antminer/X21/init.py
+++ b/pyasic/miners/device/models/antminer/X21/init.py
@@ -14,5 +14,5 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

-from .S21 import S21, S21Hydro, S21Pro
+from .S21 import S21, S21Hydro, S21Plus, S21PlusHydro, S21Pro
 from .T21 import T21
--- a/pyasic/miners/device/models/avalonminer/nano/init.py
+++ b/pyasic/miners/device/models/avalonminer/nano/init.py
@@ -1 +1 @@
-from .nano3 import AvalonNano3
+from .nano3 import AvalonNano3, AvalonNano3s
--- a/pyasic/miners/device/models/avalonminer/nano/nano3.py
+++ b/pyasic/miners/device/models/avalonminer/nano/nano3.py
@@ -10,3 +10,12 @@ class AvalonNano3(AvalonMinerMake):
    expected_chips = 10
    expected_fans = 1
    algo = MinerAlgo.SHA256
+
+
+class AvalonNano3s(AvalonMinerMake):
+    raw_model = MinerModel.AVALONMINER.AvalonNano3s
+
+    expected_hashboards = 1
+    expected_chips = 12
+    expected_fans = 1
+    algo = MinerAlgo.SHA256
--- a/pyasic/miners/device/models/elphapex/DGX/DG1.py
+++ b/pyasic/miners/device/models/elphapex/DGX/DG1.py
@@ -18,6 +18,15 @@ from pyasic.device.models import MinerModel
 from pyasic.miners.device.makes import ElphapexMake


+class DG1(ElphapexMake):
+    raw_model = MinerModel.ELPHAPEX.DG1
+
+    expected_chips = 144
+    expected_hashboards = 4
+    expected_fans = 4
+    algo = MinerAlgo.SCRYPT
+
+
 class DG1Plus(ElphapexMake):
    raw_model = MinerModel.ELPHAPEX.DG1Plus

@@ -25,3 +34,12 @@ class DG1Plus(ElphapexMake):
    expected_hashboards = 4
    expected_fans = 4
    algo = MinerAlgo.SCRYPT
+
+
+class DG1Home(ElphapexMake):
+    raw_model = MinerModel.ELPHAPEX.DG1Home
+
+    expected_chips = 120
+    expected_hashboards = 4
+    expected_fans = 4
+    algo = MinerAlgo.SCRYPT
--- a/pyasic/miners/device/models/elphapex/DGX/init.py
+++ b/pyasic/miners/device/models/elphapex/DGX/init.py
@@ -1 +1 @@
-from .DG1 import DG1Plus
+from .DG1 import DG1, DG1Home, DG1Plus
--- a/pyasic/miners/device/models/epic/blockminer/blockminer.py
+++ b/pyasic/miners/device/models/epic/blockminer/blockminer.py
@@ -19,3 +19,12 @@ class BlockMiner720i(ePICMake):
    expected_fans = 4
    expected_hashboards = 3
    algo = MinerAlgo.SHA256
+
+
+class BlockMinerELITE1(ePICMake):
+    raw_model = MinerModel.EPIC.eLITE1
+
+    expected_chips = 105
+    expected_fans = 4
+    expected_hashboards = 3
+    algo = MinerAlgo.SCRYPT
--- a/pyasic/miners/device/models/iceriver/ALX/AL3.py
+++ b/pyasic/miners/device/models/iceriver/ALX/AL3.py
@@ -0,0 +1,27 @@
+# ------------------------------------------------------------------------------
+#  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.algorithm import MinerAlgo
+from pyasic.device.models import MinerModel
+from pyasic.miners.device.makes import IceRiverMake
+
+
+class AL3(IceRiverMake):
+    raw_model = MinerModel.ICERIVER.AL3
+
+    expected_chips = 156
+    expected_fans = 4
+    expected_hashboards = 3
+    algo = MinerAlgo.BLOCKFLOW
--- a/pyasic/miners/device/models/iceriver/ALX/init.py
+++ b/pyasic/miners/device/models/iceriver/ALX/init.py
@@ -0,0 +1 @@
+from .AL3 import AL3
--- a/pyasic/miners/device/models/iceriver/init.py
+++ b/pyasic/miners/device/models/iceriver/init.py
@@ -1 +1,2 @@
+from .ALX import *
 from .KSX import *
--- a/pyasic/miners/elphapex/daoge/DGX/DG1.py
+++ b/pyasic/miners/elphapex/daoge/DGX/DG1.py
@@ -1,6 +1,14 @@
 from pyasic.miners.backends.elphapex import ElphapexMiner
-from pyasic.miners.device.models import DG1Plus
+from pyasic.miners.device.models import DG1, DG1Home, DG1Plus


 class ElphapexDG1Plus(ElphapexMiner, DG1Plus):
    pass
+
+
+class ElphapexDG1(ElphapexMiner, DG1):
+    pass
+
+
+class ElphapexDG1Home(ElphapexMiner, DG1Home):
+    pass
--- a/pyasic/miners/elphapex/daoge/DGX/init.py
+++ b/pyasic/miners/elphapex/daoge/DGX/init.py
@@ -1 +1 @@
-from .DG1 import ElphapexDG1Plus
+from .DG1 import ElphapexDG1, ElphapexDG1Home, ElphapexDG1Plus
--- a/pyasic/miners/factory.py
+++ b/pyasic/miners/factory.py
@@ -41,6 +41,7 @@ from pyasic.miners.elphapex import *
 from pyasic.miners.goldshell import *
 from pyasic.miners.hammer import *
 from pyasic.miners.iceriver import *
+from pyasic.miners.iceriver.iceminer.ALX import IceRiverAL3
 from pyasic.miners.innosilicon import *
 from pyasic.miners.luckyminer import *
 from pyasic.miners.volcminer import *
@@ -108,6 +109,8 @@ MINER_CLASSES = {
        "ANTMINER S19J88NOPIC": BMMinerS19jNoPIC,
        "ANTMINER S19PRO+": BMMinerS19ProPlus,
        "ANTMINER S19J PRO": BMMinerS19jPro,
+        "ANTMINER S19J+": BMMinerS19jPlus,
+        "ANTMINER S19J PRO+": BMMinerS19jProPlus,
        "ANTMINER S19 XP": BMMinerS19XP,
        "ANTMINER S19A": BMMinerS19a,
        "ANTMINER S19A PRO": BMMinerS19aPro,
@@ -120,6 +123,8 @@ MINER_CLASSES = {
        "ANTMINER S21": BMMinerS21,
        "ANTMINER BHB68601": BMMinerS21,  # ???
        "ANTMINER BHB68606": BMMinerS21,  # ???
+        "ANTMINER S21+": BMMinerS21Plus,
+        "ANTMINER S21+ HYD.": BMMinerS21PlusHydro,
        "ANTMINER S21 PRO": BMMinerS21Pro,
        "ANTMINER T21": BMMinerT21,
        "ANTMINER S21 HYD.": BMMinerS21Hydro,
@@ -505,6 +510,7 @@ MINER_CLASSES = {
        "AVALONMINER 1166PRO": CGMinerAvalon1166Pro,
        "AVALONMINER 1246": CGMinerAvalon1246,
        "AVALONMINER NANO3": CGMinerAvalonNano3,
+        "AVALON NANO3S": CGMinerAvalonNano3s,
        "AVALONMINER 15-194": CGMinerAvalon1566,
    },
    MinerTypes.INNOSILICON: {
@@ -552,15 +558,20 @@ MINER_CLASSES = {
        "ANTMINER T19": BOSMinerT19,
        "ANTMINER S21": BOSMinerS21,
        "ANTMINER S21 PRO": BOSMinerS21Pro,
+        "ANTMINER S21+": BOSMinerS21Plus,
+        "ANTMINER S21+ HYD.": BOSMinerS21PlusHydro,
+        "ANTMINER S21 HYD.": BOSMinerS21Hydro,
        "ANTMINER T21": BOSMinerT21,
        "BRAIINS MINI MINER BMM 100": BraiinsBMM100,
        "BRAIINS MINI MINER BMM 101": BraiinsBMM101,
+        "ANTMINER S19 XP HYD.": BOSMinerS19XPHydro,
    },
    MinerTypes.VNISH: {
        None: VNish,
-        "L3+": VnishL3Plus,
-        "ANTMINER L3+": VnishL3Plus,
-        "ANTMINER L7": VnishL7,
+        "L3+": VNishL3Plus,
+        "ANTMINER L3+": VNishL3Plus,
+        "ANTMINER L7": VNishL7,
+        "ANTMINER L9": VNishL9,
        "ANTMINER S17+": VNishS17Plus,
        "ANTMINER S17 PRO": VNishS17Pro,
        "ANTMINER S19": VNishS19,
@@ -568,16 +579,24 @@ MINER_CLASSES = {
        "ANTMINER S19 PRO": VNishS19Pro,
        "ANTMINER S19J": VNishS19j,
        "ANTMINER S19I": VNishS19i,
+        "ANTMINER S19 XP": VNishS19XP,
+        "ANTMINER S19 XP HYD.": VNishS19XPHydro,
        "ANTMINER S19J PRO": VNishS19jPro,
        "ANTMINER S19J PRO A": VNishS19jPro,
        "ANTMINER S19J PRO BB": VNishS19jPro,
        "ANTMINER S19A": VNishS19a,
+        "ANTMINER S19 HYD.": VNishS19Hydro,
        "ANTMINER S19A PRO": VNishS19aPro,
+        "ANTMINER S19 PRO A": VNishS19ProA,
        "ANTMINER S19 PRO HYD.": VNishS19ProHydro,
        "ANTMINER S19K PRO": VNishS19kPro,
        "ANTMINER T19": VNishT19,
        "ANTMINER T21": VNishT21,
        "ANTMINER S21": VNishS21,
+        "ANTMINER S21+": VNishS21Plus,
+        "ANTMINER S21+ HYD.": VNishS21PlusHydro,
+        "ANTMINER S21 PRO": VNishS21Pro,
+        "ANTMINER S21 HYD.": VNishS21Hydro,
    },
    MinerTypes.EPIC: {
        None: ePIC,
@@ -592,14 +611,17 @@ MINER_CLASSES = {
        "ANTMINER S21 PRO": ePICS21Pro,
        "ANTMINER T21": ePICT21,
        "ANTMINER S19J PRO DUAL": ePICS19jProDual,
+        "ANTMINER S19K PRO DUAL": ePICS19kProDual,
        "BLOCKMINER 520I": ePICBlockMiner520i,
        "BLOCKMINER 720I": ePICBlockMiner720i,
+        "BLOCKMINER ELITE 1.0": ePICBlockMinerELITE1,
    },
    MinerTypes.HIVEON: {
        None: HiveonModern,
        "ANTMINER T9": HiveonT9,
        "ANTMINER S19JPRO": HiveonS19jPro,
        "ANTMINER S19": HiveonS19,
+        "ANTMINER S19K PRO": HiveonS19kPro,
        "ANTMINER S19X88": HiveonS19NoPIC,
    },
    MinerTypes.MSKMINER: {
@@ -617,6 +639,7 @@ MINER_CLASSES = {
        "ANTMINER S19 XP": LUXMinerS19XP,
        "ANTMINER T19": LUXMinerT19,
        "ANTMINER S21": LUXMinerS21,
+        "ANTMINER T21": LUXMinerT21,
    },
    MinerTypes.AURADINE: {
        None: type("AuradineUnknown", (Auradine, AuradineMake), {}),
@@ -663,6 +686,7 @@ MINER_CLASSES = {
        "KS5": IceRiverKS5,
        "KS5L": IceRiverKS5L,
        "KS5M": IceRiverKS5M,
+        "10306": IceRiverAL3,
    },
    MinerTypes.HAMMER: {
        None: type("HammerUnknown", (BlackMiner, HammerMake), {}),
@@ -675,6 +699,8 @@ MINER_CLASSES = {
    MinerTypes.ELPHAPEX: {
        None: type("ElphapexUnknown", (ElphapexMiner, ElphapexMake), {}),
        "DG1+": ElphapexDG1Plus,
+        "DG1": ElphapexDG1,
+        "DG1-Home": ElphapexDG1Home,
    },
 }

@@ -875,8 +901,6 @@ class MinerFactory:
            return MinerTypes.INNOSILICON
        if "Miner UI" in web_text:
            return MinerTypes.AURADINE
-        if "<title>Antminer</title>" in web_text:
-            return MinerTypes.MSKMINER

    async def _get_miner_socket(self, ip: str) -> MinerTypes | None:
        commands = ["version", "devdetails"]
--- a/pyasic/miners/iceriver/iceminer/ALX/AL3.py
+++ b/pyasic/miners/iceriver/iceminer/ALX/AL3.py
@@ -0,0 +1,6 @@
+from pyasic.miners.backends.iceriver import IceRiver
+from pyasic.miners.device.models.iceriver import AL3
+
+
+class IceRiverAL3(IceRiver, AL3):
+    pass
--- a/pyasic/miners/iceriver/iceminer/ALX/init.py
+++ b/pyasic/miners/iceriver/iceminer/ALX/init.py
@@ -0,0 +1 @@
+from .AL3 import IceRiverAL3
--- a/pyasic/web/avalonminer.py
+++ b/pyasic/web/avalonminer.py
@@ -64,7 +64,7 @@ class AvalonMinerWebAPI(BaseWebAPI):
                resp = await client.get(url)
                raw_data = resp.text.replace("minerinfoCallback(", "").replace(");", "")
                return json.loads(raw_data)
-        except httpx.HTTPError:
+        except (httpx.HTTPError, json.JSONDecodeError):
            pass
        return {}

--- a/pyasic/web/braiins_os/boser.py
+++ b/pyasic/web/braiins_os/boser.py
@@ -89,7 +89,7 @@ class BOSerWebAPI(BaseWebAPI):
        for cmd in tasks:
            try:
                result[cmd] = await tasks[cmd]
-            except (GRPCError, APIError):
+            except (GRPCError, APIError, ConnectionError):
                pass

        return result
@@ -121,7 +121,7 @@ class BOSerWebAPI(BaseWebAPI):
                        metadata = [("authorization", await self.auth())]
                        return (await endpoint(message, metadata=metadata)).to_pydict()
                    raise e
-        except GRPCError as e:
+        except (GRPCError, ConnectionError) as e:
            raise APIError(f"gRPC command failed - {endpoint}") from e

    async def auth(self) -> str | None:
--- a/pyasic/web/espminer.py
+++ b/pyasic/web/espminer.py
@@ -20,34 +20,36 @@ class ESPMinerWebAPI(BaseWebAPI):
        **parameters: Any,
    ) -> dict:
        url = f"http://{self.ip}:{self.port}/api/{command}"
-        try:
-            async with httpx.AsyncClient(
-                transport=settings.transport(),
-            ) as client:
-                if parameters.get("post", False):
-                    parameters.pop("post")
-                    data = await client.post(
-                        url,
-                        timeout=settings.get("api_function_timeout", 3),
-                        json=parameters,
-                    )
-                elif parameters.get("patch", False):
-                    parameters.pop("patch")
-                    data = await client.patch(
-                        url,
-                        timeout=settings.get("api_function_timeout", 3),
-                        json=parameters,
-                    )
-                else:
-                    data = await client.get(url)
-        except httpx.HTTPError:
-            pass
-        else:
-            if data.status_code == 200:
+        async with httpx.AsyncClient(transport=settings.transport()) as client:
+            for _ in range(settings.get("get_data_retries", 1)):
                try:
-                    return data.json()
-                except json.decoder.JSONDecodeError:
+                    if parameters.get("post", False):
+                        parameters.pop("post")
+                        data = await client.post(
+                            url,
+                            timeout=settings.get("api_function_timeout", 3),
+                            json=parameters,
+                        )
+                    elif parameters.get("patch", False):
+                        parameters.pop("patch")
+                        data = await client.patch(
+                            url,
+                            timeout=settings.get("api_function_timeout", 3),
+                            json=parameters,
+                        )
+                    else:
+                        data = await client.get(
+                            url,
+                            timeout=settings.get("api_function_timeout", 5),
+                        )
+                except httpx.HTTPError:
                    pass
+                else:
+                    if data.status_code == 200:
+                        try:
+                            return data.json()
+                        except json.decoder.JSONDecodeError:
+                            pass

    async def multicommand(
        self, *commands: str, ignore_errors: bool = False, allow_warning: bool = True
@@ -94,3 +96,6 @@ class ESPMinerWebAPI(BaseWebAPI):

    async def update_settings(self, **config):
        return await self.send_command("system", patch=True, **config)
+
+    async def asic_info(self):
+        return await self.send_command("system/asic")
--- a/pyasic/web/vnish.py
+++ b/pyasic/web/vnish.py
@@ -58,7 +58,7 @@ class VNishWebAPI(BaseWebAPI):
        allow_warning: bool = True,
        privileged: bool = False,
        **parameters: Any,
-    ) -> dict:
+    ) -> dict | None:
        post = privileged or not parameters == {}
        if self.token is None:
            await self.auth()
@@ -126,6 +126,9 @@ class VNishWebAPI(BaseWebAPI):
    async def summary(self) -> dict:
        return await self.send_command("summary")

+    async def perf_summary(self) -> dict:
+        return await self.send_command("perf-summary")
+
    async def chips(self) -> dict:
        return await self.send_command("chips")

--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "pyasic"
-version = "0.71.10"
+version = "0.73.0"

 description = "A simplified and standardized interface for Bitcoin ASICs."
 authors = [{name = "UpstreamData", email = "brett@upstreamdata.ca"}]
@@ -43,7 +43,7 @@ classifiers = [
 requires-python = ">3.9, <4.0"
 dependencies = [
    "httpx>=0.26.0",
-    "asyncssh>=2.17.0",
+    "asyncssh>=2.20.0",
    "cryptography>=39.0",
    "passlib>=1.7.4",
    "pyaml>=23.12.0",
@@ -51,7 +51,7 @@ dependencies = [
    "tomli-w>=1.0.0",
    "aiofiles>=23.2.1",
    "betterproto==2.0.0b7",
-    "pydantic>=2.9.2",
+    "pydantic>=2.11.0",
 ]

 [tool.poetry.group.dev]
Author	SHA1	Message	Date
Brett Rowan	aa3d105fcb	version: bump version number	2025-07-21 15:41:35 -06:00
Brett Rowan	77f59f6db6	feature: add support for Elphapex DG1 Home Fixes: #311	2025-07-21 10:08:11 -06:00
Brett Rowan	3fa0d96fbb	feature: add support for Iceriver AL3 Fixes: #317	2025-07-21 10:02:06 -06:00
Brett Rowan	e55477a8b8	feature: add support for S19j+ Fixes: #330	2025-07-21 09:51:51 -06:00
Brett Rowan	7d5744ae28	feature: add support for vnish XP Hydro Fixes: #342	2025-07-21 09:48:11 -06:00
Brett Rowan	d4500be10c	feature: add support for a couple alternate models - Antminer S19j Pro+, ANTMINER - Antminer S19 Pro A, VNISH - Antminer S19 XP, VNISH - Antminer L9, VNISH - DG1, ELPHAPEX Fixes: #354	2025-07-21 09:35:00 -06:00
Brett Rowan	7ef2540133	feature: add support for Vnish S19 Hydro Fixes: #355	2025-07-21 09:18:20 -06:00
Brett Rowan	1ea4f4e124	version: bump version number	2025-07-15 08:11:34 -06:00
bbemoll	a8a0e4a5fe	Added support for Antminer S19XH Hydro running on Braiins OS (#353 ) * Add pyasic files * Add pyasic files * Update pyproject.toml * Update pyproject.toml * Added support for Antminer S19XP Hydro running on Braiins OS * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>	2025-07-15 08:10:59 -06:00
Brett Rowan	5f2f6e01da	version: bump version number	2025-07-10 10:56:42 -06:00
Brody	41b4c23d45	Fix API Issue with Bitaxe Miners (#352 ) * added checks to identify which field is None. * better logging * if asicCount is None, try to find it in /system/asic * ran pre-commit	2025-07-10 10:56:22 -06:00
Brett Rowan	b4687f18fd	version: bump version number	2025-05-01 15:15:42 -06:00
Brett Rowan	2437421005	feature: add support for a bunch of BOS and VNish S21 models.	2025-05-01 15:15:18 -06:00
Ryan Heideman	40ebc2773f	Retry and Timeout Changes for espminer (#340 ) * Retry and Timeout Fixes for espminer * Build check fix	2025-05-01 15:07:58 -06:00
Art	b8ae238d23	Fix incorrect computation of active_preset for Antminer VNish. See #338 . (#339 ) * Fix incorrect computation of active_preset for Antminer VNish. See #338. * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * #338 renamed perf_summary to web_perf_summary for clarity and consistency. New API call is done in backward compatibility manner. Data is also retrieved safely * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>	2025-05-01 15:07:11 -06:00
Brett Rowan	2920639b70	version: bump version number	2025-04-27 11:01:10 -06:00
Brett Rowan	bd9144b3de	requirements: bump dependency versions	2025-04-27 11:01:10 -06:00
SKART1	8f7a67d4dc	Fix efficiency_fract property to correctly return computed value. See #334 .	2025-04-19 08:28:44 -06:00
Brett Rowan	a62bea33a7	docs: update docs	2025-04-18 16:15:31 -06:00
pre-commit-ci[bot]	406bcd179c	[pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci	2025-04-18 16:12:55 -06:00
Ryan Heideman	aa87ef7d71	nano3s fixes	2025-04-18 16:12:55 -06:00
SKART1	ec88fbf6aa	Fix #334 efficiency calculation and add computed fields	2025-04-18 16:12:44 -06:00
pre-commit-ci[bot]	e23c86a944	[pre-commit.ci] pre-commit autoupdate updates: - [github.com/python-poetry/poetry: 2.1.1 → 2.1.2](https://github.com/python-poetry/poetry/compare/2.1.1...2.1.2)	2025-04-16 08:41:30 -06:00
Brett Rowan	b81276cb19	version: bump version number	2025-04-16 08:40:36 -06:00
Adrian	8dcc72b1bb	T21 working on LuxOS (#331 )	2025-04-14 12:55:54 -06:00
Timur Taipov	540572356f	feature: add support for S21+ hydro (#326 )	2025-04-14 09:15:06 -06:00
Ryan Heideman	83035a869b	feature: Add Support for Avalon Nano 3s (#329 )	2025-04-12 15:34:45 -06:00
Brett Rowan	4c104a59ff	version: bump version number	2025-04-01 09:24:20 -06:00
Brett Rowan	e708ae3728	bug: remove MSKminer web identification	2025-04-01 09:23:51 -06:00
Wilfred Allyn	a4352816ee	bug: pass atmset param as bool	2025-04-01 07:48:42 -06:00
Will Jackson	336bd9c002	bug: update set_dps configuration to handle optional power and hashrate parameters (#319 ) * bug: update set_dps configuration to handle optional power and hashrate parameters	2025-03-27 11:09:47 -06:00
Wilfred Allyn	e3c917efde	feature: set supports_autotuning True for luxminer	2025-03-26 08:06:38 -06:00
Brett Rowan	4d71012ed6	version: bump version number Closes: #310	2025-03-20 10:46:30 -06:00
Will Jackson	1acdba8ae0	bug: fix set_dps configuration to handle power target parameters correctly (#318 ) * bug: fix set_dps configuration to handle power target parameters correctly * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>	2025-03-20 10:45:48 -06:00
Brett Rowan	5567f26c03	version: bump version number Closes: #316, #310	2025-03-20 09:20:51 -06:00
Brett Rowan	0027485582	bug: fix set_dps tuple cc: #310	2025-03-20 09:20:23 -06:00
Brett Rowan	c9bcb7bab6	feature: add support for S21+ cc: #316	2025-03-19 13:28:03 -06:00
John-Paul Compagnone	0ee261930e	epic: remove guard on expected_hashboards	2025-03-18 09:35:13 -06:00
John-Paul Compagnone	3cfc8dded9	epic: remove v1 from ELITE miner	2025-03-18 09:35:13 -06:00
John-Paul Compagnone	655cf6d0ac	epic: add BlockMiner eLITE, S19k Pro Dualie	2025-03-18 09:35:13 -06:00
Brett Rowan	640dc6d8c2	version: bump version number	2025-03-18 09:00:40 -06:00
Brett Rowan	a572fedb4d	bug: fix some cases where bosminer config could be invalid	2025-03-18 09:00:16 -06:00
Brett Rowan	6c46a7cd71	bug: handle cases where hashboards and fans can be None with unknown types	2025-03-18 08:18:34 -06:00
Brett Rowan	49f42172da	version: bump version number	2025-03-17 14:19:47 -06:00
Brett Rowan	83be80e4bc	bug: handle connection errors in grpc for boser	2025-03-17 14:19:28 -06:00
Brett Rowan	0be9e9d519	feature: add fault_light to influx	2025-03-17 14:17:37 -06:00
Upstream Data	4694c0f774	bug: fix error code handling in list	2025-03-06 11:45:38 -07:00
Brett Rowan	11012b310b	bug: fix delimiter handling	2025-03-04 21:27:28 -07:00
Brett Rowan	8852fab3ee	feature: allow the user to pass a delimiter to as_influx	2025-03-04 20:14:55 -07:00
Brett Rowan	ec1b2ca162	bug: fix bad " " handling in influx	2025-03-04 19:58:44 -07:00
Upstream Data	1f9d4c8c10	bug: swap to lower case booleans	2025-03-04 19:51:48 -07:00
Upstream Data	5bb04b2af4	refactor: round hashrate to 2 decimals for influx	2025-03-04 19:51:48 -07:00
Upstream Data	2e192a1536	feature: update support for influxdb line protocol	2025-03-04 19:51:48 -07:00
Brett Rowan	4da8044bc7	bug: fix bad type hint	2025-03-04 19:51:37 -07:00
Brett Rowan	76078e4d0e	bug: fix wattage limit parsing on luxos	2025-03-04 19:51:13 -07:00
Upstream Data	276a476fab	bug: fix json decode error possibility with avalon nanos	2025-03-03 15:04:22 -07:00
pre-commit-ci[bot]	e0abed4f93	[pre-commit.ci] pre-commit autoupdate (#307 ) updates: - [github.com/pycqa/isort: 6.0.0 → 6.0.1](https://github.com/pycqa/isort/compare/6.0.0...6.0.1) Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>	2025-03-03 14:56:47 -07:00
Ganey	4a67bd5d99	feat: add powerlimit to avalon nano (#302 ) * feat: add powerlimit to avalon nano add power limit to avalon nano * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>	2025-02-26 15:23:18 -07:00
pre-commit-ci[bot]	eb48d04939	[pre-commit.ci] pre-commit autoupdate updates: - [github.com/python-poetry/poetry: 2.0.1 → 2.1.1](https://github.com/python-poetry/poetry/compare/2.0.1...2.1.1)	2025-02-18 08:44:43 -07:00
Upstream Data	c4697728e4	version: bump version number	2025-02-13 15:38:53 -07:00
Upstream Data	de64172073	feature: add support for Hiveon S19kPro	2025-02-13 15:38:28 -07:00
Upstream Data	4d7a13433b	version: bump version number	2025-02-12 16:08:23 -07:00
Adrian	e14a4791b2	it turns out there are 3 hashboards per miner (#293 )	2025-02-12 16:07:46 -07:00