Add dynamic hashrate scaling and estimated efficiency for high-power miners

- Dynamic gauge scaling for miners up to 10+ TH/s (NerdAxeQ++, Magic Miner, Canaan Nano S)
- Device specs database for estimated efficiency when miners don't report expectedHashrate
- Supported devices: Magic Miner BG01/BG02, NerdAxeQ++, Canaan Nano S, BitDSK N5.Rex, Piaxe, Jade, Lucky Miner
- Estimated efficiency shown with ~ suffix (e.g., "95.2% eff~")
- Bump version to 1.2.0

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: ShaeOJ

.github/workflows/release.yml

@@ -55,7 +55,21 @@ jobs:
         with:
           tagName: ${{ github.ref_name }}
           releaseName: 'AxeOS Live! ${{ github.ref_name }}'
-          releaseBody: 'Building for cross platforms - V1.0'
+          releaseBody: |
+            ## What's New in V1.2
+
+            ### Features
+            - **Dynamic hashrate gauge scaling** - Properly displays high-power miners (NerdAxeQ++, Magic Miner BG01/BG02, Canaan Nano S) up to 10+ TH/s
+            - **Estimated efficiency for all miners** - Devices that don't report expected hashrate now show estimated efficiency based on known device specs
+
+            ### Supported Devices for Estimated Efficiency
+            - Magic Miner BG01/BG02
+            - NerdAxeQ++
+            - Canaan Nano S
+            - BitDSK N5.Rex (BM1397)
+            - Piaxe, Jade, Lucky Miner, NerdAxe
+
+            Estimated efficiency is shown with a `~` suffix (e.g., "95.2% eff~")
           releaseDraft: true
           prerelease: false
           args: ${{ matrix.args }}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextn",
-  "version": "0.1.0",
+  "version": "1.2.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 9002 -H 0.0.0.0",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "app"
-version = "0.1.0"
+version = "1.2.0"
 description = "A Tauri App"
 authors = ["you"]
 license = ""

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
   "productName": "AxeOS Live!",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "identifier": "com.axeos.live",
   "build": {
     "frontendDist": "../out",

src/components/miner-card.tsx

@@ -710,22 +710,66 @@ export function MinerCard({ minerConfig, onRemove, isRemoving, state, updateMine
 
   const hashrateDisplay = useMemo(() => {
     if (hashrateInGhs >= 1000) {
-      return { value: hashrateInGhs / 1000, unit: 'TH/s', isFloat: true, max: 3 };
+      // Convert to TH/s for high-power miners
+      const valueInThs = hashrateInGhs / 1000;
+      // Dynamic max scaling for different miner tiers:
+      // - Standard BitAxe: up to 1.5 TH/s
+      // - NerdAxeQ++, Magic Miner BG01/BG02: up to 7 TH/s
+      // - Canaan Nano S and larger: up to 10+ TH/s
+      let max: number;
+      if (valueInThs <= 1.5) {
+        max = 2;        // Small TH/s miners (standard BitAxe overclocked)
+      } else if (valueInThs <= 3) {
+        max = 4;        // Mid-range TH/s miners
+      } else if (valueInThs <= 5) {
+        max = 6;        // Higher-end miners like some Magic Miner models
+      } else if (valueInThs <= 7) {
+        max = 8;        // NerdAxeQ++, Magic Miner BG01/BG02
+      } else if (valueInThs <= 10) {
+        max = 12;       // Canaan Nano S range
+      } else if (valueInThs <= 20) {
+        max = 25;       // Larger miners
+      } else {
+        // For very high hashrates, round up to next 10 TH/s
+        max = Math.ceil(valueInThs / 10) * 10 + 5;
+      }
+      return { value: valueInThs, unit: 'TH/s', isFloat: true, max };
+    }
+    // GH/s mode - also make max dynamic for better gauge utilization
+    let max: number;
+    if (hashrateInGhs <= 500) {
+      max = 600;        // Low-power miners
+    } else if (hashrateInGhs <= 800) {
+      max = 1000;       // Standard BitAxe range
+    } else {
+      max = 1200;       // High-end GH/s range (approaching TH/s)
     }
-    return { value: hashrateInGhs, unit: 'GH/s', isFloat: false, max: 3000 };
+    return { value: hashrateInGhs, unit: 'GH/s', isFloat: false, max };
   }, [hashrateInGhs]);
 
   const freq = state.info?.frequency ?? 0;
   const cardTitle = minerConfig.name || state.info?.hostname || minerConfig.ip;
   const cardDescription = minerConfig.name ? minerConfig.ip : (state.info?.hostname ? `v${state.info.boardVersion}` : '');
 
   // Calculate efficiency percentage (actual vs expected hashrate)
-  const efficiencyPercent = useMemo(() => {
-    if (state.info?.hashRate && state.info?.expectedHashrate && state.info.expectedHashrate > 0) {
-      return ((state.info.hashRate / state.info.expectedHashrate) * 100).toFixed(1);
+  // Uses device-reported expectedHashrate if available, otherwise falls back to estimated value
+  const efficiencyData = useMemo(() => {
+    if (!state.info?.hashRate) return null;
+
+    // Prefer device-reported expectedHashrate, fall back to estimated
+    const expectedHashrate = state.info.expectedHashrate || state.info.estimatedExpectedHashrate;
+    const isEstimated = !state.info.expectedHashrate && !!state.info.estimatedExpectedHashrate;
+
+    if (expectedHashrate && expectedHashrate > 0) {
+      return {
+        percent: ((state.info.hashRate / expectedHashrate) * 100).toFixed(1),
+        isEstimated
+      };
     }
     return null;
-  }, [state.info?.hashRate, state.info?.expectedHashrate]);
+  }, [state.info?.hashRate, state.info?.expectedHashrate, state.info?.estimatedExpectedHashrate]);
+
+  const efficiencyPercent = efficiencyData?.percent ?? null;
 
 
   const StatusBadge = useMemo(() => {
@@ -815,8 +859,14 @@ export function MinerCard({ minerConfig, onRemove, isRemoving, state, updateMine
                   <div className="flex items-center gap-2">
                       {StatusBadge}
                       {efficiencyPercent && (
-                        <Badge variant="outline" className="text-xs">
-                          {efficiencyPercent}% eff
+                        <Badge
+                          variant="outline"
+                          className="text-xs"
+                          title={efficiencyData?.isEstimated
+                            ? `Estimated efficiency based on typical ${state.info?.ASICModel} specs`
+                            : 'Efficiency based on device-reported expected hashrate'}
+                        >
+                          {efficiencyPercent}% eff{efficiencyData?.isEstimated && '~'}
                         </Badge>
                       )}
                       {(state.info?.blockFound === 1 || blockFoundCelebration) && (

src/components/miner-dashboard.tsx

@@ -15,6 +15,7 @@ import { ThemeSwitcher } from './theme-switcher';
 import { GlitchText } from './glitch-text';
 import { useIsMobile } from '@/hooks/use-mobile';
 import { getMinerData } from '@/lib/tauri-api';
+import { getExpectedHashrate } from '@/lib/device-specs';
 
 const FETCH_INTERVAL = 15000; // 15 seconds
 const MAX_HISTORY_LENGTH = 360; // Keep 90 minutes of history (360 * 15s)
@@ -46,6 +47,15 @@ export function MinerDashboard() {
             info.coreVoltage = parseFloat((info.coreVoltage * 1000).toFixed(0));
         }
 
+        // If device doesn't report expectedHashrate, try to estimate from device specs
+        if (!info.expectedHashrate && info.ASICModel) {
+            const estimatedHashrate = getExpectedHashrate(info.ASICModel);
+            if (estimatedHashrate) {
+                info.estimatedExpectedHashrate = estimatedHashrate;
+                info.isEstimatedHashrate = true;
+            }
+        }
+
         const hashrateInGhs = info.hashRate ? info.hashRate : 0;
         const infoInGhs = { ...info, hashRate: hashrateInGhs };
 

src/lib/device-specs.ts

@@ -0,0 +1,123 @@
+/**
+ * Device specifications for miners that don't report expectedHashrate.
+ * These values are used to estimate efficiency when the device doesn't provide its own.
+ *
+ * All hashrate values are in GH/s.
+ */
+
+export interface DeviceSpecification {
+  model: string | RegExp;           // Model identifier (exact string or regex pattern)
+  expectedHashrate: number;         // Expected max hashrate in GH/s
+  description: string;              // Human-readable name
+}
+
+/**
+ * Known device specifications.
+ * Add new devices here as they become available.
+ *
+ * Note: Regex patterns are case-insensitive and match partial strings.
+ * Order matters - more specific patterns should come before generic ones.
+ */
+export const DEVICE_SPECIFICATIONS: DeviceSpecification[] = [
+  // Magic Miner devices
+  {
+    model: /Magic[- ]?Miner[- ]?BG02/i,
+    expectedHashrate: 6800,          // Magic Miner BG02 ~6.8 TH/s
+    description: 'Magic Miner BG02'
+  },
+  {
+    model: /Magic[- ]?Miner[- ]?BG01/i,
+    expectedHashrate: 5500,          // Magic Miner BG01 ~5.5 TH/s
+    description: 'Magic Miner BG01'
+  },
+  {
+    model: /Magic[- ]?Miner/i,
+    expectedHashrate: 5500,          // Generic Magic Miner fallback
+    description: 'Magic Miner'
+  },
+
+  // NerdAxe devices
+  {
+    model: /NerdAxe[- ]?Q\+\+/i,
+    expectedHashrate: 5000,          // NerdAxeQ++ ~5 TH/s
+    description: 'NerdAxeQ++'
+  },
+  {
+    model: /NerdAxe/i,
+    expectedHashrate: 500,           // Standard NerdAxe ~500 GH/s
+    description: 'NerdAxe'
+  },
+
+  // Canaan devices
+  {
+    model: /Canaan[- ]?Nano[- ]?S/i,
+    expectedHashrate: 8000,          // Canaan Nano S ~8 TH/s
+    description: 'Canaan Nano S'
+  },
+  {
+    model: /Nano[- ]?S/i,
+    expectedHashrate: 8000,          // Canaan Nano S (short name)
+    description: 'Canaan Nano S'
+  },
+
+  // Piaxe devices
+  {
+    model: /Piaxe/i,
+    expectedHashrate: 500,           // Piaxe ~500 GH/s
+    description: 'Piaxe'
+  },
+
+  // Jade devices
+  {
+    model: /Jade/i,
+    expectedHashrate: 500,           // Jade ~500 GH/s
+    description: 'Jade Miner'
+  },
+
+  // Lucky Miner devices
+  {
+    model: /Lucky[- ]?Miner/i,
+    expectedHashrate: 500,           // Lucky Miner ~500 GH/s
+    description: 'Lucky Miner'
+  },
+
+  // BitDSK devices (BM1397 chip)
+  {
+    model: /BitDSK[- ]?N5[- ]?Rex/i,
+    expectedHashrate: 300,           // BitDSK N5.Rex ~300 GH/s (BM1397)
+    description: 'BitDSK N5.Rex'
+  },
+  {
+    model: /N5[- ]?Rex/i,
+    expectedHashrate: 300,           // N5.Rex ~300 GH/s (BM1397)
+    description: 'BitDSK N5.Rex'
+  },
+  {
+    model: /BitDSK/i,
+    expectedHashrate: 300,           // Generic BitDSK fallback
+    description: 'BitDSK'
+  },
+];
+
+/**
+ * Look up device specification by ASIC model string.
+ * Returns null if no matching specification is found.
+ */
+export function getDeviceSpecification(asicModel?: string): DeviceSpecification | null {
+  if (!asicModel) return null;
+
+  return DEVICE_SPECIFICATIONS.find(spec => {
+    if (typeof spec.model === 'string') {
+      return asicModel.toLowerCase() === spec.model.toLowerCase();
+    }
+    return spec.model.test(asicModel);
+  }) || null;
+}
+
+/**
+ * Get expected hashrate for a device, returning null if unknown.
+ */
+export function getExpectedHashrate(asicModel?: string): number | null {
+  const spec = getDeviceSpecification(asicModel);
+  return spec?.expectedHashrate ?? null;
+}

src/lib/types.ts

@@ -26,6 +26,8 @@ export type MinerInfo = {
   nominalVoltage?: number;
   hashRate?: number; // MHS
   expectedHashrate?: number;
+  estimatedExpectedHashrate?: number; // Estimated from device-specs when device doesn't report
+  isEstimatedHashrate?: boolean;      // Flag indicating if expectedHashrate is estimated
   errorPercentage?: number;
   bestDiff?: string;
   bestSessionDiff?: string;