Compare commits

...
61 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 da0d1582be scan: cap identification concurrency at 128 to fix Braiins value dropout (R4)
Round 17 R4. Scanning most values from Braiins OS units failed under a
full fleet scan: a /24 returned watts=0 and no best-share/temps/fw for
Braiins miners (and dropped a few responders entirely), while the same
miner scanned in isolation populated fully.

Root cause: asic-rs picks a scan concurrency of 1000 for any range up to
/22, so a /24 fires all ~254 address probes at once. Over a real link
(the fleet is reached across a WireGuard VPN, and a subnet full of dead
IPs holds every TCP connect open for the whole identification timeout)
that burst starves the per-responder get_data. A Braiins miner fans out
~12 authenticated REST calls; under the burst they drop miner/stats, so
"most values" come back blank. It is not FD exhaustion (nofile is 500k),
not the per-call timeout, and not an auth race.

Fix: cap identification concurrency at 128 in the app (GUI scan +
miner_probe). On the live fleet 128 was the highest cap that stayed fully
reliable -- 192 already dropped responders, 254 blanked a Braiins miner.
A /24 still finishes in ~35s; larger ranges just take proportionally
longer and stay correct.

Belt-and-suspenders in the braiins backend (patch 0016): single-flight
the login (one auth instead of ~12 concurrent) and widen the defensive
get_data timeout 5s -> 15s.

Verified live: 10.4.1.0/24 now populates both Braiins corpus miners
(.27 watts=2748 best=55217110, .83 watts=2749) fully and misses no
responders (65/65). SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 09:59:27 -06:00
noahandClaude Opus 4.8 7f802c568f Scan progress: smooth per-address counter (was jumping ~1%/second)
The scan counter jumped in big steps (e.g. +45 for a 4590-address scan) because
(a) progress was only emitted every total/100 addresses and (b) the drain timer
ran once per second, so the gauge only refreshed ~1 Hz. The +45 was total/100, not
a chosen value.

Fix, both cheap:
- scan.rs emits progress per address (throttled only above 5000 addresses to bound
  channel traffic) instead of every 1%.
- ui.rs runs the scan/drain timer at 200 ms (5 Hz) so the counter climbs smoothly;
  drain_scan coalesces the many per-address updates into ONE gauge/status update
  per drain (no extra repaints). A tick accumulator keeps the once-per-second work
  (auto-rescan countdown, idle status) at 1 Hz despite the faster tick.

Net: the counter now climbs several times a second in small increments; overhead
is negligible (unbounded mpsc sends are cheap and the gauge still repaints once per
tick). No user-facing setting added -- the smoothness is size-independent.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 09:21:33 -06:00
noahandClaude Opus 4.8 86338062a5 Round 17 B (part 2, GUI): timezone / change-password / factory-reset dialogs + BOS fix
Wire G10/G11/G12 into the GUI (they already had CLI verbs in part 1):
- MinerCaps gains timezone / change_password / factory_reset (probed from the
  matching supports_*() at scan time; intersect + any_control + is_empty updated).
- ConfigAction gains Timezone(String) / ChangePassword(String) / FactoryReset with
  labels + apply arms. Timezone/FactoryReset go through apply_action(&dyn Miner);
  ChangePassword takes &mut self so it runs on the owned miner in the action loop.
- ui.rs: a shared PromptKind (Power/Tuning/Timezone/Password) generalises the
  value prompt (timezone is IANA-validated before firing; password is non-empty);
  factory-reset uses the confirm dialog with a strong WIPES-config/DHCP warning.
  New gated context-menu items: Set timezone, Change password, Factory reset.

Backend fix (asic-rs patch 0015): BOS send_command treated an empty 2xx body as a
parse error, so change_password reported Ok(false) on success. Empty 2xx is now
Null (success). Found + fixed while live-verifying G11.

Verified live on Braiins 10.4.1.27: full change-password round-trip (root ->
bftest2 -> read with new pw -> restore root), all Ok(true), unit left on root/root.
Timezone shares the CLI-verified set_timezone_config path. Factory-reset is wired +
gated but intentionally NOT live-fired: its behaviour is unrecoverable per firmware
(can revert LuxOS to stock / reset network to DHCP and lose the unit) -- needs a
truly sacrificial console-attached unit. GUI selftest + 89 unit tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 08:58:00 -06:00
noahandClaude Opus 4.8 c4c85d5b3d Round 17 B (part 1, CLI): timezone / change-password / factory-reset verbs (G10/G11/G12)
Round B wires the already-complete SupportsTimezoneConfig / ChangePassword /
FactoryReset backends to the toolkit. Part 1 adds the committed CLI surface
(GUI dialogs follow in part 2):
- `timezone <ip> [<IANA>]` - read (no arg) or set the timezone (gated on
  supports_timezone_config: Braiins/VNish/ePIC).
- `passwd <ip> <newpass>`  - change the web/API password (gated).
- `factoryreset <ip>`      - factory reset (gated).
Each is capability-gated and the usage banner marks passwd/factoryreset DANGEROUS.

Verified live: timezone set/read/restore end-to-end on Braiins 10.4.1.83
(set America/Edmonton -> read back -> restore Etc/GMT, all Ok). change-password
and factory-reset are implemented + gated but NOT live-run: both are destructive
on the shared corpus (change-password breaks the default auth every other test
relies on; factory-reset can reset a unit to DHCP and lose its IP) -- they need a
dedicated sacrificial/console-attached unit to verify live.

Also: ci/compute-version.sh now treats crates/alkane-gui/src/bin/* as a UI change
so CLI-tool changes trigger a release.

Note: the VNish timezone READ errors ("Unrecognised VNish timezone GMT, expected
GMT+N/-N") is a pre-existing vnish backend parse quirk, separate from this wiring.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:58:43 -06:00
noahandClaude Opus 4.8 25c8ccf1ff Round 17 A (part 2, G13): LuxOS pool ops privileged + removepool
The luxminer pool write commands (addgroup/groupquota/removegroup/addpool/
switchpool/enablepool/disablepool) sent privileged=false -> no session_id, which
fails with "Missing session_id" on password-set LuxOS units (all other LuxOS
writes are already privileged). Flipped all seven to privileged=true and added the
missing removepool. asic-rs patch 0014.

Verified no regression on default corpus unit 10.4.1.60 (set_pools_config still
applies). The password-set failure needs a password-set LuxOS unit to verify live.

Round A remaining: G8 (constraints/limits reads) and G14 (telemetry enrichment) are
deferred to the rounds that consume them (G8 -> the tuning/cooling dialogs in C/D;
G14 -> detail-panel/tooltip work) rather than built as unused plumbing now.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:47:18 -06:00
noahandClaude Opus 4.8 307539543d Round 17 A (part 1): committed write CLI (G1) + best-share reads (G9) + parity roadmap
Executing the aftermarket config+scan parity plan (docs/aftermarket-parity-roadmap.md,
from the ultracode writer/adversary workflow). This is Round A's foundation + first cheap win.

G1 - miner_probe is now a committed config+scan CLI, not a local-only diagnostic. Added
capability-gated write verbs: `light <ip> <on|off>`, `pause`, `resume`, `restart` (alongside
the existing setpl/setpools/led), a READ vs WRITE usage banner warning that write verbs mutate
(use the test-bed miners, not production), and best_share/session_best_share columns in `scan`.
Verified: `light on`/`light off` on a LuxOS corpus unit -> Ok(true) (reversible).

G9 - implement GetBestShare/GetSessionBestShare (were empty impls feeding two dead columns):
Braiins v26_04 reads miner/stats -> /miner_stats/best_share; LuxMiner v1 reads summary ->
/SUMMARY/0/Best Share + Best Session Share. Both reuse already-collected responses (no extra
calls). asic-rs patch 0013. Verified live read-only: BOS 10.4.1.83 = 130601978 (no session on
BOS); LuxOS 10.4.1.60 = 638881749/638881749, 10.4.1.67 = 497802665/497802665 -- exact API match.
(WhatsMiner stock summary exposes no best-share on the tested units; deferred. The roadmap's BOS
source "miner_stats" was a typo for the real "miner/stats" endpoint.)

Also commits the parity roadmap (docs/) as the plan of record for rounds A-F.
Round A remainder (G8 constraints reads, G13 LuxOS pool-op privileged fix, G14 telemetry
enrichment) follows; G13 needs a password-set LuxOS unit to fully verify.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:36:59 -06:00
noahandClaude Opus 4.8 561c50e5dc GUI round 16 (#4/#5/#6/#7): UMC OS colour, pool + restore dialog polish, new icons
- #4 ePIC miners report their firmware family as "UMC OS"; colour that row light
  blue in the Firmware column (was falling through to the theme default / black),
  matching the existing ePIC colour.
- #5 Configure-pools dialog: widen the "+" buttons so the glyph shows; the dropdown
  "add" entry now reads "Add new"; user-added values can be removed via a "Remove
  saved value" submenu (pool_prefs::remove_saved); dropped the intro tidbit and
  narrowed the window.
- #6 Restore-to-stock confirmation: the miner list is now a height-capped,
  scrollable text box instead of one unbounded label, so restoring hundreds at
  once stays usable. Removed the "Flash firmware..." right-click option for now
  (the in-app flash path is parked while it is reworked).
- #7 Replaced the brain (control board) and fan Health icons with the new
  operator-supplied artwork, image-traced from PNG to SVG (potrace) and stripped
  of explicit fills so the Health column's per-state recolouring still applies.

Headless selftest passes (fixtures render through the real widgets); all GUI unit
tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 17:43:45 -06:00
noahandClaude Opus 4.8 74b97162f5 GUI round 16 (#1/#2/#3): per-component health attribution + tooltips
Health icons and their hover tooltips now reflect the miner's actual per-component
faults instead of a generic "faulted".

- #1 Each Health icon's tooltip carries the specific fault text for THAT component
  (e.g. "Slot 0 error reading chip id.", "Power current error."), sourced from
  asic-rs's structured MinerMessage.component (HashBoard idx / PowerSupply / Fan /
  ControlBoard) rather than fragile string matching on the summary. New MinerRow
  `faults` field + FaultComponent/Fault types; scan.rs maps messages -> faults.
- #2 A power-supply fault turns the bolt icon red, lists the PSU faults on its
  tooltip, and greys (not reds) every hashboard -- the boards can't be powered or
  tested, so they read "unpowered (PSU fault)".
- #3 When the miner reports board-specific faults, ONLY the named boards are red;
  the rest stay green. A whole-miner stall zeroes every board's hashrate, which
  previously reddened working boards the error codes actually exonerate.

Backend enabler (asic-rs patch 0012): the WhatsMiner V1 backend now sources faults
from get_error_code (like V2/V3; its summary error fields are empty on H6OS), and
a targeted repair fixes firmware that emits an invalid bare-pair error_code array.

Verified live: 10.7.1.231 (PSU) greys its boards + shows the 4 PSU faults on the
bolt; 10.8.1.234 (540/541/561) reds boards 1+2 and leaves board 3 green. Unit
tests cover the attribution and the malformed-array repair; all suites pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 17:30:18 -06:00
noahandClaude Opus 4.8 75663f4c23 asic-rs: implement LuxOS set_power_limit (via profiles); document ePIC PSU gating
Follow-up to the Round 15 corpus. The toolkit reported supports_power_limit=false
for LuxOS and ePIC; investigated both against the live corpus (S19j Pro).

LuxOS was genuinely under-reporting: it tunes by discrete named profiles that each
carry a Watts rating (the `profiles` RPC gives Step + Watts), applied via
profileset -- pure frequency/voltage tuning, no PSU dependency. Implemented
SetPowerLimit to map the requested watts to the highest profile whose Watts does
not exceed it (or the lowest profile when the target is below all of them). The
pure mapping (parse_profile_watts + select_profile_at_or_below) has a unit test.
Live-verified: set_power_limit(2500) on an S19j Pro picked step -4 (2385 W) and
the miner's active profile became 445MHz/-4.

ePIC is left at false, now with a comment explaining why: PowerPlay's only true
power-limit path is the PowerTune perpetual-tune algorithm, which the firmware
gates on the PSU -- on a fixed-voltage Bitmain APW12 (S19j Pro) it answers "Power
optimization is not supported by this PSU". That is a per-PSU runtime property the
synchronous capability check cannot see, so reporting true would over-advertise on
most reflashed Antminers. Hashrate tuning remains available via set_tuning_config.

Captured as asic-rs patch 0011. luxminer + epic crate tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 16:40:38 -06:00
noahandClaude Opus 4.8 9eb6a0f229 asic-rs: fix Antminer locate-LED (and reboot) on legacy web-UI firmware
Round 15 #7. The "flash the light" action failed on old (< 2023.07) Antminer
firmware -- the LuCI web-UI generation, e.g. the Z15/Z15J. set_fault_light
returned Ok(false) on live hardware while appearing to "succeed".

Root cause (confirmed on a live Z15): that firmware's blink.cgi ignores the JSON
body {"blink":"true"} the backend sent (answering 200 with an empty text/html
body, so the JSON parse fails and the error is swallowed into Ok(false)). Its own
blink.html POSTs a form field action=startBlink/stopBlink and reads state back via
action=onPageLoaded -> {"isBlinking":bool}; the action handler also often answers
401/500 even on success, so HTTP status is not a reliable signal.

Fix (v2020 backend): add a form-encoded POST helper; blink() now fires
action=startBlink/stopBlink, ignores the unreliable status, and reads the real
state back via onPageLoaded; set_fault_light reports success only when the observed
isBlinking matches the request. The LightFlashing read is routed to the same path
(get_blink_status.cgi is 404 here) and remapped to {"blink":bool}.

Also switch reboot() from POST to GET to match the same firmware's reboot.html (the
Restart action was affected); not live-fired, to avoid rebooting production miners.

Captured as asic-rs patch 0010. Also teach ci/compute-version.sh that vendor/* and
thirdparty/asic-rs/* are backend changes, so vendored fixes trigger a release.

Verified live: Z15/Z15J now return Ok(true) with the light genuinely toggling;
VNish (4 control boards) and WhatsMiner (H6OS/H616) unchanged; antminer tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 15:19:05 -06:00
noahandClaude Opus 4.8 bafbd519bb GUI round 15 (part 2, #13): Settings menu, localization, Logs page
Add a Settings menu (the old Credentials toolbar button is now "Settings")
containing Credentials, a Language sub-menu, and a Logs page.

Localization (#13): a small i18n layer -- visible strings are wrapped in
t("English") and looked up per language, falling back to English. Built-in
translations for Mandarin, Russian, French, Spanish and Portuguese cover the
toolbar buttons, KPI captions and table column headers; changing the language
re-labels them live (columns via a table rebuild) and localizes dialogs as
they open. The choice persists under the config dir and loads at startup.
(Dialog-internal strings and status text are not yet fully translated -- the
framework is in place to extend them.)

Logs page (#13): an in-app activity log (scans, operations applied, export,
language change) shown in Settings > Logs with Refresh / Clear.

New wx-rs bridge: menu sub-menus (menu_append_submenu). Bridge patches
0002/0003 regenerated. Unit tests + headless selftest pass; the Chinese UI
was verified rendering end to end.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 14:54:10 -06:00
noahandClaude Opus 4.8 0d19e958f0 GUI round 15 (part 1): pool dropdowns, aligned health icons, export, more
Twelve of the round-15 items (the code items; the live-hardware flashing/
testing and the settings/localization/logs work follow separately):

#1 Configure-pools: three pool rows (address, account, worker, password),
each field with a "+" dropdown of presets (top-11 BTC pool stratums;
worker-name placeholders) plus user-addable, persisted entries. Worker
picks insert at the cursor rather than replacing. Writes up to three pools
per miner via set_pools_config, worker expanded per unit.

#2 PIC detection: replace the broken SSH i2cdump (it read 0x48, the temp
sensor, not the PIC) with a model lookup -- no firmware exposes PIC over the
network, so infer it from the model (noPIC: S19k Pro, S21 family, T21,
explicit noPIC; PIC: rest of the S19 line).

#4 Zoom: an editable percent field in the status bar (type an exact scale)
and Ctrl +/- / Ctrl+0 to zoom in/out/reset.

#5 Health icons align in fixed slots (power, control, fans, hashboards);
miners with fewer fans/boards leave a gap so hashboards still line up. The
max fan/board counts are computed parametrically from the fleet.

#6 Light: the locate-light column is on by default (last), shown as a
green-over-red beacon flashing quickly instead of a single amber dot.

#8 The bottom-left status line is now scan-only; operation progress lives in
the Health column (per miner) and failures in the bottom-right indicator.

#9 / #10 / #11: drop the Credentials-dialog blurb; move the scan-ranges
format help to a tooltip; make Restore-to-stock a plain confirmation (no
typed keyword, no warning wall).

#12 Z15 fans: the v2020 backend now reads fans from higher fan slots
(the Z15 reports fan3/fan4 with fan1/fan2 = 0). Vendored patch 0009.

#14 Export: an Export button writes every scanned data point to a CSV, one
value per cell (lists expanded to indexed columns) -- complete and
machine-readable, unlike the on-screen table.

#15 Health tooltips are per-icon: hovering a specific fan or hashboard shows
just that component's state, with errors attributed to the board that names
them in the message.

New wx-rs bridge surface: widget tooltips, save-file dialog, insert-at-cursor,
status-bar zoom entry + Ctrl+/-, the light beacon + alignment-gap sentinels,
and per-icon cell tooltips (bridge patches 0002/0003 regenerated). Unit tests
(worker templates, PIC map, CSV export, health) + headless selftest pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 14:43:00 -06:00
noahandClaude Opus 4.8 368f992404 GUI round 14: bigger health icons, table zoom, pool config, op progress
Seven items from the round-14 list:

#1 Health icons: render bigger (nearly the full row height) and packed
tighter so a row of component icons stays large and readable; the icon
sizes also scale with the new table zoom.

#2 Scan timeout: a per-miner scan timeout (asic-rs identification timeout)
is now configurable in the Scan-ranges dialog and persisted, so slow
miners can be given longer or fast scans sped up.

#3 Table zoom: a slider in the bottom-right of the status bar scales the
whole table together -- font, component icons, row height, and column
widths -- from 50% to 250% (default 100%). Implemented in the wx bridge
(no Rust round-trip); the custom SegmentRenderer draws its text in the
control's scaled font so the coloured columns zoom like the native ones,
and the zoom is re-applied after a column rebuild so it survives show/
hide/reorder.

#4 Operation progress: while an operation runs on a miner (refresh,
config/light/power/tuning action, firmware flash, restore-to-stock, access
check), its Health cell shows the progress text ("refreshing…",
"restarting…", "setting pools…", …) instead of the component icons, and
reverts to icons when the operation finishes.

#5 Remove the SSH PIC probe: the "Detect PIC (SSH)..." right-click flow and
its dialog, background probe, and pic_probe module are removed. PIC state
stays a best-effort model-string heuristic in the PIC column.

#6 WhatsMiner access: WhatsMiners now show the locked/unlocked padlock in
the Access column instead of a blank cell -- since round 12 #8b gave the
V1/V2/V3 backends their control commands, the same capability heuristic the
other brands use applies to WhatsMiner too (the token access check still
refines a read-only unit to "locked").

#7 Configure pools: a right-click "Configure pools..." flow (gated on the
new pools capability) with three fields -- pool address and account
(required) and an optional worker name. The worker name expands per miner
from case-insensitive placeholders scanned from each unit: {ip1}..{ip4},
{serial}, {mac} (colons removed), {nameplate-hr} (rated TH), {brand},
{model}, {submodel}, {cpu}, {cb}, {firmware}, {hostname}. Applied via
asic-rs set_pools_config on a background thread reusing the action plumbing.

wx-rs bridge patches 0002/0003 regenerated. No vendored asic-rs changes.
Unit tests (component health, worker-template expansion) + headless
selftest pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 12:20:06 -06:00
noahandClaude Opus 4.8 ecdb2fab9d GUI round 13: health-icon column, Z15J algorithm, Credentials + Columns dialogs
Five items from the round-13 list:

#4/#5 Z15 hashrate / unknown algorithm: a Z15J reports its model as
"ANTMINER Z15J", which asic-rs' alias table did not recognise, so it
deserialised to Unknown and its Sol/s hashrate was left un-bucketed as
"unknown hashrate". Add a first-class Z15J model (Equihash) in the makes
crate, plus a family-letter fallback in the v2020 backend so other
un-tabled Antminer models still resolve an algorithm (Z->Equihash,
L->Scrypt, S/T->SHA-256; ambiguous K/DR stay Unknown). Live-verified on
the Z15/Z15J fleet. Carried as vendored patch 0008.

#3 Component-health column: a new Health column (power, control board,
each fan front-to-back, each hashboard) drawn as coloured icons -- grey
unreachable, red down, yellow sub-optimal, green healthy -- replacing the
Errors, Boards and Status columns. Left-clicking the header cycles the
sort through the component facets (overall/power/fans/hashboards); the
active facet shows as a tag beside the chevron. Errors move to the cell
tooltip. Four operator-supplied Font Awesome icons registered via the
existing SVG-in-cell renderer (new SHAPE_BOLT/BRAIN/FAN/CHIP sentinels).

#2 Credentials: rename the "Set scan credentials" button to "Credentials"
and make the per-firmware defaults the main dialog (the global "all
firmwares" login is folded in as the top row).

#1 Columns dialog: narrower; new Alphabetical and Categories sort buttons
(via a Column::category grouping and a wxbr_reorder_set_order bridge fn);
one mouse handler that does both drag-to-reorder and drag-to-rubber-band-
select (the old BEGIN_DRAG binding had silently disabled rubber-band
selection); Ctrl+A select-all and Ctrl/Shift+Up/Down extend-selection.

wx-rs bridge patches 0002/0003 regenerated. Unit tests + headless
selftest pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 11:06:05 -06:00
noahandClaude Opus 4.8 a75fe5ba52 GUI round 12 (#8a): restore aftermarket firmware to stock (right-click)
Adds a right-click "Restore to stock firmware..." action for aftermarket-firmware
miners, behind a strong typed (RESTORE) confirmation that lists exactly which
miners will be reverted. All three supported firmwares self-restore for free (the
stock image is retained on-device; no image is uploaded), per the live-confirmed
flows in the miner-firmware wiki:
- VNish:   POST /api/v1/unlock -> bearer -> POST /api/v1/firmware/remove (~3 s)
- LuxOS:   luxminer :4028  logon -> uninstallluxos (credential-free)
- Braiins: SSH `uninstall.sh` (re-flashes the on-NAND stock backup)

New crates/alkane-gui/src/restore.rs runs the revert on a background thread with a
result channel and a fake-scan demo path; VNish password reuses the round 12 #13
per-firmware default, Braiins uses the saved SSH login. The menu item only appears
when the selection includes a revertible firmware.

Also fixes an event-routing bug introduced in #12/#8a: the log-viewer Close and
restore OK/Cancel buttons were mistakenly handled in the MenuItem match instead
of ButtonClicked, so they never fired -- this restores #12's log-viewer Close
button too. Moved them to the ButtonClicked match.

Verified under Xvfb + openbox: the menu item shows for VNish/LuxOS/Braiins rows;
the confirm dialog renders the targets and typed gate; typing RESTORE runs the
(fake) revert and closes the dialog; a wrong value is rejected and the dialog
stays open. restore unit test + GUI self-test pass. NOTE: no live restore was
run -- the designated test range 10.2.1.0/24 is currently empty, and production
miners were not touched; the live flash awaits a unit in that range.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 11:39:49 -06:00
noahandClaude Opus 4.8 f1fb2f8623 GUI round 12 (#8b, part 2): WhatsMiner control commands on the older V1 backend
asic-rs already implements the full WhatsMiner proprietary control+monitoring
surface for V2/V3 (adjust_power_limit, set_led, update_pools, reboot, power_off/
power_on + all reads), so the modern fleet was already covered. The gap was the
V1 backend (firmware < 2022-07-29): it declared no control commands, so older
units could only be monitored and the GUI's capability actions never appeared.

V1-era firmware speaks the same classic btminer token write API as V2 (the round
12 #8b part 1 access-probe handshake proved V1 accepts get_token + AES), so the
V1 backend now reuses V2's proven RPC client for writes and implements the same
control commands: set_fault_light, set_power_limit, update_pools, restart, pause,
resume (HasAuth routes the admin password to the write RPC).

Verified live on a V1 unit that the token AES key (password) is accepted; the
write path is byte-identical to V2's live-validated one. Some V1 units keep their
API in read-only mode and answer writes with Code 45 "can't access write cmd"
until an operator enables write access via the WhatsMiner Tool -- a per-device
setting; the backend now fails those gracefully instead of hiding the command.
40 whatsminer crate tests pass; GUI self-test passes. Patch queue adds 0007.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 11:13:01 -06:00
noahandClaude Opus 4.8 a6d286a147 GUI round 12 (#12): scan miner logs over the firmware API (PIC + metrics)
Adds a right-click "View log (API)..." action that fetches a miner's log through
its firmware API and regex-scans it -- the "logs through API" path for PIC
detection and other metrics without SSH.

Per firmware (crates/alkane-gui/src/log_scan.rs, curl-based like the access
probe, stdout drained on a thread so a large log never deadlocks the pipe):
- VNish: POST /api/v1/unlock -> bearer -> GET /api/v1/logs/miner (the full miner
  log: PSU init, per-chain chip detection, tuning, errors).
- Stock Antminer: GET /cgi-bin/log.cgi (digest); older models (Z15) that do not
  serve it are reported as "no log over its web API".
- WhatsMiner: get_error_code on :4028 (unauthenticated) formatted as the log.

The summary regex reports PIC status ("not present (no-PIC miner)" / "present --
<version line>"), the latest per-chain chip-detection line, and recent errors
from the log history. Creds reuse the round 12 #13 per-firmware defaults (VNish
password, else "admin"; Antminer web login from the saved global creds).

Verified live: VNish S19j Pro (10.7.1.25) log -> "PIC: not present (log reports a
no-PIC miner)" + chains + recent errors; WhatsMiner (10.8.1.45) -> its active
error codes; Z15 (10.5.1.196) -> honest "no log over its web API". Unit tests for
the summary + a headless ALKANE_LOG_SCAN diagnostic; self-test passes.

Note: WhatsMiner fault codes already surface in the Errors column via asic-rs's
get_error_code -> messages; this adds the raw-log view and the PIC scan on top.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 10:54:52 -06:00
noahandClaude Opus 4.8 3ba3211371 GUI round 12 (#8b, part 1): correct WhatsMiner lock/access with the :4028 token API
WhatsMiners were shown "locked/unauthenticated" even with their default login.
Two causes, both fixed:

- The access probe hit an Antminer-only endpoint (/cgi-bin/get_miner_conf.cgi via
  curl --digest) for EVERY make; WhatsMiners answer 307 there, so the check was
  always indeterminate. Added a real WhatsMiner check over its :4028 token API:
  get_token (unauthenticated) -> derive the AES key from the password (md5crypt +
  SHA256, the same scheme the vendored asic-rs whatsminer backend uses) -> send a
  NON-mutating encrypted `summary`. An encrypted reply means the password was
  accepted (unlocked); a plaintext "enc json load err" means rejected (locked).
  probe_access now branches on the miner brand. Candidate passwords: a per-firmware
  override (round 12 #13) if set, else the factory defaults admin (V1/V2) and super
  (V3); all attempts are non-mutating so trying both is safe.
- The scan-time lock guess (!caps.any_control()) falsely marked older WhatsMiners
  locked because they route to the asic-rs V1 backend, which declares no control
  commands even though the miner is controllable via the token API. WhatsMiner
  lock state is now left unknown at scan time and decided by the real probe.

Live-verified on the fleet: older 20220422.18.REL units (10.8.1.176, 10.7.1.196)
and newer M30S+ (10.8.1.45) all report UNLOCKED with the default admin login;
the Antminer digest path is unchanged (Z15 -> 200 with root/root -> unlocked).
Added a headless `ALKANE_ACCESS_PROBE="<ip> <make>"` diagnostic and a
deterministic AES unit test. Self-test passes.

Note: this is the access/lock half of #8b. Implementing the full reverse-
engineered WhatsMiner command set (control + monitoring over the token API) is
tracked separately.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 09:29:43 -06:00
noahandClaude Opus 4.8 c8d5cd71c4 GUI round 12 (#10): Z15 realtime hashrate + control board, from data we can read
Stock Antminer Z15/Z15J were mis-handled: their control board showed blank and
their realtime hashrate looked absent next to the target. Root cause: the version
detector only read summary.cgi, which the Z15 does not serve (404), so version
detection returned nothing and AntMiner::new fell through to the newest backend,
which mis-parsed the miner. Fixes (all in the vendored asic-rs antminer crate,
verified live on 10.5.1.x):

- Backend routing: fall back to the cgminer :4028 `version` RPC's CompileTime when
  summary.cgi is absent, so a 2020 Z15 routes to the v2020 backend instead of the
  default newest one.
- Control board "read, not guess": the Z15 has no miner_type.cgi, so read the
  control board from the kernel build string in get_system_info.cgi
  ("Linux 4.6.0-xilinx-..." -> Xilinx). The ControlBoardVersion field now carries
  both the subtype and the kernel; the parser prefers the explicit subtype and
  falls back to the kernel marker (xilinx/zynq -> Xilinx, aml/meson -> AMLogic).
- Malformed cgminer stats: the Z15 emits a stats array with no commas between its
  objects (invalid JSON serde rejected, which dropped every stats-derived field).
  Insert the missing separators before parsing (a no-op on valid responses),
  restoring expected hashrate, fans, hashboards and uptime. Expected hashrate now
  gets the same Equihash Sol/s reinterpretation as the realtime rate, so both read
  on one scale (e.g. 144k / 320k) instead of expected reading ~1e6x larger.

Live result: Z15/Z15J now report control board "Xilinx" and realtime/expected
hashrate on the same scale. asic-rs antminer crate tests (35) pass; GUI self-test
passes. Vendored source + refreshed checksum committed; patch queue adds 0006.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 08:59:53 -06:00
noahandClaude Opus 4.8 c74e8ebaca GUI round 12 (#6): fade the locate-light dot in and out
The Light column's flashing-light dot now pulses (fades between ~30% and 100%
opacity over a ~1.6 s cycle) instead of sitting static, so a flashing locate
light reads as live.

- A distinct SHAPE_PULSE_DOT sentinel marks the fading dot, so only the locate
  light pulses -- the hashboard health dots stay solid.
- A wxTimer in the bridge advances an animation phase and, each 100 ms tick, emits
  a row change so the custom cell renderer re-runs (a plain Refresh() does not
  re-invoke a custom renderer under wxGTK's cell caching); the renderer blends the
  dot toward its cell background by the phase. The timer runs only while a visible
  row's light is actually flashing -- fill_rows calls set_light_pulse(true/false)
  -- so there is no idle repaint loop.

Verified under Xvfb: with the fixture whose locate light flashes and the Light
column shown, the dot's measured intensity oscillates across frames (strong amber
to a pale tint and back); with no flashing light the timer stays stopped.
Self-test still passes. wx-rs patches 0002/0003 regenerated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 00:20:37 -06:00
noahandClaude Opus 4.8 282f0b195c GUI round 12 (#13): editable per-firmware default scan credentials
Adds a per-firmware default-login editor so the operator can set the discovery
credentials each firmware is probed with, rather than a single global pair.

- credentials.rs: a per-firmware store (firmware-credentials.txt, 0600, one
  "name<TAB>user<TAB>pass" line per firmware) keyed by the asic-rs firmware
  registry's Display name -- the same key the factory uses for
  with_firmware_discovery_auth. A firmware_default_creds() table seeds the editor
  with each firmware's shipped default (mirrors the asic-rs backends' default_auth
  constants; asic-rs does not expose them at the entry level).
- configured_factory() precedence is now: a per-firmware override wins; else the
  single global scan credential (unchanged back-compat) applies to every backend;
  else the backend's own default_auth. Nothing saved -> plain MinerFactory::new().
- UI: the "Set scan credentials..." dialog gains a "Per-firmware defaults..."
  button opening an editor that lists every firmware in the compiled-in registry
  (read at runtime, not hard-coded) with editable user/pass fields prefilled from
  the saved override or the shipped default. Save persists only rows that differ
  from the shipped default (so defaults evolve with asic-rs and the file stays
  minimal); Reset to defaults clears all overrides.

Verified under Xvfb: the editor lists all 16 registry firmwares with correct
default logins (AntMiner root/root, WhatsMiner admin/admin, VNish blank/admin,
UMC OS blank/letmein, ...). Round-trip/permissions/precedence covered by a unit
test (folded into the existing HOME-scoped credentials test to avoid a parallel
HOME race); self-test still passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 00:06:37 -06:00
noahandClaude Opus 4.8 1857a9e1a0 GUI round 12 (#9, #11): SVG icons in table cells (access padlocks + status)
Adds an SVG-backed icon path to the table's segment renderer: the Rust side
registers a raw SVG per shape sentinel (with its viewBox dims), and the renderer
recolours it to the cell's segment colour, rasterises once per (sentinel, colour,
height) and caches the bitmap. The recolour matches the KPI cards' svg_recolored
(replace currentColor + inject a root fill so fill-less SVGs inherit the colour).

- #9: the Access column padlocks now use the operator-supplied Font Awesome
  lock/unlock SVGs (red closed = view-only, green open = writable) instead of the
  hand-drawn vector padlock. The vector padlock remains as a fallback if the SVG
  is somehow unregistered.
- #11: the Status column renders its KPI icon (green rabbit = hashing, amber
  turtle = slow, red cracked wine glass = not hashing, blue otter = paused)
  instead of the status text, matching the dashboard cards. An unrecognised
  status still falls back to coloured text.

The status dots (hashboards, locate light) stay vector so the round-12 #6 fade
can drive them later. Self-test updated (Status is now a shape cell, verified
structurally like the other icon columns) and still passes. Verified under Xvfb:
the Access column shows the FA padlocks and, with the Status column enabled, the
four status icons render in their KPI colours. wx-rs patches 0002/0003
regenerated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:55:37 -06:00
noahandClaude Opus 4.8 b7a77cbed8 GUI round 12 (#7): batch multi-select in the Columns and Filter menus
Both list widgets now support Excel-style batch selection so several rows can be
toggled at once.

- Filter menu value list (wxCheckListBox): was wxLB_SINGLE, so only one value
  could ever be selected. Switched to wxLB_EXTENDED -- ctrl-click, shift-click
  and rubber-band drag now select a range of values. Clicking any selected
  row's checkbox applies that new checked state to every selected row.
- Columns menu list (wxListCtrl): already multi-select for the drag-reorder, but
  a checkbox toggle only affected the clicked row. A toggle on a row that is part
  of a multi-row selection now applies to every selected row, so several columns
  can be shown/hidden together. Re-entrancy guarded (CheckItem re-fires the
  event).

Verified under Xvfb by driving the real dialogs: ctrl-click selects several
columns and one checkbox click toggles them together; shift-click selects a
range of filter values and one checkbox click toggles them together. Headless
self-test still passes. wx-rs patch 0003 regenerated to match the edited bridge.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:38:57 -06:00
noahandClaude Opus 4.8 606ae85781 GUI round 12 (#2): keep KPI units visible when the window shrinks
The two wide KPI cards (SHA-256 Hashrate, Est. power) carry a units-bearing
value like "685 TH" / "21.3 kW". When the window was narrowed the row squeezed
these cards below the width their value needs, clipping the trailing unit so it
read as "21.3" with no "kW". Two fixes:

- A nested wxPanel does not re-run its own sizer when its parent resizes it, so
  each card's value/label centring kept whatever slot width it had at the
  previous window size. on_resize now re-lays-out every card on each size event,
  so the value stays centred and gets its full best-size width allocation.
- Raise the wide-card minimum width (150 -> 176) to fit a ~20px icon + a value
  up to "118.0 PH" + the card's side inset, and derive the collapse threshold
  from the real per-card minimums. The wide cards now either show their full
  units or drop out of the row cleanly -- they never render a clipped value.

Verified under Xvfb: at 1050px all seven cards show "685 TH" / "21.3 kW" in
full; at 960px the two wide cards collapse and the five count cards fill the
row. Headless self-test still passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:29:36 -06:00
noahandClaude Opus 4.8 ad9b0dc868 GUI round 12 (batch 1): black hashrate value, Control Board label, blank placeholder serials, sensible WhatsMiner temps
- #1: the total-hashrate KPI value renders in the default (black) text colour
  instead of accent blue (and now dims with focus like the other neutral cards).
- #4: the board-code column header is now "Control Board".
- #5 (serial): placeholder serials ("N/A", "none", "null", ...) render as an
  empty cell instead of the literal placeholder.
- #3: the Chip-temp cell now prefers each board's board/PCB temperature over the
  hottest-chip (outlet) reading. WhatsMiner's outlet_chip is the max chip temp
  (verified live: ~100C on the hottest board of a M30S+ VE40) which read
  alarmingly high and didn't match the ~60-79C the miner itself reports; the
  board temperature is the figure the miner's UI shows. Falls back to the chip
  temp when no board temp is reported. Applies to all makes for consistency.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:02:39 -06:00
noahandClaude Opus 4.8 aaf049bbfc GUI round 11: use the exact potraced beehive for the Hashrate KPI icon
Replaced the hand-traced beehive with an exact potrace of the operator-supplied
beehive.png (parent miner-firmware folder): potrace -s on the flattened bilevel
bitmap, then the black fill rewritten to currentColor so it recolours to the
Hashrate accent. Renders correctly via wxBitmapBundle::FromSVG (nanosvg).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 22:26:02 -06:00
noahandClaude Opus 4.8 8b7b0c70b4 GUI round 11: hand-traced beehive KPI icon (Hashrate)
Replaced the placeholder skep with a beehive matching the operator's reference
(branch + hook on top, stacked pill bands, centre entrance), as an outline SVG
using stroke="currentColor" so it recolours to the Hashrate accent. Hand-traced
because a chat-pasted raster can't be reached as a file for potrace; if the
source raster is saved to disk later, it can be image-traced for an exact match.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 22:14:12 -06:00
noahandClaude Opus 4.8 3ae80efdde GUI round 11: KPI icons match their card text colour + recolour SVGs without a fill
- Each KPI icon now uses its card's value colour (dropped the amber special-case),
  so the otter matches the Paused text colour and the lightning bolt matches the
  Est-power text colour, etc.
- svg_recolored also injects a root fill: some Font Awesome exports (e.g. the Free
  otter) omit fill entirely and default to black, so replacing currentColor alone
  left them black. Now shapes without their own fill inherit the card colour.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 20:53:28 -06:00
noahandClaude Opus 4.8 7901d82c4b GUI round 11 follow-ups: equal-height zebra, backdrop dimming, SVG KPI icons, boards sort
- Zebra stripe heights: the cell rect wx hands a custom renderer is shrunk to the
  content size in BOTH dimensions, so shape cells (dots) and text cells filled
  different-height bands -> unequal stripes across columns. SegmentRenderer now
  fills an over-sized rect (full column width + well beyond the row vertically);
  the cell DC clips it to the real cell, giving uniform full-row stripes. Verified
  in a screenshot.
- Focus dimming: the treeview's own state flags don't carry GTK_STATE_FLAG_BACKDROP
  (that lives on the toplevel), so uncoloured segments (combined-cell slashes,
  target hashrate, "Stock") never dimmed. ThemedTextColour now reads the toplevel
  window's active state (gtk_window_is_active) and forces BACKDROP onto the
  style-context state when inactive, so those segments take the same dimmed themed
  colour the native columns do.
- KPI icons: replaced the hand-drawn vectors with operator-supplied Font Awesome
  Pro SVGs (rabbit=hashing, turtle=slow, cracked wine glass=not hashing,
  otter=paused) plus matching in-repo bolt (power) and hive (hashrate) SVGs. New
  wxbr_svg_icon renders an SVG via wxBitmapBundle::FromSVG; the GUI recolours
  each icon's currentColor to the card's colour and sizes it to the SVG aspect
  ratio. Removed the old wxbr_kpi_icon path.
- Boards column sort: it sorted by total board count (all ~3, so no visible
  order). It now sorts by the number of ONLINE (green) boards, total count as a
  tiebreaker, so units with dead/missing boards surface.

wx-rs bridge/Rust changes mirrored into patches 0002 (widgets.rs) and 0003
(widgets_bridge.cpp) per ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 11:55:39 -06:00
noahandClaude Opus 4.8 8f7aab3f80 GUI round 11 (live-miner items #5/#6b/#8/#11): control-board scan gaps, VNish partner build, CVITek PIC bus
All root-caused and fixed against the live fleet (read-only scans; no device
state changed). asic-rs changes go through the vendored tree + thirdparty/asic-rs
patch queue (0003-0005) with refreshed checksums, per ADR 0003.

#5 (XIL/CVITek + WhatsMiner blank control board):
- VNish reports the board in short form in /api/v1/info "platform": "cv"
  (CVITek), "xil" (Xilinx), "aml" (AMLogic); AntMinerControlBoard::parse matched
  only the full names, so CVITek/Xilinx boards were blank. Added CV/XIL.
- Old M30S firmware (< 2022.7.29 -> v1 backend) omits summary's "CB Platform"
  and v1's parse mandatorily stripped an "ALLWINNER_" prefix. Added get_version
  /Msg/platform as a fallback source and made the strip optional.
- Verified live: S19k Pro cv->CVITek, S19 xil->Xilinx, M30S+ VE40->H6OS.

#6b/#11 (VNish partner / shared-devfee build):
- The partner build shows as /api/v1/info "build_name" ("WildRose",
  "vnishreturn"). The VNish backend (v1_2_0 + v1_3_0) now reads /build_name and
  combines it with the /fw_version number, so firmware_version reads e.g.
  "WildRose 1.2.7". Verified live on S19j Pro / S19k Pro.

#8 (hashboard PIC detection):
- pic_probe tried i2c-1/i2c-0 for CVITek, but a live VNish CVITek S19k Pro
  exposes the hashboard MCU on i2c-3 (i2cdump 0x48 = period-8 -> PIC). Broadened
  bus_candidates (cvi->[3,4,1,0], aml->[1,3,4,0], bb->[0,1,3,4], else->[1,0,3,4]);
  probe_pic stops at the first bus that classifies. The classify logic was
  already correct + unit-tested; only the bus map was wrong.

The GUI picks up #5/#6b automatically through asic-rs (CPU/Board columns now
populate for VNish CVITek/Xilinx and old M30S; FW Version shows the partner
build); #8 is fixed in the GUI's own pic_probe. The miner_probe diagnostic's
local-only mutation modes are left uncommitted as before.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 09:07:57 -06:00
noahandClaude Opus 4.8 e593548746 GUI round 11 (#4): drag-reorder + multi-select columns dialog (no up/down buttons)
Replaces the columns dialog's wxRearrangeCtrl (checkboxes + up/down buttons)
with a wxListCtrl-based list (new wxbr_reorder_list / Widget::reorder_list):
- No up/down buttons; rows are reordered by dragging.
- Native multi-select: Shift/Ctrl-click and rubber-band drag.
- Keeps per-row checkboxes for show/hide; same [idx | !idx] order encoding, so
  apply_columns is unchanged.

Drag-reorder is implemented by recording the selected rows' base indices on
wxEVT_LIST_BEGIN_DRAG and moving that group to the row under the cursor on the
following mouse-up (no real DnD loop is started, so the mouse-up still arrives).

Verified: the dialog opens without crashing and renders the checkable, button-
free list (headless click test). The drag and shift/ctrl multi-select
interactions are not headlessly simulatable and need interactive confirmation.

Bridge + Rust mirrored into patches 0002 (widgets.rs) and 0003
(widgets_bridge.cpp) per ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 18:03:47 -06:00
noahandClaude Opus 4.8 2fd433c3b0 GUI round 11 (#15): drawn icons on the KPI cards
Each KPI card's value now leads with a small vector icon drawn into a
transparent bitmap via wxGraphicsContext (new wxbr_kpi_icon -> Widget::kpi_icon):
rabbit = Hashing, turtle = Slow, broken wine glass = Not hashing, otter =
Paused, hive = SHA-256 Hashrate, lightning bolt = Est. power; Total has none.
The icon takes the card's value colour (amber on the neutral Est. power card so
the bolt reads).

The icons are simple flat silhouettes so they render at ~22px without external
assets (no emoji/pictographs in source). The rabbit, turtle, wine glass, hive,
and lightning read clearly; the otter is the least distinct at this size.

Bridge + Rust mirrored into patches 0002 (widgets.rs) and 0003
(widgets_bridge.cpp) per ADR 0003. Self-test passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:51:09 -06:00
noahandClaude Opus 4.8 5399f9fc49 GUI round 11: fix headless self-test after Status dropped from default columns
Round 11 #12 removed the Status column from the default view, but the runtime
self-test (CI's "Headless UI self-test", separate from cargo test) read each
miner's status from the displayed Status cell -- now absent -- so three status
spot-checks failed and the self-test binary exited non-zero, failing CI. Status
is a model property, so the checks now read it straight from the row
(status_of(row) = rows[view_idx[row]].status()) instead of a displayed cell.
Self-test passes (exit 0).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:42:53 -06:00
noahandClaude Opus 4.8 6b4961d7bc GUI round 11 (#2): collapse the two wide KPI cards when the window is too narrow
When the window is narrowed past the width needed to fit all seven KPI cards at
their minimum size, the two wide cards (SHA-256 Hashrate, Est. power) are hidden
so the five miner-count cards fill the row; they return when there is room again.
The five count cards still floor the window's minimum width (unchanged).

Adds a resize event to the wx-rs bridge (WxEV_SIZE -> WxEventKind::Sized, p1 =
client width) and a wxbr_sizer_show helper to hide/restore a sizer child and
reclaim its space. The main panel binds it; App::on_resize toggles the two cards
on a state change only (no per-drag relayout thrash). Bridge + Rust changes
mirrored into patches 0002 (widgets.rs) and 0003 (widgets_bridge.cpp) per
ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:39:56 -06:00
noahandClaude Opus 4.8 fc7c665166 GUI round 11 (#9): option to hide columns with no scanned values
The Columns dialog gains a "Hide columns with no scanned values" checkbox. When
on, columns whose cell is blank for every current row are hidden from the table.
It is non-destructive: the hiding is applied at table-build time via a new
App::table_columns() (used by every table-path caller in place of
view.display_columns()), so clearing the option restores the columns and the
underlying column order/visibility is never mutated. IP is never hidden, and
nothing is hidden before the first scan (no rows -> nothing empty).

Note: while the option is hiding columns, drag-reorder of the header is a no-op
(the reorder validates against the full visible set); turn the option off to
reorder.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:32:20 -06:00
noahandClaude Opus 4.8 ae437c0d24 GUI round 11 (batch 1): default columns, control-board split cleanup, Stock/Env fixes, relative sort, consistent zebra + focus-dimming, hashboard/light dots, access icon
Table/model (Rust):
- #12: default columns are now IP, Model, Errors, Hashrate, Power, Chip temp,
  Firmware, CPU, Boards, Access, in that display order (initial ViewState and the
  built-in "Default" preset both updated).
- #14: removed the Control board column (CPU + Board replace it); the underlying
  control-board string stays on MinerRow for the SSH PIC probe.
- #6 (part 1): firmware family strips the vendor word asic-rs prepends on stock
  firmware ("AntMiner Stock" -> "Stock"), moving it into FW Version.
- #17: air-cooled miners' ambient reading routes to a new "Env temp" column
  instead of "Fluid temp" (asic-rs reports ambient in its fluid field and has no
  cooling-type flag; cooling type is inferred from the model name).
- #16: relative-hashrate (actual/expected) sort -- the Hashrate header cycles
  absolute-asc/desc then relative-asc/desc, with right-click menu entries;
  HashrateRel is a sort-only pseudo-column.

Rendering (wx-rs SegmentRenderer bridge, mirrored to patches/0003 per ADR 0003):
- #3: the per-row zebra background now fills the whole column-wide cell (wx
  shrinks a custom renderer's rect to the content size, so the earlier fill
  covered only the text; Render now fills GetOwner()->GetWidth() and wxGTK clips
  it to the cell).
- #1/#7: uncoloured segments (combined-cell slashes, "Stock" firmware) take the
  tree widget's themed text colour at its live GTK state, so they dim on
  window-backdrop like the native cells.
- #10: the Boards column renders per-hashboard status dots (green hashing / red
  faulted / grey undetected, board 1 rightmost); the Light column renders a
  yellow locate dot while flashing.
- #13: the Access column renders a padlock icon (green open = writable, red
  closed = view-only) instead of "locked"/"unlocked" text.

Shapes draw from control-char sentinels (never emoji/pictographs), font-
independent. Self-test verifies the icon columns structurally. 82 unit tests
pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 17:24:09 -06:00
noahandClaude Opus 4.8 b343746718 GUI round 10 (batch 2): consistent zebra on custom columns + neutral KPIs dim with focus
R10.1 (zebra consistency): wxGTK does not paint a custom renderer's cell
background, so the per-row zebra colour set via GetAttrByRow appeared on the
native columns but not on the SegmentRenderer columns (Hashrate, Chip temp,
Firmware, ...), making the striping look inconsistent. SegmentRenderer::Render
now paints the row's GetAttr() background itself (skipping selected rows, which
the control already highlights) so every column stripes identically.

R10.2 (focus dimming): the Total-miners and Est-power KPI cards and the plain
segments in combined cells forced an explicit foreground colour, so they did
not dim when the window lost focus like the rest of the dashboard. mk_card and
repaint_theme now leave ColorKind::Neutral cards on the default text colour, and
SegmentRenderer draws an uncoloured segment with the DC's current text
foreground (falling back to wxSYS_COLOUR_WINDOWTEXT) instead of a hardcoded
system colour.

The widgets_bridge.cpp edit is mirrored into the wx-rs patch queue
(patches/0003-widget-bridge-cpp.patch) per ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 15:44:48 -06:00
noahandClaude Opus 4.8 aa75031112 GUI round 10 (batch 1): firmware family colour + FW Version, CPU/Board split, per-board chip temp, error count
#3 Firmware column now shows the firmware FAMILY, coloured (Stock=default,
VNish=green, Braiins=purple, LuxOS=gold, BixBit=pink, ePIC=light-blue,
Hive=orange, Alkane=navy -- Alkane wired for our future scannable firmware);
the version moves to a new "FW Version" column.

#4 Control board split into a "CPU" column (AML/CVI/BBB/XIL, WhatsMiner
H3/H6/H616) and a "Board" column (C76/C88/CBE/C49/C55, CB2/CB4/CB6). Fixed the
AMLogic 140mm heuristic so S21 Pro -> CBE (was C76). The combined ControlBoard
column stays available (hidden).

#5 "Worker" now shows just the rig name; a new "Pool account" column holds the
account (pool username "account.rig" split on the first dot).

#6 Chip temp shows per-hashboard temps as integers ("77 / 64 / 74"), each
coloured on the blue-to-red scale, falling back to the integer average.

#7 Errors column shows just the count (a number, even for one; no "errors"
word); the hover tooltip lists the messages, now concise -- Info dropped, the
repetitive "[Error]"/"[Warning]" prefixes stripped, and duplicates collapsed.

Default profile updated to show Firmware/FW Version/CPU/Board/Errors. 80 offline
tests pass; headless self-test PASS; screenshot-verified the colours, splits,
per-board temps and error counts in the offline demo.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 15:32:38 -06:00
noahandClaude Opus 4.8 8eb9a2caad GUI round 10 (#8): Z15/Z15J Equihash hashrate shows the correct SI prefix (k, not T)
Root-caused and verified against the live fleet. An Antminer Z15 shows its
hashrate as e.g. "288T" when it is really ~288 kSol/s ("288k"). Equihash miners
report a Sol/s rate in the cgminer "GHS" key, but asic-rs AntMiner parse_hashrate
takes the unit from the key name ("GHS" -> GigaHash), scaling the value 1e9x too
large. The value is a raw Sol/s count, so for Equihash use the base Hash unit;
the toolkit`s SI-prefixing then yields "288k".

Matched by algorithm, and by "Z15" model name for the Z15J (which asic-rs leaves
algo Unknown). Fixed in both the v2020 and v2023_07 AntMiner backends, via
asic-rs patch queue 0002. Verified live: Z15 288T -> ~288k, Z15J 138T -> ~110k.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 15:18:12 -06:00
noahandClaude Opus 4.8 9e2b453eb5 GUI round 9 (#4 v2): WhatsMiner v2 power-limit now reports success on the apply-restart
Follow-up to 3530d67a. Verified on the live fleet that the v2 (firmware
< 2024-11-01) "adjust_power_limit" command DOES apply the new watt limit --
confirmed the set value settles via the read-only :4028 "Power Limit" after the
miner restarts to re-tune. But the restart drops the connection mid-command, so
the read times out; the code then reported that as a failure even though it
applied.

Both v2 and v3 set_power_limit now treat a transient RPC error after the command
(is_expected_write_error -- read timeout / connection reset, the helper the
pause/resume paths already use) as success. A genuine rejection is a
StatusCheckFailed and still errors. v1 miners keep the "not supported" bail.

Verified: v2 M30S+ (fw 20240930) set 3500 -> :4028 settles to 3500, restore 3600
-> settles to 3600 and the miner resumes hashing.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 15:01:42 -06:00
noahandClaude Opus 4.8 3530d67a5c GUI round 9 (#4): fix WhatsMiner power-limit (v3 auth/param) + asic-rs patch queue
Round-9 #4 -- "the power-limit on the WhatsMiners doesn't apply properly" --
root-caused and verified against the live fleet, then fixed in vendored asic-rs
via a new patch queue (ADR 0003).

Root cause: asic-rs routes a WhatsMiner to its v3 (WhatsMinerOS) backend when
the firmware date is >= 2024-11-01. The v3 privileged power-limit write
(command "set.miner.power_limit" on port 4433) authenticated against account
"super" but hashed the token with the WEB/admin password, and sent the watt
value as a float -- so the miner rejected every write with "invalid json or
password is wrong". asic-rs then swallowed that (Ok(data.is_ok()) -> Ok(false))
so the GUI showed "refused" with no reason. (Older miners, fw < 2024-11-01, use
the v2 "adjust_power_limit" path, which restarts the miner on a change -- see
below.)

Fix (thirdparty/asic-rs/patches/0001):
- v3 set_auth: the "super" account's token password is a SEPARATE v3 credential
  (factory default "super"), NOT the web/admin password carried by `auth`; use
  "super". The web password still drives the v2 (admin) path.
- v3 set_power_limit: send the watts as a bare integer (a float trips the
  firmware's "invalid json" parser).
- v2 + v3: propagate the RPC error with `?` instead of swallowing it to
  Ok(false), so a real failure reaches the round-9 bottom-right error indicator
  with the miner's own message.

Verified on a live M30S+ (fw 20241108, api 3.0.1) via a read-only 4028
capture/restore harness: the fixed request returns {"code":0,"msg":"ok"};
asic-rs set_power_limit now returns Ok(true) and the miner applies the limit
(it restarts to re-tune, ~10 min ramp -- expected WhatsMiner behaviour). Matches
the pyasic and HashSource whatsminer-api-3 references. All test miners were
returned to their prior configured limit.

asic-rs patch-queue mechanism (ADR 0003 updated): asic-rs is cargo-vendored, so
in-place edits are documented as a numbered patch under thirdparty/asic-rs/
plus a checksum-refresh helper and scripts/apply-asic-rs-patches.sh for
re-vendoring. The committed vendor/ tree has the patch applied and its
.cargo-checksum.json refreshed, so builds need nothing extra (CI builds fresh;
a note documents the local `cargo clean -p` cargo-caching gotcha).

Known follow-up: the v2 backend (fw < 2024-11-01) reaches the miner via
"adjust_power_limit" but a changed value restarts the miner and the in-restart
status check reports failure; whether it applies correctly needs its own
verification. The error-propagation change surfaces that honestly meanwhile.

Compile-checked (release + tests); 79 offline tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 14:10:05 -06:00
noahandClaude Opus 4.8 3ac4e104a0 GUI round 9 (#3): mask power-limit on VNish; naming passthrough fix; live-scan probe tool
#3 (power-limit shown where it shouldn't be): asic-rs advertises
supports_set_power_limit = true unconditionally for whole firmware families,
VNish included. Per operator guidance -- VNish Antminers should not expose the
power-limit control, while Braiins keeps it -- mask the capability for VNish
firmware in to_row; every other backend keeps asic-rs's answer. Verified
against the live fleet (all VNish Antminers report true; Antminer stock Z15 /
S21Pro already report false).

#11 follow-up: asic-rs Unknown-model passthroughs carry the raw vendor string
with the brand still in it (seen live: a NoPIC S19 as "ANTMINER S19 (88)").
Drop a redundant leading brand word in clean_antminer so the Model column
never repeats the Brand column: "ANTMINER S19 (88)" -> "S19 (88)".

New read-only diagnostic: crates/alkane-gui/src/bin/miner_probe.rs -- a
standalone asic-rs CLI (`miner_probe scan <cidr>...`) that reuses the GUI's
MinerFactory + saved-credential setup to inventory a range (ip/make/firmware/
model/control-board/watts/supports_power_limit/supports_tuning) without going
through the wx event loop. Used to validate the round-9 naming + capability
work against real hardware; kept as a hardware-check tool. It performs no
mutations (asic-rs exposes no power-limit read-back, so exact restore-to-prior
cannot be guaranteed from it alone).

naming unit tests + headless self-test PASS; 80 offline tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 12:05:37 -06:00
noahandClaude Opus 4.8 3c99934513 GUI round 9 (#11): device-naming cleanup -- Brand/Submodel columns, clean model names, control-board short codes
asic-rs hands us compact Rust-identifier model strings ("S19KPro",
"M30SPlusVE40") and bare control-board family names ("Xilinx", "AMLogic",
"BeagleBoneBlack", WhatsMiner "H3"/"H6"/"H6OS"/"H616"). This adds a pure
display-layer transform (new crate::naming) that turns those into the
human-facing identity the table shows -- no asic-rs edit, so it stays a
build-on-top layer over the vendored crate.

- Model column now shows the cleaned name: brand dropped, family-letter
  suffix lowercased, word suffixes spaced, "+"/"++" for Plus/PlusPlus, and
  (WhatsMiner) the trailing version block moved out. "S19KPro" -> "S19k Pro",
  "S21Pro" -> "S21 Pro", "M30SPlusVE40" -> "M30S+".
- New Brand column ("Antminer"/"WhatsMiner"/...) and Submodel column
  (WhatsMiner version block, e.g. "VE40"; blank for Antminer -- its hashboard
  type is not reported over the network). Both hidden by default; available
  via the Columns menu and filterable.
- Control-board column now shows the Bitmain short code: BeagleBoneBlack ->
  "BBB (C77)", CVITek -> "CVI (C88)", Xilinx -> "XIL (C49)" (S17-era) /
  "XIL (C55)" (S19-era), AMLogic -> "AML (C76)" (120mm) / "AML (CBE)"
  (140mm); WhatsMiner H3 -> "H3 (CB2)", H6 -> "H6 (CB4)", H6OS ->
  "H6os (CB4)", H616 -> "H616 (CB6)". Xilinx/CVITek/AMLogic/BeagleBone are
  already detected by asic-rs, so no crate extension was needed.

Heuristics (asic-rs reports only the board family, never the exact board
number): the AMLogic 120mm-vs-140mm (C76/CBE) and Xilinx S17-vs-S19-era
(C49/C55) splits are inferred from the model family. These are documented in
crate::naming and are the one place a live-hardware correction may be needed.

ALL_COLUMNS is now 41. Fixtures refactored to carry asic-rs-style
make/model_id/board so they exercise the real transform. naming has unit
tests for the model/submodel/brand/control-board rules; the headless
self-test gained 32 checks (brand/model/submodel/control-board per fixture),
all PASS. 79 offline tests pass; screenshot-verified the cleaned Model and
control-board codes in the default view.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 11:29:15 -06:00
noahandClaude Opus 4.8 9b5d811b1e GUI round 9 (batch 2): KPI box layout, bottom-right error indicator, algorithm filter + hashrate cycling
Round-9 UI items #5, #6, #7 and the #9 algorithm-cycle follow-on.

#6 KPI boxes: switch the header from a wrap sizer to a horizontal box
sizer with every card at proportion 1 + EXPAND, so the cards are always
equal width and grow to span the full window; a per-card min size
(116x62) floors them at their largest content. Fix the filter-alignment
drift by re-running each card's sizer in refresh_kpis after set_label
(the centring spacers now recompute around the new value width). The
active-filter highlight now paints the card panel and both its texts, so
the whole box tints instead of only the strip behind the text. Bind the
card click on the value and label static texts too (a click on the number
or caption registers the quick-filter, not just the card gap).

#5 error indicator: add a second, colour-tinted status-bar field pinned
to the bottom-right corner (wxbr_status_indicator_init/set in the widget
bridge; a wxStaticText repositioned into the right field on resize). Scan
and apply outcomes route here without overwriting the left scan-status
text: a total apply failure and a scan failure show red, a partial apply
failure amber, full success clears it; a new scan/action clears any stale
message.

#7 algorithm filter: the Filter dialog now offers every column (via a new
ViewState::filter_columns) rather than only the visible ones, so Algorithm
-- and any other hidden metric -- can be filtered without first un-hiding
its column. Filters already match on the plain model cell, independent of
visibility.

#9 hashrate cycling: compute per-algorithm hashrate totals in compute_kpis
(Kpis::hashrate_by_algo, ordered by total). The hashrate KPI card shows
the selected algorithm's total under a "<Algo> Hashrate" caption and
cycles through the running algorithms when clicked (a no-op with a single
algorithm). SHA256 renders as "SHA-256".

Bridge provenance patches 0002/0003 regenerated to match the -patched tree.
Compile-checked (release + tests); 74 offline tests pass; headless
self-test PASS; screenshot-verified equal-width cards, full-box highlight,
click-through-text, and centred values after filtering.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 11:09:50 -06:00
noahandClaude Opus 4.8 77399bdd06 GUI round 9 (batch 1): column-reorder persistence, post-action refresh, algorithm column, hashrate KPI label
- #1 Column reorder now persists (incl. after sorting a moved column). On wxGTK,
  GetColumnPosition() does not reflect a native GtkTreeView column drag, so the
  reorder was read as a no-op and the rebuild snapped columns back. dvlc_col_at_pos
  now reads the real display order from the GtkTreeView (gtk_tree_view_get_columns
  + GTKColumnToWX) on __WXGTK__, falling back to GetColumnPosition elsewhere.
- #2 A right-click config action (e.g. Flash lights) now re-probes the miners it
  targeted when it finishes, so the change shows in the table (skipped after a
  flash, since the unit is rebooting). New App.action_targets.
- #7 New Algorithm column (from asic-rs hashrate.algo: SHA256/Scrypt/Equihash/...),
  categorical so it is filterable via the value checklist.
- #9 SHA-256 Hashrate KPI: card relabelled "SHA-256 Hashrate" and the value drops
  the "/s" ("685 TH", "1.2 PH"). (Per-algorithm click-cycling deferred.)

Note on #8 (Z15 shows T not k): our formatting already derives the SI prefix from
the base value (si_mantissa), so a wrong 'T' means asic-rs reports the wrong unit
for that Equihash model -- an asic-rs backend fix that needs a live Z15 to verify.

cargo check --release --tests clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:41:21 -06:00
noahandClaude Opus 4.8 408b7d12b4 GUI: real access/lock-state detection via credentialed digest probe
asic-rs has no lock-state signal (a wrong-password miner just silently returns
fewer fields, because the collector drops the 401). This builds the real check
ON TOP of asic-rs:

- access_probe.rs: a NON-mutating, digest-authenticated GET to a privileged
  endpoint (Antminer get_miner_conf.cgi, read-only). The HTTP status is decisive
  -- 200 = credentials authenticate (writable -> unlocked), 401/403 = rejected
  (view-only -> locked); anything else -> indeterminate. Pure classifier +
  unit tests; shells out to curl --digest (no HTTP crate) so the offline build
  is unaffected.
- Right-click "Check access (auth)" on the selected miners runs start_access_probe
  on a background thread using the saved scan (web) credentials (default root/root),
  updating write_locked in the rows as results arrive. Fake-scan mode returns
  deterministic demo results. Guarded against a flash / concurrent probe.

Replaces the previous capability-based inference for the miners the user
explicitly checks. cargo check --release --tests clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:32:44 -06:00
noahandClaude Opus 4.8 50cd463bee GUI fix: guard out-of-range dvlc GetItem (crash selecting rows after refresh)
Round-9 #10: selecting miners could trip
`datavcmn.cpp: assert "row < m_hash.GetCount()" failed in GetItem(): invalid
index` and crash. wxDataViewIndexListModel::GetItem() asserts on an out-of-range
row, and three bridge helpers called it with an index that can go stale when the
row set shrinks (a filter, or a scan that returns fewer rows): wxbr_dvlc_
ensure_visible (the round-8 scroll-hold, unguarded), wxbr_dvlc_select_rows and
wxbr_dvlc_select_row (only lower-bounded). All three now bound the row against
the store's item count before calling GetItem, so a stale/empty index is a
no-op instead of a crash.

Local wx-rs bridge compile clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:29:14 -06:00
noahandClaude Opus 4.8 d73299166e GUI: real PIC detection via on-board SSH + i2c probe (right-click action)
asic-rs and the miner's network API cannot report PIC-vs-noPIC (only one legacy
SKU, ANTMINER S19J88NOPIC, carries it in the model string; the authoritative
signal lives on the control board's I2C bus). So this builds the real detector
ON TOP of asic-rs as an opt-in SSH probe, per the project wiki
(30-power-thermal-and-board-identity/hashboard-eeprom-pic.md):

- pic_probe.rs: SSH to the control board and run i2cdump -y <bus> 0x48 b, then
  discriminate by the register period -- a PIC/MCU board exposes an 8-byte
  register file that WRAPS every 8 bytes ("17 00 4b 50 7f 00 00 00 ..."), while
  a noPIC board has a 4-register LM75 temp sensor (4-byte wrap). The classifier
  is pure + unit-tested against the wiki's example dumps and is conservative
  (indeterminate -> None, never a guess). The I2C bus is chosen from the
  control-board family (AMLogic->1, BeagleBone->0, else try both). We shell out
  to ssh/sshpass (no SSH crate) so the offline/vendored build is unaffected.
- Right-click "Detect PIC (SSH)..." on the selected miners: a dialog collects
  SSH login (prefilled from a new 0600 ssh-credentials.txt, default user root),
  then start_pic_probe runs one miner at a time on a background thread (each is a
  slow SSH round trip; never part of the fast network scan) and upserts
  pic_present into the rows as results arrive. Fake-scan mode returns
  deterministic demo results. Guarded against a firmware flash / concurrent probe.

The classifier is unit-tested; the live SSH round-trip needs a reachable bench
miner with SSH + i2c-tools to verify end-to-end. cargo check --release --tests
clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-18 10:25:15 -06:00
noahandClaude Opus 4.8 a81fef3c7d GUI round 8: Errors column hover tooltip (full message list)
Item 12 (tooltip half): hovering an Errors cell now shows the full list of the
miner's error/event messages ("[Severity] text (component)", most severe first)
as a tooltip; the cell itself keeps the compact red summary.

wxDataViewCtrl has no per-cell tooltip API, and wx mouse-motion events are not
delivered to wx handlers on the native GTK control, so this uses GtkTreeView's
native "query-tooltip" signal directly (guarded by __WXGTK__): a per-cell
tooltip map (row, model column) -> text on the AttrListStore, populated from
Rust via a new dvlc_set_cell_tooltip bridge fn, and looked up by the signal
handler using dv->GTKColumnToWX(gcol)->GetModelColumn(). The map is populated on
every platform (a no-op where nothing reads it) so the non-GTK platform round
can wire its own tooltip surface later.

Local wx-rs bridge compile + full cargo check clean; patches 0002/0003
regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:37:18 -06:00
noahandClaude Opus 4.8 365732b5d4 GUI round 8b.2 fix: rubber-band drag-select uses native GtkTreeView on GTK
The wx-mouse-event rubber-band approach (LEFT_DOWN/MOTION/LEFT_UP) does not work
on the native GTK wxDataViewCtrl: the underlying GtkTreeView grabs the pointer
during a button drag, so wx never delivers the MOTION events, and only the
initial click row was selected (verified against the shipped binary).

Fix: on GTK, enable the GtkTreeView's own native rubber-band selection via
dv->GtkGetTreeView() + gtk_tree_view_set_rubber_banding(TRUE), guarded by
__WXGTK__ (gtk/gtk.h included only there). The wx-mouse-event approach is kept
as the non-GTK fallback for the future Windows/macOS builds, where it will be
verified in the platform round. The column-header right-click menu (native wx
dataview event) already worked and is unchanged.

Local wx-rs bridge compile clean; patch 0003 regenerated + validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:27:16 -06:00
noahandClaude Opus 4.8 98603077e3 GUI round 8: view presets (save/load column arrangement, filters, sort)
Item 11: a "Presets" button (top-right) opens a dialog to save the current
table view -- column arrangement + visibility, sort, and all active filters --
as a named profile, load a saved one, or delete it. The built-in "Default"
profile is always the first preset and shows IP, Model, Hashrate, Power, Chip
temp, Firmware, Control board, PIC and Status; the app now boots with it.

- New presets.rs: a serde-serialized PresetView snapshot of ViewState (Vec-based
  so the JSON has no enum map keys), Preset { name, view }, and load/save to
  ~/.config/alkane-toolkit/presets.json. "Default" is re-seeded on load and not
  written, so it can't be lost or deleted. A loaded preset missing newer columns
  still covers every column (they're appended hidden).
- serde/serde_json added to alkane-gui (already vendored + locked via asic-rs);
  Column/ColFilter/TextOp/NumOp derive Serialize/Deserialize and ViewState is
  now Clone.
- ui.rs: build_presets_dialog + apply_preset_load/save/delete, wired to the new
  Presets button.

Unit tests: default-preset round-trips through ViewState and JSON.
cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:21:49 -06:00
noahandClaude Opus 4.8 bc9f847689 GUI round 8b.2: column-header menu + rubber-band drag-select
Bridge + UI (local wx-rs bridge compile + full cargo check clean).

- Column-header right-click menu (#5): right-clicking a column header opens an
  Excel-style menu -- Sort ascending / descending, Auto-size this column, Hide
  <column> (not offered for the fixed IP column), and Columns... (the full
  show/hide picker). New wx event WxEV_DVLC_HEADER_RIGHT_CLICK bound from the
  native wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, plus a wxbr_dvlc_autosize_col
  bridge fn (wxCOL_WIDTH_AUTOSIZE). (Sticky/frozen columns are the separate 8c
  dual-control piece.)
- Rubber-band (click-drag) range selection (#10): wxDataViewCtrl has no native
  drag-to-extend selection (only ctrl/shift-click), so it is tracked in the
  bridge -- LEFT_DOWN records the anchor row (and lets the native handler select
  it), dragging with the button down selects the inclusive row range under the
  cursor, LEFT_UP clears the anchor; modifier-clicks are left to the native
  multi-select. Reuses the existing Select/UnselectAll primitives and emits
  SELECTION_CHANGED so the model's selected-IP set stays in sync.
- KPI cards widened to 150px so "685 TH/s" / "21.3 kW" are no longer clipped.

wx-rs patches 0002/0003 regenerated + round-trip validated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 17:13:27 -06:00
noahandClaude Opus 4.8 71cdf2d988 GUI round 8b.1: scroll-hold, zebra striping + vertical gridlines, default-colour text
Bridge + rendering rework (validated with a local wx-rs bridge compile + full
cargo check; CI is the build oracle).

- Scroll position hold (#2): the table no longer jumps to the top as new rows
  stream in during a scan. fill_rows captures the top visible row before the
  clear+refill and restores it after (new wx-rs bridge fns dvlc_get_top_row /
  dvlc_ensure_visible, wrapping wxDataViewCtrl::GetTopItem / EnsureVisible).
- Default-colour text (#3b): rows are no longer tinted wholesale by status. Every
  cell is now the default text colour (black in light mode, white in dark -- the
  SegmentRenderer falls back to wxSYS_COLOUR_WINDOWTEXT for any run with no
  explicit colour), so IP addresses, slashes, expected/target values and all
  non-conditional cells read in the default colour. Only the conditionally-
  formatted columns carry colour: Hashrate/Boards/Chips actual (ratio scale),
  Chip temp (blue-red), fans (grey-blue), Access (red/green), Errors (red), and
  the Status column keeps its own status colour on its own cell.
- Zebra striping (#8): odd rows get a subtle theme-aware background via the
  AttrListStore (a per-row BACKGROUND attr, so it does not disturb the
  default-foreground fallback and the native selection highlight still shows
  through). This replaces the status row-tint as the row separator. (The earlier
  abandoned attempt used SetAlternateRowColour / GTK CSS against the status
  foreground tint; removing that tint is what makes the background approach
  clean now.)
- Vertical gridlines (#8): wxDV_VERT_RULES added to the table style (row lines
  were already on), so columns have borders.
- KPI cards: wxWrapSizer now drops wxEXTEND_LAST_ON_EACH_LINE, so the last card
  on a line is no longer stretched -- the uniform-size KPI boxes stay uniform.

wx-rs patches 0002/0003 regenerated and round-trip-validated against the source.
cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:55:27 -06:00
noahandClaude Opus 4.8 4fea3becf6 GUI round 8a.2: PIC, Access (locked), and Errors columns
Adds the round-8 columns that asic-rs either already exposes or that we infer.
Control board type (#9) and identify-light state (#4b) were already scannable
columns; this adds the three new ones:

- PIC (#9): asic-rs does not report PIC-vs-noPIC over the network (it needs an
  on-board SSH/I2C probe -- a separate feature), so this is a best-effort
  inference from the model string ("NoPIC" variants), showing "?" when unknown.
  New MinerRow.pic_present.
- Access (#13): locked (view-only) vs unlocked (writable), inferred from whether
  the miner exposes any writable control capability (asic-rs has no direct
  lock-state field). Red = locked, green = unlocked. New MinerRow.write_locked
  and MinerCaps::any_control().
- Errors (#12): wires asic-rs's structured MinerData.messages (previously
  dropped) into MinerRow.errors as "[Severity] text (component)" lines, most
  severe first. The column shows a summary (blank / the single message / "N
  errors") in red when non-empty; the full list becomes a hover tooltip once the
  tooltip bridge support lands in 8b.

The identify-light column header is relabelled "Light" (from "Fault light") to
match the round-8 terminology. Fixtures populated with demo values so all new
columns render offline. Unit tests for the three cell renderers + any_control.

cargo check --release --tests is clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:37:21 -06:00
noahandClaude Opus 4.8 7781ff71d3 GUI round 8a: no phantom-offline rows, hashrate/temp conditional formatting, multi-range parse, uniform KPI cards
First slice of the round-8 batch (Linux; Windows/macOS builds deferred to a
dedicated platform round per the design discussion). Feature/format changes
with no C++ bridge dependency; the bridge-dependent items (scroll-hold, zebra +
default-colour rework, header menu, rubber-band select, tooltips, presets,
frozen columns, plus the new asic-rs columns) follow in 8b/8c.

- Offline recognition (reverses the round-6 interpretation): the scanner no
  longer fabricates a row for an address with no miner. Only miners that
  actually respond become rows; a responding non-mining miner is "not hashing".
  Removed the MinerRow.offline field, MinerRow::offline(), the "offline" status,
  and the synthetic fixture/fake-scan offline rows. The bench fleet is now 9
  rows (was 10); KPI not-hashing is 1.
- Hashrate conditional format: the scale now bottoms out at 50% (full red at
  <=50% of expected, amber at 75%, green at 100%+), matching "green = 100%,
  red = 50% or lower".
- Hashrate cell format: prefix-only unit, no space, no spaces around the slash
  (e.g. "60.0T/200T", "80.5T/95.0T") instead of "60.0 TH/s / 200 TH/s". The
  combined-cell encoder now builds from formatted parts rather than re-splitting
  a joined string on " / ", so hashrate ("/") and count columns (" / ") each
  keep their own separator.
- Chip temperature: new blue-to-red conditional scale (cool blue at/below 40 C
  to hot red at/above 90 C); the Chip temp column is now a coloured cell.
- Multi-range scan input: each octet may be a range, so "10.1-9.1.1-255" expands
  to the 9 /24s (cartesian per-octet parse). CIDR / full-range / short-range
  forms are preserved.
- KPI header: every card is now a uniform size with its value + label centred.
- Right-click menu: "Fault light on/off" relabelled to "Flash lights on/off"
  (the underlying asic-rs set_fault_light call is unchanged).

Tests updated for the new formats/counts; new unit tests for the 50%-100% ratio
scale, the blue-to-red temp scale, the parts-based combined encoder, and the
per-octet range parser. cargo check --release --tests is clean; CI runs the
release build + tests + headless self-test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 16:26:19 -06:00
noahandClaude Opus 4.8 86e4761316 GUI round 7: code-review remediation (flash safety, unknown-actual colour, credentials, coverage)
Fixes the Critical/High findings from the round-6 review (6 parallel dimension
reviewers + adversarial verify), plus the cheap high-value non-blocking ones.
Full write-up in code-review-report.md.

Firmware-flash safety (the one irreversible, hardware-destroying action):
- Critical: re-triggering an action no longer races the previous one. A flash
  now takes an exclusive lock (new App.flashing): it will not start while any
  scan / refresh / config action is running, and none of those (nor another
  flash) start while it runs. begin_scan, start_action, start_refresh and
  apply_flash_confirm all gate on it, and the context menu offers only the
  read-only "Open in browser" while flashing. This removes the two overlapping-
  network-operation paths that could interrupt/corrupt an upload and brick a
  miner (old.stop() never joined the in-flight upload).
- High: the flash confirm dialog now lists every target IP + model and warns
  loudly when the batch spans more than one model (a single image is rarely
  valid for all), instead of showing only a bare count.

Correctness:
- High: combined columns no longer paint the "-" placeholder solid red when the
  actual is unknown but the expected is known (an idle/paused/booting miner of a
  recognised model looked like a 0% catastrophic failure). fill_rows now gates
  the ratio on the actual being known; unknown-actual falls to the plain,
  uncoloured segment. Was masked by the all-zero-expected fixtures.
- compute_kpis buckets by status() instead of re-deriving the precedence from
  raw flags (KPI header can no longer disagree with a row's status; offline
  folds into not_hashing).

Security:
- credentials file is created at 0600 up front (OpenOptions::mode) and
  re-tightened while still empty, so the plaintext password is never on disk
  under a looser mode (was create-0644 then chmod-0600).
- the "Set scan credentials" dialog no longer pre-fills the saved password in
  plaintext; a blank Password field keeps the stored one.

Robustness / API:
- the fake-scan branches of the config-action / refresh / flash background
  threads now honour the cancel flag (were ignored, so stop() was a no-op).
- MinerRow.online -> offline (default false = online), removing the footgun
  where a struct-update literal that forgot `online: true` read back offline.

Tests (the review's primary focus -- these paths had zero coverage):
- scan.rs fake_mode_background_actions: start_scan offline-row emission,
  start_refresh (Row/Failed/Done), start_firmware_flash_action, and that a
  cancelled run still terminates with Done rather than hanging.
- model.rs: flash_confirmed (exact/case/prefix/whitespace), compute_kpis vs
  status() consistency, Default-is-online.
- new ui::tests: ratio_color/fan_color/tint_toward stops+clamping+blends, and
  the combined-cell unknown-actual and cooling-cell encodings.
- credentials.rs: configured_factory smoke (both branches) + pre-existing-0644
  re-tighten.
- self-test: offline row (.199) spot-check, KPI quick-filter toggle on/off, and
  a numeric (not lexical) IP-sort assertion via model::ip_to_u32.

Deferred (non-blocking, tracked in code-review-report.md): start_* boilerplate
extraction; per-model firmware image-compatibility check; scoping saved
credentials to a chosen backend; a masked password field (needs a wx-rs
TE_PASSWORD binding); flash-specific status text; a segment-encode microbench.

Verified: cargo check --release --tests is clean; unit tests + benches + the
headless self-test run in CI (local release link is OOM-blocked on this
desktop).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 14:06:03 -06:00
noahandClaude Opus 4.8 c1234f6df7 GUI round 6 self-test fix: decode combined-column cells in spot-checks
The round-6 combined columns (Hashrate/Hashboards/TotalChips/Cooling) now
store colour-segment-encoded strings in the data view, so the headless
self-test's per-IP spot-checks read raw encoded bytes instead of plain text.
Two checks failed in CI as a result:
- S21 Pro (.149) hashrate read "B95E18<US>60.0 TH/s / 200 TH/s" (colour hex
  prefix + encoded combined text) rather than the plain value.
- S17 (.112) blank-hashrate read an encoded empty cell (invisible control
  chars), so is_empty() was false.

Fix: the spot-check `cell` closure now runs dvlc_get_cell output through
decode_segments_plain (a no-op for plain cells), and the S21 hashrate check
expects the combined "60.0 TH/s / 200 TH/s" form. The "every cell matches the
model" loop already decoded, so it was unaffected.

Verified: cargo check --release --tests is clean; the self-test itself is a
CI gate (local release link is OOM-blocked on this desktop).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 13:27:54 -06:00
noahandClaude Opus 4.8 b6afe08a5f GUI round 6: offline detection, combined columns, per-cell colours, paused status, credentials, refresh, firmware flash
Large round implemented via a research workflow (6 parallel readers) then a
file-partitioned implementation workflow (model/scan/bridge/ui/fixtures), all to
one shared contract.

Table / model:
- Offline recognition fix: the scan loop now emits a row for EVERY probed IP -
  non-responders become an "offline" row (new MinerRow.online flag +
  MinerRow::offline()), so unreachable miners show up (offline, red) instead of
  vanishing. Previously only responders got a row.
- Not-hashing rows are now RED (were grey); offline also red.
- New "paused" status (operating_state contains "pause" while not mining):
  its own blue row colour, a blue "Paused" KPI card, and a Kpis.paused count.
- Combined actual/expected columns: Hashrate, Hashboards and TotalChips fold
  their separate Expected* columns into one "actual / expected" cell; the actual
  is drawn on a smooth red->amber->green scale by ratio (100% = green), the
  expected in plain text, the slash black. num_value is carved out so a numeric
  filter never matches a row that only has an expected value.
- Fan column shows every fan's RPM as "rpm/rpm/rpm" (max 3 sig digits, SI-style),
  each fan coloured on its own grey->blue speed scale, slashes black.
- These four columns render via a new wxDataViewCustomRenderer (SegmentRenderer)
  that draws colour runs from a \x1f/\x1e-encoded value; every other column keeps
  the stock renderer and per-row status colour.

Interaction:
- KPI quick-filter: clicking the Hashing / Slow / Not hashing / Paused card
  filters the table to that status (composed with any column filters) and
  highlights the active card; clicking again clears it.
- Removed "Select all" / "Clear selection" from the right-click menu.
- Right-click "Refresh": re-polls the selected miners (asic-rs scan_miner) on a
  background thread and upserts the rows, without a full network scan.
- "Set scan credentials..." button (top-right): stores a username/password
  (~/.config/alkane-toolkit/scan-credentials.txt, 0600) that is fanned out to
  every asic-rs firmware backend via with_firmware_discovery_auth, so scans and
  all right-click actions authenticate. Applied through a new
  credentials::configured_factory() used everywhere MinerFactory::new() was.
- "Flash firmware..." (right-click): asic-rs UpgradeFirmware for the backends
  that support it (stock Antminer + EPIC; every other backend declines and is
  reported as unsupported). File picker (new wxFileDialog binding) + a typed
  "FLASH" confirmation; one miner at a time; cancel only between miners.
- Responsive layout: the KPI and controls rows use wxWrapSizer so they reflow
  when narrow; the min window size drops from 1200x720 to 640x480.

Bridge (wx-rs): SegmentRenderer + dvlc_append_colored_col, wrap_sizer,
bind_click (clickable KPI cards), file_dialog; dropped a vestigial gtk.h include.
Patches 0002/0003 regenerated + round-trip validated.

Portability note: every widget is a stock, natively-backed wxWidgets control
(ports to wxMSW/wxOSX); wxDataViewCtrl is native on Linux/macOS and wx's own
generic (still-correct) drawing on Windows.

Verified: cargo check --release --tests is clean; the release build + tests +
headless self-test run in CI. (Local release link is OOM-blocked on this
desktop; CI is the authoritative build.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 13:09:16 -06:00
noahandClaude Opus 4.8 eb08a9ef97 GUI: per-miner capabilities + live config write path (right-click actions)
Completes the right-click config menu (round-2 item 11): the menu now offers
real actions computed from the intersection of what every selected miner
supports, and applies them to the fleet over the network.

- Capability detection: to_row probes each miner's asic-rs supports_* methods
  (fault light, restart, pause, resume, power limit, tuning) at scan time and
  stores them in MinerRow.caps -- no extra network round-trip.
- Intersection: MinerCaps::intersect_all yields the actions common to the whole
  selection; the context menu offers only those (a mixed mining + idle selection
  shows just fault light + restart; an all-mining selection shows everything).
- Write path: scan::start_config_action runs on a background thread -- it
  re-discovers each selected miner with asic-rs scan_miner(ip), applies the
  setter, and reports per-IP results that drain into the status bar (running
  progress while applying, a pass/fail summary when done). Cancellable, and a
  new action cancels any in-flight one so two never overlap. In fake-scan mode
  it simulates success so the flow is exercisable offline.
- Actions: fault light on/off, pause, resume, restart apply immediately; set
  power limit and set tuning % open a small value-prompt dialog first. Factory
  reset, change password, and firmware upgrade are deliberately not exposed in a
  casual right-click.

Adds the `measurements` dependency (already in the lock, transitive via asic-rs)
for Power::from_watts.

Review fixes (one review pass):
- Restart / pause / resume now require a confirmation dialog (naming the count)
  so a misclick can't stop a producing fleet; fault light stays instant, and
  power/tuning are confirmed by their value entry.
- The action result is held on the status bar for a few ticks so a fleet
  action's outcome (including failures) isn't clobbered by the next timer tick.
- The action loop uses a current-thread tokio runtime (it applies to one miner
  at a time; a worker pool was wasted).
- The value prompt validates before closing: a bad value keeps the dialog and
  the captured selection so it can be corrected.
- The menu's "(N)" counts use the rows-backed selection, matching what is
  actually acted on.

Verified off-screen: capability intersection (mixed vs all-mining selections),
the value-prompt and confirmation nested modals (menu -> dialog) with no crash,
the end-to-end apply flow, 46 unit tests (incl. a caps-intersection test), and
the headless self-test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 11:05:15 -06:00
noahandClaude Opus 4.8 297e21a519 GUI round 3: Excel-style filters, status row colours, icon controls, context menu, live theme
Addresses the round-3 feedback batch:

- Right-click now works: a context menu (open selected in browser, select all,
  clear) pops up from the table. It was never wired before. (The live-config
  intersection over the selection remains a follow-up; no dead menu items.)
- Selection is readable again in both themes: the alt-row/zebra CSS hack (which
  painted row backgrounds over the native highlight, leaving white-on-white) is
  gone; the native selection highlight shows through.
- Row text is coloured by status (green = hashing, amber = slow, grey = not
  hashing), which also separates rows without fragile GTK zebra striping.
- Dark mode: KPI cards and rows follow the system theme (no more white boxes in
  dark mode); a system-colour-changed event repaints them live if the OS toggles
  light/dark while the app is open.
- Play / Pause / Stop are coloured media icons (green triangle / amber bars /
  red square) instead of text buttons.
- Filter panel redesigned Excel-style: a column dropdown at the top selects the
  column; controls adapt to its type. Text columns: a value checklist ("is any
  of") or a predicate (contains / does not contain / begins with / ends with /
  equals). Numeric columns: between / = / != / > / >= / < / <=. Filters AND
  across columns; edits held in a working copy, committed on Apply.
- Auto-rescan label shortened to "Rescan (s):" so the value field has room.

Table: replaced wxDataViewListCtrl with a raw wxDataViewCtrl + a custom
AttrListStore (per-row foreground via GetAttrByRow), which keeps in-table column
drag while enabling status row colours. New wx-rs bridge primitives: wxChoice
dropdown, coloured media buttons (drawn on a transparent bitmap via
wxGraphicsContext), a wxEVT_SYS_COLOUR_CHANGED event, destroy_children, and
call_after (deferred rebuilds). Patches 0002/0003 regenerated + round-trip
validated.

Model: ColFilter { Values, Text{op}, Num{op} } with TextOp/NumOp and
passes_filters -> ColFilter::matches; Column::num_value for numeric filtering.

Review fixes (one review pass):
- Deferred the two rebuilds that destroyed a control from inside its own event
  (filter op-dropdown change; column drag-reorder) via call_after, avoiding a
  use-after-free.
- num_value returns None for a blank-displaying value-type cell (Hashrate,
  Power, ChipTemp, ...), so "ChipTemp <= 50" no longer matches a miner with no
  temperature reading.
- Value checklist maps a checked entry back to its real value by index, so a
  literal "(blank)" value is not confused with an empty cell.

Verified off-screen: 45 unit tests, headless self-test (14 checks), and
interaction screenshots of selection, right-click, the text/numeric filter, the
comparator swap, and dark mode.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-17 09:19:38 -06:00
noahandClaude Opus 4.8 7fac0ce726 CI: make the headless UI self-test a hard gate
The self-test was continue-on-error while the container display path was
unproven. Run 529 confirmed it launches and passes (SELFTEST PASS) once xauth
was installed, so remove continue-on-error: a future regression that breaks GUI
init now fails the build instead of releasing silently.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-16 19:30:17 -06:00
83 changed files with 15601 additions and 600 deletions
-1
View File
@@ -75,7 +75,6 @@ jobs:
- name: Headless UI self-test
if: steps.ver.outputs.release == 'true'
continue-on-error: true
run: |
apt-get update -qq && apt-get install -y -qq --no-install-recommends \
xvfb xauth dbus-x11 fonts-dejavu-core >/dev/null
Generated
+9
View File
@@ -76,10 +76,19 @@ dependencies = [
name = "alkane-gui"
version = "0.1.0"
dependencies = [
"aes",
"alkane-core",
"alkane-discovery",
"asic-rs",
"base64 0.21.7",
"ecb",
"futures-util",
"hex",
"md5crypt",
"measurements",
"serde",
"serde_json",
"sha2",
"tokio",
"wx-rs",
]
+4 -2
View File
@@ -30,12 +30,14 @@ ui=false; backend=false
while IFS= read -r f; do
[ -z "$f" ] && continue
case "$f" in
crates/alkane-gui/src/ui.rs|crates/alkane-gui/src/fixtures.rs|thirdparty/wx-rs/*)
crates/alkane-gui/src/ui.rs|crates/alkane-gui/src/fixtures.rs|thirdparty/wx-rs/*|\
crates/alkane-gui/src/bin/*)
ui=true ;;
crates/alkane-core/*|crates/alkane-discovery/*|crates/alkane-access/*|\
crates/alkane-flash/*|crates/alkane-artifacts/*|crates/alkane-cli/*|\
crates/alkane-gui/src/scan.rs|crates/alkane-gui/src/model.rs|\
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*)
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
vendor/*|thirdparty/asic-rs/*)
backend=true ;;
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
esac
+11
View File
@@ -14,5 +14,16 @@ alkane-discovery = { path = "../alkane-discovery" }
# vendored + patched wx-rs (see vendor/wx-rs/patches/)
wx-rs = { path = "../../thirdparty/wx-rs/wx-rs-0.2.0-patched" }
asic-rs = "0.8.1"
measurements = "0.11"
tokio = { version = "1", features = ["rt"] }
futures-util = "0.3"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
# WhatsMiner :4028 token-auth access check (round 12 #8b) -- same crates the
# vendored asic-rs whatsminer backend uses, so no new versions enter the lock.
md5crypt = "1"
sha2 = "0.10"
aes = "0.8"
ecb = "0.1"
base64 = "0.21"
hex = "0.4"
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M434.8 54.1C446.7 62.7 451.1 78.3 445.7 91.9L367.3 288L512 288C525.5 288 537.5 296.4 542.1 309.1C546.7 321.8 542.8 336 532.5 344.6L244.5 584.6C233.2 594 217.1 594.5 205.2 585.9C193.3 577.3 188.9 561.7 194.3 548.1L272.7 352L128 352C114.5 352 102.5 343.6 97.9 330.9C93.3 318.2 97.2 304 107.5 295.4L395.5 55.4C406.8 46 422.9 45.5 434.8 54.1z"/></svg>

After

Width:  |  Height:  |  Size: 569 B

+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 384 512"><path fill="currentColor" d="M240 8L48 296h112L128 504 336 216H224L272 8z"/></svg>

After

Width:  |  Height:  |  Size: 145 B

@@ -0,0 +1,29 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g transform="translate(0.000000,512.000000) scale(0.100000,-0.100000)" >
<path d="M2152 4645 c-35 -8 -95 -28 -133 -46 l-70 -32 39 -41 c109 -115 121
-180 41 -222 -48 -24 -74 -11 -168 85 -225 229 -555 240 -774 25 l-59 -57 57
-22 c103 -38 134 -107 76 -166 -36 -36 -54 -36 -145 -3 -290 107 -608 -44
-712 -339 -13 -36 -13 -39 4 -32 147 57 237 37 237 -54 0 -56 -26 -78 -115
-101 -479 -123 -584 -723 -175 -995 92 -62 102 -71 105 -100 4 -40 -1 -56 -25
-80 -34 -35 -81 -33 -146 5 -28 17 -53 29 -55 27 -2 -2 14 -38 35 -80 114
-227 341 -383 586 -404 l70 -5 1 103 c4 397 280 752 674 870 70 21 101 23 447
28 l373 6 25 26 c19 18 28 42 35 85 15 107 57 173 141 219 54 30 55 30 234 33
108 2 191 -1 207 -7 60 -23 72 -111 21 -151 -23 -18 -41 -20 -185 -20 -200 0
-238 -16 -238 -98 0 -66 -30 -134 -84 -188 -82 -81 -98 -84 -482 -84 -348 0
-405 -6 -526 -55 -355 -144 -547 -560 -421 -912 156 -434 650 -621 1049 -398
60 34 224 176 224 195 0 4 -17 19 -38 33 -109 72 -138 132 -92 190 43 54 75
48 192 -36 291 -208 673 -260 1012 -136 205 74 390 218 518 399 71 102 72 106
48 140 -37 52 -90 177 -90 213 0 68 62 109 126 82 25 -10 36 -26 58 -81 153
-385 618 -488 905 -201 197 197 213 494 39 725 -38 52 -148 142 -172 142 -6 0
-20 -33 -30 -72 -33 -128 -107 -172 -175 -104 -31 32 -31 62 3 171 114 371
-43 798 -372 1015 -71 47 -198 108 -206 99 -3 -2 13 -40 35 -84 46 -92 43
-132 -12 -160 -64 -34 -95 -17 -149 81 -251 454 -793 618 -1249 378 -99 -52
-140 -57 -176 -18 -43 46 -30 109 28 144 l31 19 -39 17 c-102 42 -247 54 -363
29z"/>
<path d="M4064 2007 c-184 -270 -531 -485 -854 -529 -49 -7 -90 -16 -90 -20 0
-19 163 -171 228 -213 494 -318 1255 -101 1387 395 15 55 18 199 6 254 l-6 30
-155 1 c-119 1 -168 6 -210 19 -67 22 -184 79 -226 111 l-31 24 -49 -72z"/>
<path d="M2431 1509 c-51 -58 -53 -62 -47 -103 13 -83 97 -179 179 -205 18 -5
62 -12 98 -16 138 -13 125 -2 531 -464 231 -265 244 -275 305 -259 63 17 68
37 68 276 l0 214 -80 27 c-237 80 -440 241 -552 441 -23 41 -33 50 -56 50 -49
0 -179 30 -284 66 -55 19 -103 34 -105 34 -2 0 -28 -27 -57 -61z"/>
</g></svg>

After

Width:  |  Height:  |  Size: 2.0 KiB

@@ -0,0 +1,38 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g transform="translate(0.000000,512.000000) scale(0.100000,-0.100000)" >
<path d="M1970 5109 c-158 -18 -233 -52 -290 -130 -63 -88 -40 -168 95 -329
290 -345 492 -728 595 -1130 7 -25 34 -86 61 -136 l49 -91 108 -6 c76 -3 130
-12 187 -31 44 -14 83 -22 87 -18 13 13 87 322 112 470 126 749 -33 1218 -462
1362 -134 45 -353 60 -542 39z"/>
<path d="M3615 4886 c-82 -30 -119 -107 -130 -271 -29 -409 -151 -830 -337
-1160 -41 -74 -72 -146 -94 -220 l-33 -110 34 -27 c45 -38 120 -139 157 -213
17 -33 32 -61 33 -63 10 -11 325 187 480 303 704 524 836 1036 386 1499 -221
228 -372 307 -496 262z"/>
<path d="M975 4370 c-226 -36 -431 -174 -638 -430 -97 -120 -131 -220 -107
-310 24 -90 105 -132 280 -145 435 -32 872 -164 1211 -366 30 -17 103 -47 163
-64 l108 -33 29 33 c42 48 130 113 209 154 l70 37 -56 99 c-246 438 -574 799
-857 943 -131 67 -298 101 -412 82z"/>
<path d="M4795 3451 c-23 -10 -86 -56 -140 -103 -326 -277 -690 -475 -1066
-579 -76 -21 -144 -48 -205 -82 l-91 -51 -6 -105 c-3 -75 -13 -130 -31 -186
-14 -44 -22 -83 -18 -87 10 -10 261 -74 382 -97 794 -154 1301 2 1450 447 74
222 63 625 -20 756 -63 99 -158 131 -255 87z"/>
<path d="M2443 3095 c-206 -45 -374 -215 -418 -422 -82 -385 263 -730 648
-648 209 44 378 213 423 424 81 385 -268 730 -653 646z m152 -179 c59 -25 75
-97 31 -141 -24 -24 -35 -28 -111 -40 -54 -9 -121 -76 -130 -130 -12 -76 -16
-87 -40 -111 -26 -26 -72 -32 -107 -13 -49 26 -54 133 -10 232 45 101 163 191
274 207 29 4 54 8 56 9 1 0 18 -5 37 -13z"/>
<path d="M767 3009 c-562 -63 -820 -407 -758 -1013 20 -185 49 -255 133 -316
87 -64 167 -40 333 100 329 276 698 475 1070 575 65 18 132 45 192 79 l93 51
0 73 c0 79 21 199 46 258 20 47 20 47 -116 83 -359 95 -742 138 -993 110z"/>
<path d="M1770 2244 c-141 -81 -339 -216 -449 -304 -716 -578 -764 -1101 -146
-1599 106 -85 171 -115 255 -115 139 -2 184 64 206 302 43 463 178 899 372
1206 14 23 40 90 58 151 l33 109 -40 34 c-48 41 -117 137 -155 215 -16 31 -31
57 -34 56 -3 0 -48 -25 -100 -55z"/>
<path d="M3098 2066 c-35 -44 -138 -121 -213 -158 -33 -17 -61 -32 -63 -33
-12 -10 203 -350 312 -494 527 -695 1026 -820 1490 -372 193 187 268 305 270
421 1 129 -67 183 -251 201 -210 20 -292 32 -408 55 -297 62 -591 172 -836
314 -36 21 -106 50 -155 64 -50 14 -97 28 -105 31 -8 3 -25 -9 -41 -29z"/>
<path d="M2256 1882 c-25 -41 -108 -428 -131 -612 -18 -143 -21 -439 -5 -550
74 -535 419 -776 1015 -710 174 19 246 50 305 131 63 87 39 170 -92 324 -277
326 -474 689 -579 1066 -21 74 -49 146 -82 207 l-51 92 -73 0 c-79 0 -200 21
-257 45 -41 17 -43 18 -50 7z"/>
</g></svg>

After

Width:  |  Height:  |  Size: 2.5 KiB

+1
View File
@@ -0,0 +1 @@
<svg version="1.0" xmlns="http://www.w3.org/2000/svg" width="511.104248pt" height="512.144915pt" viewBox="0 0 511.104248 512.144915" preserveAspectRatio="xMidYMid meet"><g transform="translate(-0.500000,511.997478) scale(0.100000,-0.100000)" fill="currentColor" stroke="none"><path d="M82 5103 c-52 -25 -77 -69 -77 -133 0 -41 6 -63 22 -86 49 -68 -31 -64 1237 -64 l1146 0 0 -150 0 -150 -323 0 c-292 0 -332 -2 -403 -20 -201 -52 -370 -228 -414 -432 -8 -34 -11 -94 -8 -155 5 -90 12 -119 52 -214 6 -14 -9 -17 -121 -22 -142 -7 -205 -22 -304 -73 -123 -65 -229 -192 -272 -329 -33 -106 -30 -264 7 -360 15 -38 30 -77 32 -85 4 -12 -9 -20 -49 -33 -76 -24 -163 -83 -228 -156 -160 -176 -193 -424 -86 -638 61 -123 195 -242 315 -280 40 -13 52 -21 48 -33 -2 -8 -17 -46 -32 -85 -38 -95 -41 -253 -7 -360 56 -178 206 -323 393 -380 32 -9 108 -19 182 -22 l126 -6 -25 -66 c-31 -81 -42 -233 -23 -319 45 -210 221 -387 433 -437 94 -22 1622 -22 1716 0 108 26 188 71 272 155 126 125 176 255 167 437 -5 90 -12 119 -52 214 -6 14 9 17 122 22 147 6 246 33 337 92 110 70 199 186 238 310 33 106 30 264 -7 360 -15 39 -30 77 -32 85 -4 12 9 20 49 33 211 67 377 303 377 537 0 233 -167 470 -378 537 -40 13 -52 21 -48 33 2 8 17 47 32 85 37 96 40 254 7 360 -39 122 -130 241 -240 311 -89 58 -188 85 -335 91 -113 5 -128 8 -122 22 40 95 47 124 52 214 6 119 -7 184 -55 287 -46 97 -157 210 -254 257 -117 58 -159 63 -516 63 l-323 0 0 150 0 150 618 0 617 0 210 -211 c116 -116 227 -219 247 -230 122 -63 256 59 207 187 -5 16 -60 79 -121 141 l-112 113 313 0 c346 0 360 2 404 64 31 43 31 129 0 172 -50 70 173 64 -2535 64 -2230 0 -2446 -2 -2476 -17z m3337 -918 c94 -52 141 -134 141 -244 -1 -102 -60 -192 -155 -237 l-50 -24 -795 0 -795 0 -50 24 c-61 28 -116 87 -140 149 -26 70 -17 172 21 235 31 49 104 105 158 121 18 6 363 9 821 8 l790 -2 54 -30z m649 -834 c95 -43 162 -147 162 -251 0 -66 -30 -131 -85 -187 -84 -83 -84 -83 -593 -83 l-434 0 -55 50 c-281 257 -719 257 -1005 0 l-57 -51 -453 3 c-452 3 -453 3 -500 26 -92 45 -158 151 -158 252 0 119 99 235 221 259 24 5 688 8 1474 8 l1430 -2 53 -24z m-1317 -623 c130 -64 224 -184 249 -317 5 -29 10 -98 10 -151 0 -53 -5 -122 -10 -151 -25 -133 -119 -253 -249 -317 -73 -36 -77 -37 -191 -37 -114 0 -118 1 -191 37 -125 62 -210 164 -244 293 -20 79 -20 271 0 350 39 149 147 263 300 318 38 13 74 17 151 15 93 -3 107 -6 175 -40z m-924 -235 c-16 -51 -16 -415 0 -465 l11 -38 -547 0 -548 0 -62 31 c-87 43 -138 117 -148 213 -11 110 44 211 145 263 l64 33 548 0 548 0 -11 -37z m2580 24 c60 -22 117 -72 148 -128 26 -46 30 -64 30 -129 0 -65 -4 -83 -30 -129 -31 -56 -88 -106 -148 -128 -23 -8 -187 -12 -578 -12 l-546 -1 13 68 c17 86 17 318 0 405 l-13 67 546 -1 c391 0 555 -4 578 -12z m-2349 -878 c286 -256 725 -255 1006 1 l55 51 453 -3 c452 -3 453 -3 500 -26 90 -44 158 -151 158 -247 0 -99 -69 -204 -162 -246 l-53 -24 -1455 0 -1455 0 -53 24 c-95 43 -162 147 -162 251 0 66 30 131 85 187 83 82 79 81 588 82 l439 1 56 -51z m1342 -820 c97 -43 160 -138 160 -240 0 -111 -47 -192 -141 -244 l-54 -30 -783 -3 c-518 -2 -796 1 -822 8 -59 16 -131 70 -164 122 -38 63 -47 165 -21 235 24 62 79 121 140 149 l50 24 795 0 c778 0 796 -1 840 -21z"/></g></svg>

After

Width:  |  Height:  |  Size: 3.0 KiB

+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 384 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M128 192l128 0 0-64c0-35.3-28.7-64-64-64s-64 28.7-64 64l0 64zm-64 0l0-64C64 57.3 121.3 0 192 0S320 57.3 320 128l0 64c35.3 0 64 28.7 64 64l0 192c0 35.3-28.7 64-64 64L64 512c-35.3 0-64-28.7-64-64L0 256c0-35.3 28.7-64 64-64zm256 64l-256 0 0 192 256 0 0-192z"/></svg>

After

Width:  |  Height:  |  Size: 522 B

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M240 88C240 74.7 229.3 64 216 64C202.7 64 192 74.7 192 88L192 128C156.7 128 128 156.7 128 192L88 192C74.7 192 64 202.7 64 216C64 229.3 74.7 240 88 240L128 240L128 296L88 296C74.7 296 64 306.7 64 320C64 333.3 74.7 344 88 344L128 344L128 400L88 400C74.7 400 64 410.7 64 424C64 437.3 74.7 448 88 448L128 448C128 483.3 156.7 512 192 512L192 552C192 565.3 202.7 576 216 576C229.3 576 240 565.3 240 552L240 512L296 512L296 552C296 565.3 306.7 576 320 576C333.3 576 344 565.3 344 552L344 512L400 512L400 552C400 565.3 410.7 576 424 576C437.3 576 448 565.3 448 552L448 512C483.3 512 512 483.3 512 448L552 448C565.3 448 576 437.3 576 424C576 410.7 565.3 400 552 400L512 400L512 344L552 344C565.3 344 576 333.3 576 320C576 306.7 565.3 296 552 296L512 296L512 240L552 240C565.3 240 576 229.3 576 216C576 202.7 565.3 192 552 192L512 192C512 156.7 483.3 128 448 128L448 88C448 74.7 437.3 64 424 64C410.7 64 400 74.7 400 88L400 128L344 128L344 88C344 74.7 333.3 64 320 64C306.7 64 296 74.7 296 88L296 128L240 128L240 88zM224 192L416 192C433.7 192 448 206.3 448 224L448 416C448 433.7 433.7 448 416 448L224 448C206.3 448 192 433.7 192 416L192 224C192 206.3 206.3 192 224 192zM240 240L240 400L400 400L400 240L240 240z"/></svg>

After

Width:  |  Height:  |  Size: 1.4 KiB

+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M181.5 261.1L194.4 267.5C200.3 270.5 206.8 272 213.5 272C237 272 256.1 252.9 256.1 229.4L256.1 208C256.1 172.7 227.4 144 192.1 144L128.1 144C92.8 144 64.1 172.7 64.1 208L64.1 229.4C64.1 252.9 83.2 272 106.7 272C113.3 272 119.8 270.5 125.8 267.5C135.1 262.8 142.2 259.3 147 256.9L135.1 249C130.6 246 128 241 128 235.7L128 232C128 218.7 138.7 208 152 208L168 208C181.3 208 192 218.7 192 232L192 235.7C192 241 189.3 246 184.9 249L173.1 256.9L181.5 261.1zM172.9 310.5L160 304.1L147.1 310.5C134.5 316.8 120.6 320.1 106.6 320.1C103 320.1 99.5 319.9 96 319.5L96 320.1C96 355.4 124.7 384.1 160 384.1L224 384.1C241.7 384.1 256 398.4 256 416.1C256 433.8 241.7 448.1 224 448.1L384 448.1L384 384.1C384 360.4 396.9 339.7 416 328.7C425.4 323.3 436.3 320.1 448 320.1L448 304.1C448 277.6 469.5 256.1 496 256.1C504.8 256.1 512 263.3 512 272.1L512 368.1C512 376.9 519.2 384.1 528 384.1C536.8 384.1 544 376.9 544 368.1L544 268.4C544 220.2 513.2 177.4 467.4 162.1L458.9 159.3C450.9 156.6 446.3 148.2 448.5 140C450.7 131.8 458.8 126.8 467.1 128.4L487 132.4C576 150.1 640 228.2 640 318.9L640 320L640 320C640 443.7 539.7 544 416 544L255.4 544C132 544 32 444 32 320.6L32 280.8C21.9 266.2 16 248.5 16 229.4L16 208L16 206.6C6.7 203.3 0 194.5 0 184C0 170.7 10.7 160 24 160L26.8 160C44.8 122.2 83.3 96 128 96L192 96C236.7 96 275.2 122.2 293.2 160L296 160C309.3 160 320 170.7 320 184C320 194.5 313.3 203.3 304 206.6L304 208L304 229.4C304 230.8 304 232.2 303.9 233.7C315.9 227.5 329.6 224.1 344 224.1L352 224.1C369.7 224.1 384 238.4 384 256.1C384 273.8 369.7 288.1 352 288.1L344 288.1C330.7 288.1 320 298.8 320 312.1L320 320.1L376.4 320.1C361.2 337.1 352 359.5 352 384.1L320 384.1C277.7 384.1 241.8 356.7 229 318.8C223.9 319.7 218.7 320.1 213.4 320.1C199.3 320.1 185.5 316.8 172.9 310.5zM96 192C104.8 192 112 199.2 112 208C112 216.8 104.8 224 96 224C87.2 224 80 216.8 80 208C80 199.2 87.2 192 96 192zM208 208C208 199.2 215.2 192 224 192C232.8 192 240 199.2 240 208C240 216.8 232.8 224 224 224C215.2 224 208 216.8 208 208z"/></svg>

After

Width:  |  Height:  |  Size: 2.2 KiB

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M460.7 39.3l-2.2-2.1c-4.7-4.6-11.5-6.4-17.9-4.7s-11.4 6.6-13.1 13l-.8 2.9c-3.3 11.8-5.1 23.7-5.5 35.6 24.3 20.6 42.9 47.8 53.3 78.8-8.2-1.9-16.5-2.9-25-2.9-.6 0-1.1 0-1.7 0-18.4-44-56.5-77.4-103.6-89.3l-3.4-.9c-6.2-1.6-12.9-.6-18.5 2.6-10.8 6.2-15.6 19.5-11.2 31.1 14.9 39.5 44.3 71.4 81.4 89.7-3.7 6.6-6.4 14-7.6 21.8L279.7 154.9c-30.9-17.7-65.9-26.9-101.5-26.9-32.3 0-62.2 16.8-78.9 44.4-10.3-12.5-25.8-20.4-43.2-20.4-30.9 0-56 25.1-56 56s25.1 56 56 56c11.3 0 21.8-3.3 30.6-9.1 4.9 17.2 14.5 33.1 28.4 45.9L257.2 431.2C269 442 284.4 448 300.4 448L416 448c17.7 0 32-14.3 32-32s-14.3-32-32-32l-96 0 0-43.5c0-42.9-28.4-80.5-69.6-92.3l-30.8-8.8c-8.5-2.4-13.4-11.3-11-19.8s11.3-13.4 19.8-11l30.8 8.8c55 15.7 92.8 65.9 92.8 123.1l0 15.7 56-32.4 6.4-3.7 101.3 0c33.3 0 60.3-27 60.3-60.3 0-18.1-8.2-35.3-22.2-46.7l-34.6-28.2c-4.6-3.7-9.4-7.1-14.5-10 8.4-49.3-7.8-100-43.9-135.5zm-318.5 382c-14.7 9.8-18.7 29.7-8.9 44.4s29.7 18.7 44.4 8.9l46-30.7-48.6-44.5-32.9 22zM480 240a16 16 0 1 1 32 0 16 16 0 1 1 -32 0z"/></svg>

After

Width:  |  Height:  |  Size: 1.2 KiB

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M384 249.2c0 21.4-17.4 38.8-38.8 38.8L70.8 288C49.4 288 32 270.6 32 249.2L32 208c0-97.2 78.8-176 176-176s176 78.8 176 176l0 41.2zM480 288c-2 0-4-.1-5.9-.3-16.3 53.3-64.3 92.7-122.1 96l0 56.2c0 22.1-17.9 40-40 40l-48 0c-22.1 0-40-17.9-40-40l0-56-32 0 0 56c0 22.1-17.9 40-40 40l-48 0c-22.1 0-40-17.9-40-40l0-56-32 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l312 0c39.8 0 72-32.2 72-72l0-72c0-35.3 28.7-64 64-64 53 0 96 43 96 96l0 16c0 35.3-28.7 64-64 64l-32 0zm16-64a16 16 0 1 0 0-32 16 16 0 1 0 0 32z"/></svg>

After

Width:  |  Height:  |  Size: 761 B

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M320 128c0-35.3 28.7-64 64-64s64 28.7 64 64l0 128 64 0 0-128C512 57.3 454.7 0 384 0S256 57.3 256 128l0 64-192 0c-35.3 0-64 28.7-64 64L0 448c0 35.3 28.7 64 64 64l256 0c35.3 0 64-28.7 64-64l0-192c0-35.3-28.7-64-64-64l0-64zM64 256l256 0 0 192-256 0 0-192z"/></svg>

After

Width:  |  Height:  |  Size: 520 B

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M205 64L434.9 64L439.3 82.4L475.6 234.9C478.5 247 480 259.5 480 272C480 352.2 421 418.7 344 430.2L344 560L432 560L432 608L208 608L208 560L296 560L296 430.2C219 418.6 160 352.2 160 272C160 259.5 161.5 247 164.4 234.9L200.7 82.4L205 64zM243 112L211 246C209 254.5 208 263.2 208 272C208 333.9 258.2 384 320 384C381.8 384 432 333.8 432 272C432 263.3 431 254.5 429 246L397.1 112L371.3 112L384.1 176L320.1 216L352.1 320L256.1 216L328.1 144L306.8 112L243.1 112z"/></svg>

After

Width:  |  Height:  |  Size: 721 B

+280
View File
@@ -0,0 +1,280 @@
//! Real access / lock-state detection: whether this miner accepts privileged
//! (credentialed) command writes, or is view-only.
//!
//! asic-rs has no lock-state signal (a wrong-password miner just silently
//! returns fewer fields, because the collector drops the 401). We build the real
//! check ON TOP of asic-rs: a NON-mutating, digest-authenticated GET to a
//! privileged endpoint. On Antminer every `/cgi-bin/*.cgi` requires digest auth,
//! so the HTTP status is decisive -- 200 means our credentials authenticate
//! (we can write -> unlocked), 401/403 means they are rejected (view-only ->
//! locked). We probe `get_miner_conf.cgi`, which is read-only (never the
//! mutating `set_miner_conf.cgi`).
//!
//! We shell out to `curl --digest` (already present, supports digest auth)
//! rather than add an HTTP+digest crate, so the offline/vendored build is
//! unaffected. `Some(true)` = locked, `Some(false)` = unlocked, `None` =
//! indeterminate (unreachable, or an endpoint/vendor this probe doesn't cover).
//!
//! WhatsMiner has no such digest-gated web endpoint (it returns a 307 redirect
//! for the Antminer paths, so the curl probe always read "indeterminate" and the
//! table fell back to a capability guess that marked older units "locked" even
//! with the default login -- round 12 #8b). Instead we run the WhatsMiner
//! :4028 token handshake: `get_token` (unauthenticated) yields a salt, we derive
//! the AES key from the password, and send a NON-mutating encrypted `summary`.
//! An encrypted reply means the key (hence password) was accepted -> unlocked;
//! a plaintext `enc json load err` means it was rejected -> locked.
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::process::Command;
use std::time::Duration;
use aes::Aes256;
use aes::cipher::{BlockEncryptMut, KeyInit, block_padding::ZeroPadding};
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64;
use sha2::{Digest, Sha256};
type Aes256EcbEnc = ecb::Encryptor<Aes256>;
/// Classify a miner's access state from an HTTP status code string (curl's
/// `%{http_code}` output). Conservative: anything other than a clear
/// authenticated/unauthorized answer is `None`.
pub fn classify_http_code(code: &str) -> Option<bool> {
match code.trim() {
"200" | "204" => Some(false), // authenticated -> unlocked/writable
"401" | "403" => Some(true), // rejected -> locked/view-only
_ => None, // 000 (no connect), 404, 5xx, ... -> unknown
}
}
/// The privileged, read-only endpoint we probe per firmware family. Antminer
/// stock/aftermarket all gate `get_miner_conf.cgi` behind digest auth.
fn endpoint(_firmware: &str) -> &'static str {
"/cgi-bin/get_miner_conf.cgi"
}
/// Probe one miner's access state. `make` is the miner brand ("Whatsminer" /
/// "Antminer"): WhatsMiner uses the :4028 token handshake, everything else the
/// digest-auth web probe. Returns `Ok(Some(true/false))` on a decisive
/// lock/unlock answer, `Ok(None)` if indeterminate, `Err` only on a probe that
/// could not run at all.
pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
if make.eq_ignore_ascii_case("whatsminer") {
return Ok(probe_whatsminer_access(ip, &whatsminer_password_candidates()));
}
let url = format!("http://{ip}{}", endpoint(make));
let userpass = format!("{user}:{pass}");
let mut cmd = Command::new("curl");
cmd.args([
"-s",
"-o",
"/dev/null",
"-w",
"%{http_code}",
"--digest",
"-u",
&userpass,
"--connect-timeout",
"5",
"--max-time",
"9",
&url,
]);
let out = wait_with_timeout(cmd, Duration::from_secs(12))?;
// curl prints the status code to stdout regardless of exit status (000 on a
// connection failure), so classify the code rather than the exit status.
let code = String::from_utf8_lossy(&out.stdout);
Ok(classify_http_code(&code))
}
/// Run a command with a wall-clock timeout (curl can hang past --max-time on a
/// black-holed host).
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
use std::io::Read;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(status) => {
let mut stdout = Vec::new();
let mut stderr = Vec::new();
if let Some(mut o) = child.stdout.take() {
let _ = o.read_to_end(&mut stdout);
}
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
}
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
return Err("curl timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
}
}
}
}
/// Passwords to try for a WhatsMiner access check: a user-set per-firmware
/// override (round 12 #13) wins; otherwise the two factory defaults ("admin" for
/// V1/V2, "super" for V3). All attempts are non-mutating, so trying both is safe.
fn whatsminer_password_candidates() -> Vec<String> {
if let Some((_, pass)) = crate::credentials::load_firmware_credentials().get("WhatsMiner Stock") {
if !pass.is_empty() {
return vec![pass.clone()];
}
}
vec!["admin".to_string(), "super".to_string()]
}
/// Fetch a WhatsMiner's active fault codes over the unauthenticated :4028
/// get_error_code command and format them one per line for the log viewer
/// (round 12 #12). Returns None if the miner does not answer.
pub fn whatsminer_get_error_code(ip: &str) -> Option<String> {
let resp = wm_rpc(ip, "{\"command\":\"get_error_code\"}", Duration::from_secs(6)).ok()?;
let v: serde_json::Value = serde_json::from_str(&resp).ok()?;
let codes = v.get("Msg").and_then(|m| m.get("error_code")).and_then(|c| c.as_array());
let mut lines = vec![format!("WhatsMiner get_error_code ({ip}):")];
match codes {
Some(arr) if !arr.is_empty() => {
for entry in arr {
if let Some(obj) = entry.as_object() {
for (code, when) in obj {
lines.push(format!(" error {code}: {}", when.as_str().unwrap_or("")));
}
}
}
}
_ => lines.push(" no active error codes".to_string()),
}
Some(lines.join("\n"))
}
/// One WhatsMiner :4028 request/response (the miner closes the socket after it
/// replies). Returns the NUL-trimmed body.
fn wm_rpc(ip: &str, payload: &str, timeout: Duration) -> Result<String, String> {
let addr: SocketAddr = format!("{ip}:4028")
.parse()
.map_err(|e| format!("bad address {ip}: {e}"))?;
let mut stream = TcpStream::connect_timeout(&addr, timeout).map_err(|e| e.to_string())?;
stream.set_read_timeout(Some(timeout)).ok();
stream.set_write_timeout(Some(timeout)).ok();
stream.write_all(payload.as_bytes()).map_err(|e| e.to_string())?;
let mut buf = Vec::new();
let mut chunk = [0u8; 4096];
loop {
match stream.read(&mut chunk) {
Ok(0) => break,
Ok(n) => {
buf.extend_from_slice(&chunk[..n]);
if buf.len() > 1 << 20 {
break; // cap a runaway response
}
}
Err(_) => break,
}
}
Ok(String::from_utf8_lossy(&buf).trim_matches('\u{0}').to_string())
}
/// AES-256-ECB encrypt `data` under SHA256(pwd_md5), base64-encoded -- the exact
/// scheme the WhatsMiner btminer API expects (mirrors the vendored asic-rs
/// whatsminer v2 backend).
fn wm_aes_ecb_enc(pwd_md5: &str, data: &str) -> Option<String> {
let key = Sha256::digest(pwd_md5.as_bytes()); // 32 bytes
let mut buffer = data.as_bytes().to_vec();
while !buffer.len().is_multiple_of(16) {
buffer.push(0);
}
let ct = Aes256EcbEnc::new_from_slice(&key)
.ok()?
.encrypt_padded_mut::<ZeroPadding>(&mut buffer, data.len())
.ok()?;
Some(BASE64.encode(ct))
}
/// Check a WhatsMiner's access via the :4028 token handshake, trying each
/// candidate password. Returns `Some(false)` (unlocked) on the first password
/// the miner accepts, `Some(true)` (locked) if all are rejected, `None` if the
/// miner is unreachable or speaks an unexpected dialect. Non-mutating: only
/// `get_token` and a read-only `summary` are ever sent.
fn probe_whatsminer_access(ip: &str, passwords: &[String]) -> Option<bool> {
let timeout = Duration::from_secs(6);
let mut reachable = false;
for pass in passwords {
// 1. get_token (no auth) -> salt / newsalt / time.
let tok_resp = match wm_rpc(ip, "{\"command\":\"get_token\"}", timeout) {
Ok(s) => s,
Err(_) => return None,
};
let v: serde_json::Value = match serde_json::from_str(&tok_resp) {
Ok(v) => v,
Err(_) => return None,
};
let Some(msg) = v.get("Msg") else { return None };
let (Some(salt), Some(newsalt), Some(time)) = (
msg.get("salt").and_then(|s| s.as_str()),
msg.get("newsalt").and_then(|s| s.as_str()),
msg.get("time").and_then(|s| s.as_str()),
) else {
return None;
};
reachable = true;
// 2. Derive the md5crypt password hash + write-token from the password.
let crypted = md5crypt::md5crypt(pass.as_bytes(), salt.as_bytes());
let full = String::from_utf8_lossy(&crypted);
let Some(pwd_md5) = full.split('$').nth(3) else { continue };
let sign_crypted = md5crypt::md5crypt(format!("{pwd_md5}{time}").as_bytes(), newsalt.as_bytes());
let sign_full = String::from_utf8_lossy(&sign_crypted);
let host_sign = sign_full.split('$').nth(3).unwrap_or("");
// 3. Send an encrypted, read-only `summary`. If the AES key (from the
// password) is right the miner replies encrypted; if wrong it returns
// a plaintext "enc json load err".
let cmd = format!("{{\"command\":\"summary\",\"token\":\"{host_sign}\"}}");
let Some(enc) = wm_aes_ecb_enc(pwd_md5, &cmd) else { continue };
let payload = format!("{{\"enc\":1,\"data\":\"{enc}\"}}");
let resp = match wm_rpc(ip, &payload, timeout) {
Ok(s) => s,
Err(_) => return None,
};
if resp.contains("\"enc\"") {
return Some(false); // accepted -> unlocked/writable
}
// rejected -> try the next candidate password
}
// Reached the miner and every candidate password was rejected -> locked.
if reachable { Some(true) } else { None }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_codes() {
assert_eq!(classify_http_code("200"), Some(false), "authenticated -> unlocked");
assert_eq!(classify_http_code("204"), Some(false));
assert_eq!(classify_http_code("401"), Some(true), "unauthorized -> locked");
assert_eq!(classify_http_code("403"), Some(true));
assert_eq!(classify_http_code("000"), None, "no connection -> unknown");
assert_eq!(classify_http_code("404"), None, "endpoint absent -> unknown");
assert_eq!(classify_http_code("500"), None);
assert_eq!(classify_http_code(" 200 "), Some(false), "whitespace tolerated");
assert_eq!(classify_http_code(""), None);
}
#[test]
fn whatsminer_aes_ecb_matches_reference() {
// Deterministic vector from the verified btminer scheme: AES-256-ECB over
// SHA256(pwd_md5), zero-padded, base64. Guards the WhatsMiner access
// handshake crypto (round 12 #8b) without needing a live miner.
assert_eq!(
wm_aes_ecb_enc("abc123def456", "{\"command\":\"summary\"}").as_deref(),
Some("jn5Wru/5hhMtU1IgamxLoUd/YTxaLTxEeiCQxu5pO+Q=")
);
}
}
+531
View File
@@ -0,0 +1,531 @@
//! miner_probe -- a read-only (by default) asic-rs diagnostic for live-hardware
//! verification of the round-9 power-limit work. It reuses the same MinerFactory
//! + saved-credential setup the GUI uses (see crate::credentials), but as a
//! standalone CLI so hardware checks don't go through the wx event loop.
//!
//! Usage:
//! miner_probe scan <cidr> [<cidr>...]
//! Scan the given subnets and print, per responder (TSV):
//! ip make firmware model_id control_board watts supports_power_limit supports_tuning
//!
//! miner_probe setpl <ip> <watts>
//! Apply a power limit to ONE miner and print the setter's result. This
//! MUTATES the device -- capture and restore its prior configured limit
//! separately (e.g. WhatsMiner cgminer API on :4028 reports "Power Limit"
//! read-only). asic-rs has no power-limit read-back, so this tool cannot
//! restore on its own.
//!
//! Credentials come from ~/.config/alkane-toolkit/scan-credentials.txt, or from
//! ALKANE_PROBE_USER / ALKANE_PROBE_PASS if set (so a test can authenticate
//! without touching the app's saved config).
use asic_rs::MinerFactory;
use asic_rs::core::traits::miner::MinerAuth;
use futures_util::StreamExt;
use measurements::Power;
fn load_creds() -> Option<(String, String)> {
if let (Ok(u), Ok(pw)) = (std::env::var("ALKANE_PROBE_USER"), std::env::var("ALKANE_PROBE_PASS")) {
return Some((u, pw));
}
let home = std::env::var("HOME").ok()?;
let p = std::path::PathBuf::from(home)
.join(".config/alkane-toolkit/scan-credentials.txt");
let s = std::fs::read_to_string(p).ok()?;
let mut l = s.lines();
let u = l.next()?.to_string();
let pw = l.next().unwrap_or("").to_string();
Some((u, pw))
}
fn factory() -> MinerFactory {
let mut f = MinerFactory::new();
if let Some((u, pw)) = load_creds() {
for fw in asic_rs::factory::default_firmware_registry() {
f = f.with_firmware_discovery_auth(fw.as_ref(), MinerAuth::new(u.clone(), pw.clone()));
}
eprintln!("(using saved scan credentials for discovery auth)");
} else {
eprintln!("(no saved credentials -- backends use their default auth)");
}
f
}
async fn scan(cidrs: &[String]) {
let mut f = factory();
for c in cidrs {
f = match f.with_subnet(c) {
Ok(f) => f,
Err(e) => {
eprintln!("bad subnet {c}: {e}");
return;
}
};
}
// Cap identification concurrency to match the GUI (see
// scan::SCAN_CONCURRENCY_LIMIT). asic-rs defaults to 1000, which over a real
// link starves the per-responder get_data -- Braiins miners drop most values
// (watts=0, no best-share) and some responders are missed entirely. 128 is the
// highest cap that stayed fully reliable on the live fleet. ALKANE_PROBE_CONCURRENCY
// overrides it for diagnostics.
let concurrency = std::env::var("ALKANE_PROBE_CONCURRENCY")
.ok()
.and_then(|c| c.parse::<usize>().ok())
.unwrap_or(128);
eprintln!("(scan concurrency = {concurrency})");
f = f.with_concurrent_limit(concurrency);
println!("ip\tmake\tfirmware\tfw_version\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning\tbest_share\tsession_best_share");
let mut stream = f.scan_stream_with_ip();
let mut found = 0usize;
while let Some((ip, miner)) = stream.next().await {
if let Some(m) = miner {
let data = m.get_data().await;
let watts = data.wattage.as_ref().map(|p| p.as_watts()).unwrap_or(0.0);
let cb = data
.control_board_version
.as_ref()
.map(|c| c.to_string())
.unwrap_or_default();
let fw_ver = data.firmware_version.clone().unwrap_or_default();
let bs = data.best_share.map(|v| format!("{v:.0}")).unwrap_or_default();
let sbs = data.session_best_share.map(|v| format!("{v:.0}")).unwrap_or_default();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}\t{bs}\t{sbs}",
data.device_info.make,
data.device_info.firmware,
fw_ver,
data.device_info.model,
cb,
m.supports_set_power_limit(),
m.supports_set_tuning_percent(),
);
found += 1;
}
}
eprintln!("scan complete: {found} miner(s) responded");
}
/// Dump raw hashrate value/unit/algo (and expected) as asic-rs reports them,
/// to diagnose the SI-prefix handling for non-SHA algorithms (round-9 #8, Z15).
async fn hashrate(cidrs: &[String]) {
let mut f = factory();
for c in cidrs {
f = match f.with_subnet(c) {
Ok(f) => f,
Err(e) => {
eprintln!("bad subnet {c}: {e}");
return;
}
};
}
println!("ip\tmodel\talgo\thr_value\thr_unit\texp_value\texp_unit");
let mut stream = f.scan_stream_with_ip();
while let Some((ip, miner)) = stream.next().await {
if let Some(m) = miner {
let data = m.get_data().await;
let hr = data.hashrate.as_ref();
let exp = data.expected_hashrate.as_ref();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{}\t{}",
data.device_info.model,
hr.map(|h| h.algo.to_string()).unwrap_or_default(),
hr.map(|h| h.value).unwrap_or(0.0),
hr.map(|h| format!("{:?}", h.unit)).unwrap_or_default(),
exp.map(|h| h.value).unwrap_or(0.0),
exp.map(|h| format!("{:?}", h.unit)).unwrap_or_default(),
);
}
}
eprintln!("hashrate dump complete");
}
async fn setpl(ip_s: &str, watts: f64) {
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let data = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_power_limit={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_set_power_limit()
);
match m.set_power_limit(Power::from_watts(watts)).await {
Ok(v) => println!("set_power_limit({watts:.0} W) -> Ok({v})"),
// {e:#} prints the full anyhow chain (the miner's own Msg is the
// root cause), which is exactly what we need to characterise #4.
Err(e) => println!("set_power_limit({watts:.0} W) -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// LOCAL-ONLY: toggle a miner's locate light on then back off, to validate the
/// (token-authenticated) write path safely -- the LED is reversible and does not
/// disturb mining. Restores the light to off afterward.
async fn led(ip_s: &str) {
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let data = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_set_fault_light={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_set_fault_light()
);
match m.set_fault_light(true).await {
Ok(v) => println!("set_fault_light(on) -> Ok({v})"),
Err(e) => println!("set_fault_light(on) -> Err: {e:#}"),
}
let after_on = m.get_data().await.light_flashing;
println!(" light_flashing after on = {after_on:?}");
// Restore: turn the locate light back off.
match m.set_fault_light(false).await {
Ok(v) => println!("set_fault_light(off) [restore] -> Ok({v})"),
Err(e) => println!("set_fault_light(off) [restore] -> Err: {e:#}"),
}
let after_off = m.get_data().await.light_flashing;
println!(" light_flashing after off = {after_off:?}");
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Apply a single "default" pool group to ONE miner via asic-rs set_pools_config
/// (the same path the GUI's pool feature uses). MUTATES the device's pool config.
/// Usage: setpools <ip> <url> <user> <pass>
async fn setpools(ip_s: &str, url: &str, user: &str, pass: &str) {
use asic_rs::core::config::pools::{PoolConfig, PoolGroupConfig};
use asic_rs::core::data::pool::PoolURL;
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let data = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_pools_config={})",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
m.supports_pools_config()
);
let group = PoolGroupConfig {
name: "default".to_string(),
quota: 1,
pools: vec![PoolConfig {
url: PoolURL::from(url.to_string()),
username: user.to_string(),
password: pass.to_string(),
}],
};
match m.set_pools_config(vec![group]).await {
Ok(v) => println!("set_pools_config -> Ok({v})"),
Err(e) => println!("set_pools_config -> Err: {e:#}"),
}
// Read back the configured pools to verify.
let after = m.get_data().await;
for (i, p) in after.pools.iter().flat_map(|g| g.pools.iter()).enumerate() {
let u = p.url.as_ref().map(|u| u.to_string()).unwrap_or_default();
let acct = p.user.clone().unwrap_or_default();
println!(" pool[{i}] {u} user={acct}");
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// READ-ONLY: dump a miner's structured messages (code + severity + component +
/// text) plus its per-board data, to design health/error attribution.
async fn msgs(ip_s: &str) {
let ip: std::net::IpAddr = match ip_s.parse() {
Ok(ip) => ip,
Err(e) => {
eprintln!("bad ip {ip_s}: {e}");
return;
}
};
let f = factory();
match f.scan_miner(ip).await {
Ok(Some(m)) => {
let d = m.get_data().await;
let th = |h: &Option<asic_rs::core::data::hashrate::HashRate>| {
h.clone().map(|x| x.as_unit(asic_rs::core::data::hashrate::HashRateUnit::TeraHash).value)
};
println!(
"{ip}: {} {} hashboards={:?} expected={:?}",
d.device_info.firmware,
d.device_info.model,
d.hashboards.len(),
d.expected_hashboards,
);
println!(
" TOTAL hashrate={:?} TH wattage={:?} W fluid/env_temp={:?} best_share={:?}",
th(&d.hashrate),
d.wattage.as_ref().map(|p| p.as_watts()),
d.fluid_temperature.as_ref().map(|t| t.as_celsius()),
d.best_share,
);
let fans: Vec<i64> = d
.fans
.iter()
.map(|f| f.rpm.as_ref().map(|r| r.as_rpm() as i64).unwrap_or(-1))
.collect();
println!(" fans(rpm)={fans:?} psu_fans={}", d.psu_fans.len());
for b in d.hashboards.iter() {
println!(
" board pos={} hr={:?}TH chips={:?}/{:?} board_temp={:?} outlet_temp={:?}",
b.position,
th(&b.hashrate),
b.working_chips,
b.expected_chips,
b.board_temperature.as_ref().map(|t| t.as_celsius()),
b.outlet_chip_temperature.as_ref().map(|t| t.as_celsius()),
);
}
if d.messages.is_empty() {
println!(" (no messages)");
}
for msg in &d.messages {
println!(
" MSG code={} sev={:?} comp={:?} :: {}",
msg.code, msg.severity, msg.component, msg.message
);
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Set the locate light to an explicit on/off state (round 16/G1). Capability-gated.
async fn light(ip_s: &str, on: bool) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_set_fault_light() {
eprintln!("{ip}: locate light not supported");
return;
}
match m.set_fault_light(on).await {
Ok(v) => println!("{ip} light {} -> Ok({v})", if on { "on" } else { "off" }),
Err(e) => println!("{ip} light -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Run a simple lifecycle action (restart / pause / resume) on one miner (G1).
/// Capability-gated; MUTATES (pause/restart disrupt mining -- run on the test bed).
async fn lifecycle(ip_s: &str, verb: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
let res = match verb {
"restart" if m.supports_restart() => m.restart().await,
"pause" if m.supports_pause() => m.pause(None).await,
"resume" if m.supports_resume() => m.resume(None).await,
"restart" | "pause" | "resume" => {
eprintln!("{ip}: {verb} not supported");
return;
}
_ => {
eprintln!("unknown lifecycle verb {verb}");
return;
}
};
match res {
Ok(v) => println!("{ip} {verb} -> Ok({v})"),
Err(e) => println!("{ip} {verb} -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Read (no tz arg) or set the miner's timezone (round 16 / G10). Capability-gated.
async fn timezone(ip_s: &str, tz: Option<&str>) {
use asic_rs::core::config::timezone::{Tz, TimezoneConfig};
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_timezone_config() {
eprintln!("{ip}: timezone config not supported");
return;
}
if let Some(tz_s) = tz {
let Ok(zone) = tz_s.parse::<Tz>() else {
eprintln!("bad IANA timezone '{tz_s}' (e.g. America/Edmonton)");
return;
};
let cfg = TimezoneConfig {
timezone: Some(zone),
available: Vec::new(),
};
match m.set_timezone_config(cfg).await {
Ok(v) => println!("{ip} set timezone {zone} -> Ok({v})"),
Err(e) => println!("{ip} set timezone -> Err: {e:#}"),
}
}
match m.get_timezone_config().await {
Ok(c) => println!(
"{ip} timezone now: {:?} ({} available)",
c.timezone.map(|t| t.to_string()),
c.available.len()
),
Err(e) => println!("{ip} read timezone -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Change the miner's web/API password (round 16 / G11). Capability-gated.
/// DANGEROUS: a failed change can lock the toolkit out -- use a dedicated unit.
async fn passwd(ip_s: &str, newpass: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(mut m)) => {
if !m.supports_change_password() {
eprintln!("{ip}: change password not supported");
return;
}
match m.change_password(newpass).await {
Ok(v) => println!("{ip} change_password -> Ok({v})"),
Err(e) => println!("{ip} change_password -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// Factory-reset the miner (round 16 / G12). Capability-gated. DESTRUCTIVE:
/// wipes config and may reset the network (unit can drop off its IP) -- only run
/// on a sacrificial/console-attached unit.
async fn factoryreset(ip_s: &str) {
let Ok(ip) = ip_s.parse::<std::net::IpAddr>() else {
eprintln!("bad ip {ip_s}");
return;
};
match factory().scan_miner(ip).await {
Ok(Some(m)) => {
if !m.supports_factory_reset() {
eprintln!("{ip}: factory reset not supported");
return;
}
match m.factory_reset().await {
Ok(v) => println!("{ip} factory_reset -> Ok({v})"),
Err(e) => println!("{ip} factory_reset -> Err: {e:#}"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let rt = match tokio::runtime::Builder::new_current_thread().enable_all().build() {
Ok(rt) => rt,
Err(e) => {
eprintln!("tokio runtime: {e}");
std::process::exit(2);
}
};
match args.get(1).map(String::as_str) {
Some("scan") if args.len() >= 3 => rt.block_on(scan(&args[2..])),
Some("hashrate") if args.len() >= 3 => rt.block_on(hashrate(&args[2..])),
Some("setpl") if args.len() == 4 => {
let watts: f64 = args[3].parse().unwrap_or(-1.0);
if watts <= 0.0 {
eprintln!("watts must be a positive number");
std::process::exit(2);
}
rt.block_on(setpl(&args[2], watts));
}
Some("led") if args.len() == 3 => rt.block_on(led(&args[2])),
Some("light") if args.len() == 4 && matches!(args[3].as_str(), "on" | "off") => {
rt.block_on(light(&args[2], args[3] == "on"))
}
Some(v @ ("restart" | "pause" | "resume")) if args.len() == 3 => {
rt.block_on(lifecycle(&args[2], v))
}
Some("setpools") if args.len() == 6 => {
rt.block_on(setpools(&args[2], &args[3], &args[4], &args[5]))
}
Some("msgs") if args.len() == 3 => rt.block_on(msgs(&args[2])),
Some("timezone") if args.len() == 3 => rt.block_on(timezone(&args[2], None)),
Some("timezone") if args.len() == 4 => rt.block_on(timezone(&args[2], Some(&args[3]))),
Some("passwd") if args.len() == 4 => rt.block_on(passwd(&args[2], &args[3])),
Some("factoryreset") if args.len() == 3 => rt.block_on(factoryreset(&args[2])),
_ => {
eprintln!(
"miner_probe -- asic-rs config + scan CLI for the alkane-toolkit fleet\n\
\n\
READ (safe on any miner):\n\
\x20 scan <cidr> [<cidr>...] discover + telemetry (TSV)\n\
\x20 hashrate <cidr> [<cidr>...] raw hashrate/algo dump\n\
\x20 msgs <ip> structured faults + per-board data\n\
\n\
WRITE (MUTATES the miner -- use the test-bed miners, not production):\n\
\x20 light <ip> <on|off> set the locate light\n\
\x20 led <ip> toggle locate light on then off (reversible test)\n\
\x20 pause <ip> pause mining\n\
\x20 resume <ip> resume mining\n\
\x20 restart <ip> restart/reboot\n\
\x20 setpl <ip> <watts> set power limit\n\
\x20 setpools <ip> <url> <user> <pass> set the default pool group\n\
\x20 timezone <ip> [<IANA>] read (no arg) or set the timezone\n\
\x20 passwd <ip> <newpass> change the web/API password (DANGEROUS)\n\
\x20 factoryreset <ip> factory reset (DESTRUCTIVE; sacrificial units only)\n\
\n\
Each write verb is capability-gated (skips miners that do not support it).\n\
Credentials: ALKANE_PROBE_USER/PASS or ~/.config/alkane-toolkit/scan-credentials.txt."
);
std::process::exit(2);
}
}
}
+294
View File
@@ -0,0 +1,294 @@
//! Optional saved miner credentials, applied to every asic-rs discovery call.
//!
//! asic-rs has no single global credential field on `MinerFactory`: auth is set
//! per firmware backend via `with_firmware_discovery_auth`. `configured_factory`
//! is the one place that fans a saved username/password out across the whole
//! firmware registry, so `scan`'s callers never have to think about it.
use std::collections::HashMap;
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
use asic_rs::MinerFactory;
use asic_rs::core::traits::miner::MinerAuth;
use crate::scan::config_path;
pub const CREDENTIALS_FILE: &str = "scan-credentials.txt";
/// Per-firmware default logins the operator can override (round 12 #13). One
/// `firmware-name<TAB>user<TAB>pass` line per firmware, 0600 like the others.
/// Keyed by the firmware registry's Display name (see `firmware_default_creds`).
pub const FIRMWARE_CREDENTIALS_FILE: &str = "firmware-credentials.txt";
/// SSH login for the control board (used by the PIC probe; distinct from the
/// web/API scan credentials above -- miners' SSH root login is usually not the
/// same account as the web digest-auth login).
pub const SSH_CREDENTIALS_FILE: &str = "ssh-credentials.txt";
/// Load a saved username/password pair from `file`, if present.
fn load_creds_file(file: &str) -> Option<(String, String)> {
let s = std::fs::read_to_string(config_path(file)).ok()?;
let mut lines = s.lines();
let user = lines.next()?.to_string();
let pass = lines.next().unwrap_or("").to_string();
Some((user, pass))
}
/// Save a username/password pair to `file`, restricting it to owner read/write
/// (credentials are plaintext on disk, so the mode matters).
fn save_creds_file(file: &str, user: &str, pass: &str) -> std::io::Result<()> {
let p = config_path(file);
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
// Open (and create) with mode 0600 up front so a freshly created file is
// never world/group-readable, even for the instant before the write. For a
// pre-existing file the create mode is ignored, so also tighten it to 0600
// while it is still empty (post-truncate, pre-write) -- the plaintext is
// never on disk under a looser mode.
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&p)?;
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
f.write_all(format!("{user}\n{pass}\n").as_bytes())?;
Ok(())
}
fn clear_creds_file(file: &str) -> std::io::Result<()> {
match std::fs::remove_file(config_path(file)) {
Ok(()) => Ok(()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(e) => Err(e),
}
}
/// Load the saved miner web/API username/password, if any were saved.
pub fn load_credentials() -> Option<(String, String)> {
load_creds_file(CREDENTIALS_FILE)
}
/// Save the miner web/API username/password (0600).
pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
save_creds_file(CREDENTIALS_FILE, user, pass)
}
/// Load the saved SSH username/password (used by the Braiins restore-to-stock
/// flow), if any.
pub fn load_ssh_credentials() -> Option<(String, String)> {
load_creds_file(SSH_CREDENTIALS_FILE)
}
/// Save the SSH username/password (0600). Retained for a future SSH-login dialog
/// now that the SSH PIC probe that used to save it has been removed (round 14 #5).
#[allow(dead_code)]
pub fn save_ssh_credentials(user: &str, pass: &str) -> std::io::Result<()> {
save_creds_file(SSH_CREDENTIALS_FILE, user, pass)
}
/// Remove the saved web/API credentials, if any. Not an error if none were saved.
pub fn clear_credentials() -> std::io::Result<()> {
match clear_creds_file(CREDENTIALS_FILE) {
Ok(()) => Ok(()),
Err(e) => Err(e),
}
}
/// The stock/default login each firmware ships with, keyed by the firmware
/// registry's Display name (round 12 #13). These seed the per-firmware editor and
/// let it tell an override from an unchanged default; they mirror the
/// `default_auth()` constants in the vendored asic-rs backends (a single
/// best-guess per registry entry, since a stock entry can span several backend
/// versions). asic-rs does not expose these at the entry level, so they are
/// duplicated here; a firmware absent from this table defaults to blank.
pub fn firmware_default_creds() -> &'static [(&'static str, &'static str, &'static str)] {
&[
("AntMiner Stock", "root", "root"),
("WhatsMiner Stock", "admin", "admin"),
("Braiins", "root", "root"),
("VNish", "", "admin"),
("LuxOS", "root", "root"),
("UMC OS", "", "letmein"),
("Marathon", "root", "root"),
("VolcMiner Stock", "root", "ltc@dog"),
("Elphapex Stock", "root", "root"),
("FutureBit Stock", "futurebit", "futurebit123"),
("SealMiner Stock", "seal", "seal"),
("Auradine Stock", "admin", "admin"),
("AvalonMiner Stock", "", ""),
("Nerdaxe Stock", "", ""),
("Proto Stock", "", ""),
("Bitaxe Stock", "", ""),
]
}
/// The shipped default login for a firmware, or `("","")` if unknown.
pub fn firmware_default_for(name: &str) -> (String, String) {
firmware_default_creds()
.iter()
.find(|(n, _, _)| *n == name)
.map(|(_, u, p)| (u.to_string(), p.to_string()))
.unwrap_or_default()
}
/// Load the operator's per-firmware credential overrides, keyed by firmware
/// Display name. Malformed lines are skipped.
pub fn load_firmware_credentials() -> HashMap<String, (String, String)> {
let mut map = HashMap::new();
let Ok(s) = std::fs::read_to_string(config_path(FIRMWARE_CREDENTIALS_FILE)) else {
return map;
};
for line in s.lines() {
let mut parts = line.splitn(3, '\t');
let (Some(name), user) = (parts.next(), parts.next()) else {
continue;
};
if name.is_empty() {
continue;
}
let user = user.unwrap_or("").to_string();
let pass = parts.next().unwrap_or("").to_string();
map.insert(name.to_string(), (user, pass));
}
map
}
/// Save the per-firmware credential overrides (0600), sorted by name for a
/// stable file. An empty map clears the file.
pub fn save_firmware_credentials(map: &HashMap<String, (String, String)>) -> std::io::Result<()> {
if map.is_empty() {
return clear_firmware_credentials();
}
let p = config_path(FIRMWARE_CREDENTIALS_FILE);
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&p)?;
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
let mut names: Vec<&String> = map.keys().collect();
names.sort();
for name in names {
let (user, pass) = &map[name];
f.write_all(format!("{name}\t{user}\t{pass}\n").as_bytes())?;
}
Ok(())
}
/// Remove the per-firmware overrides file, if any. Not an error if none exists.
pub fn clear_firmware_credentials() -> std::io::Result<()> {
clear_creds_file(FIRMWARE_CREDENTIALS_FILE)
}
/// Build a `MinerFactory` with saved credentials applied as discovery auth.
/// Precedence per firmware backend: a per-firmware override (round 12 #13) wins;
/// otherwise the single global scan credential (if set) applies to every backend;
/// otherwise the backend falls back to its own default auth. With nothing saved
/// this is plain `MinerFactory::new()`.
pub fn configured_factory() -> MinerFactory {
let mut factory = MinerFactory::new();
let global = load_credentials();
let per_fw = load_firmware_credentials();
if global.is_none() && per_fw.is_empty() {
return factory;
}
for fw in asic_rs::factory::default_firmware_registry() {
let cred = per_fw
.get(&fw.to_string())
.cloned()
.or_else(|| global.clone());
if let Some((user, pass)) = cred {
factory = factory.with_firmware_discovery_auth(fw.as_ref(), MinerAuth::new(user, pass));
}
}
factory
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn credentials_round_trip_and_file_perms() {
// config_path() reads $HOME; point it at a private temp dir. HOME is
// process-global, so this stays one test and restores HOME afterward
// (matching the pattern used by scan::tests::auto_secs_round_trip_and_defaults).
let prev = std::env::var_os("HOME");
let dir = std::env::temp_dir().join(format!("alkane-cred-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::env::set_var("HOME", &dir);
assert_eq!(load_credentials(), None, "no file -> None");
save_credentials("admin", "hunter2").unwrap();
assert_eq!(load_credentials(), Some(("admin".to_string(), "hunter2".to_string())));
let meta = std::fs::metadata(config_path(CREDENTIALS_FILE)).unwrap();
assert_eq!(meta.permissions().mode() & 0o777, 0o600, "credentials file must be 0600");
// configured_factory() must construct in both branches without panicking:
// with saved credentials (fans auth across every firmware backend) ...
let _ = configured_factory();
// A pre-existing, world-readable credentials file must be tightened to
// 0600 by save_credentials (the create-mode is ignored for an existing
// file, so the explicit set_permissions is what protects it).
let path = config_path(CREDENTIALS_FILE);
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap();
save_credentials("admin2", "s3cr3t").unwrap();
let meta = std::fs::metadata(&path).unwrap();
assert_eq!(
meta.permissions().mode() & 0o777,
0o600,
"save over a pre-existing 0644 file must re-tighten to 0600"
);
assert_eq!(load_credentials(), Some(("admin2".to_string(), "s3cr3t".to_string())));
clear_credentials().unwrap();
// ... and with no saved credentials (plain MinerFactory::new()).
let _ = configured_factory();
assert_eq!(load_credentials(), None, "cleared -> None");
clear_credentials().unwrap(); // idempotent: clearing an already-clear store is not an error
// Per-firmware overrides (round 12 #13). Kept in this same test because
// HOME is process-global: a second #[test] mutating it would race under
// cargo's default parallel runner.
assert!(load_firmware_credentials().is_empty(), "no file -> empty map");
let mut fw = HashMap::new();
fw.insert("WhatsMiner Stock".to_string(), ("super".to_string(), "sup3r".to_string()));
fw.insert("VNish".to_string(), ("".to_string(), "hunter2".to_string()));
save_firmware_credentials(&fw).unwrap();
// 0600, and it round-trips (an empty username survives the tab format).
let fwpath = config_path(FIRMWARE_CREDENTIALS_FILE);
assert_eq!(
std::fs::metadata(&fwpath).unwrap().permissions().mode() & 0o777,
0o600,
"per-firmware creds file must be 0600"
);
let back = load_firmware_credentials();
assert_eq!(back.get("WhatsMiner Stock"), Some(&("super".into(), "sup3r".into())));
assert_eq!(back.get("VNish"), Some(&("".into(), "hunter2".into())));
assert_eq!(back.len(), 2);
// Shipped-default lookup: known firmware resolves, unknown blanks.
assert_eq!(firmware_default_for("AntMiner Stock"), ("root".into(), "root".into()));
assert_eq!(firmware_default_for("nonexistent"), (String::new(), String::new()));
// Overrides + no global still builds a factory.
let _ = configured_factory();
// Saving an empty map clears the file (no stale overrides linger).
save_firmware_credentials(&HashMap::new()).unwrap();
assert!(load_firmware_credentials().is_empty(), "empty save -> cleared");
clear_firmware_credentials().unwrap(); // idempotent
match prev {
Some(v) => std::env::set_var("HOME", v),
None => std::env::remove_var("HOME"),
}
let _ = std::fs::remove_dir_all(&dir);
}
}
+187
View File
@@ -0,0 +1,187 @@
//! CSV export of the full scan data (round 15 #14).
//!
//! Unlike the on-screen table (which packs several values into one cell, e.g.
//! "95T/96T" or a row of health icons), the export is one value per cell and
//! covers every scanned data point, so it is complete and machine-readable.
//! Variable-length fields (per-board temps, per-fan RPMs, per-board health, the
//! pool list) are expanded into indexed columns out to the widest miner in the
//! set, so every row has the same columns.
use crate::model::{BoardHealth, MinerRow};
/// Escape one CSV field: quote it when it contains a comma, quote, CR or LF, and
/// double any embedded quotes.
fn esc(s: &str) -> String {
if s.contains([',', '"', '\n', '\r']) {
format!("\"{}\"", s.replace('"', "\"\""))
} else {
s.to_string()
}
}
fn num(v: f64) -> String {
if v == 0.0 {
String::new()
} else if v.fract() == 0.0 {
format!("{v:.0}")
} else {
format!("{v:.3}")
}
}
fn opt_bool(v: Option<bool>, yes: &str, no: &str) -> String {
match v {
Some(true) => yes.to_string(),
Some(false) => no.to_string(),
None => String::new(),
}
}
fn board_health_str(h: &BoardHealth) -> &'static str {
match h {
BoardHealth::Ok => "ok",
BoardHealth::Fault => "fault",
BoardHealth::Missing => "missing",
}
}
/// The fixed scalar columns, in order: (header, extractor).
type Col = (&'static str, fn(&MinerRow) -> String);
fn scalar_columns() -> Vec<Col> {
vec![
("ip", |r| r.ip.clone()),
("model", |r| r.model.clone()),
("brand", |r| r.brand.clone()),
("submodel", |r| r.submodel.clone()),
("mac", |r| r.mac.clone()),
("hostname", |r| r.hostname.clone()),
("serial", |r| r.serial.clone()),
("firmware", |r| r.firmware.clone()),
("fw_version", |r| r.fw_version.clone()),
("api_version", |r| r.api_version.clone()),
("control_board", |r| r.control_board.clone()),
("cpu", |r| r.cpu.clone()),
("board_code", |r| r.board_code.clone()),
("algorithm", |r| r.algorithm.clone()),
("status", |r| r.status().to_string()),
("operating_state", |r| r.operating_state.clone()),
("is_mining", |r| r.is_mining.to_string()),
("slow", |r| r.slow.to_string()),
("paused", |r| r.paused.to_string()),
("pic", |r| opt_bool(r.pic_present, "PIC", "noPIC")),
("write_locked", |r| opt_bool(r.write_locked, "locked", "unlocked")),
("light_flashing", |r| opt_bool(r.light_flashing, "on", "off")),
("hashrate_ths", |r| num(r.hashrate_ths)),
("expected_ths", |r| num(r.expected_ths)),
("efficiency_j_th", |r| num(r.efficiency)),
("power_w", |r| num(r.power_w)),
("tuning_percent", |r| r.tuning_percent.map(|v| v.to_string()).unwrap_or_default()),
("chip_temp_c", |r| num(r.chip_temp_c)),
("fluid_temp_c", |r| num(r.fluid_temp_c)),
("env_temp_c", |r| num(r.env_temp_c)),
("outlet_temp_c", |r| num(r.outlet_temp_c)),
("psu_fan_rpm", |r| num(r.psu_fan_rpm)),
("fan_count", |r| r.fan_count.map(|v| v.to_string()).unwrap_or_default()),
("expected_fans", |r| r.expected_fans.map(|v| v.to_string()).unwrap_or_default()),
("total_chips", |r| r.total_chips.map(|v| v.to_string()).unwrap_or_default()),
("expected_chips", |r| r.expected_chips.map(|v| v.to_string()).unwrap_or_default()),
("hashboards", |r| r.hashboards.map(|v| v.to_string()).unwrap_or_default()),
("expected_hashboards", |r| r.expected_hashboards.map(|v| v.to_string()).unwrap_or_default()),
("uptime_secs", |r| if r.uptime_secs > 0 { r.uptime_secs.to_string() } else { String::new() }),
("best_share", |r| r.best_share.map(num).unwrap_or_default()),
("session_best_share", |r| r.session_best_share.map(num).unwrap_or_default()),
("pool_account", |r| r.worker.split_once('.').map(|(a, _)| a).unwrap_or(&r.worker).to_string()),
("pool_url", |r| r.pool_url.clone()),
("errors", |r| r.errors.join("; ")),
]
}
/// Build the full CSV for `rows`. Empty rows still emit a header line.
pub fn rows_to_csv(rows: &[MinerRow]) -> String {
let cols = scalar_columns();
// Widest variable-length fields across the set.
let max_board_temps = rows.iter().map(|r| r.board_temps.len()).max().unwrap_or(0);
let max_fans = rows.iter().map(|r| r.fan_rpms.len()).max().unwrap_or(0);
let max_boards = rows.iter().map(|r| r.board_status.len()).max().unwrap_or(0);
let max_pools = rows.iter().map(|r| r.pools.len()).max().unwrap_or(0);
// Header.
let mut headers: Vec<String> = cols.iter().map(|(h, _)| (*h).to_string()).collect();
for i in 1..=max_board_temps {
headers.push(format!("board_temp_{i}_c"));
}
for i in 1..=max_fans {
headers.push(format!("fan_{i}_rpm"));
}
for i in 1..=max_boards {
headers.push(format!("board_{i}_status"));
}
for i in 1..=max_pools {
headers.push(format!("pool_{i}_url"));
headers.push(format!("pool_{i}_worker"));
}
let mut out = String::new();
out.push_str(&headers.iter().map(|h| esc(h)).collect::<Vec<_>>().join(","));
out.push('\n');
for r in rows {
let mut vals: Vec<String> = cols.iter().map(|(_, f)| f(r)).collect();
for i in 0..max_board_temps {
vals.push(r.board_temps.get(i).map(|&t| num(t)).unwrap_or_default());
}
for i in 0..max_fans {
vals.push(r.fan_rpms.get(i).map(|&t| num(t)).unwrap_or_default());
}
for i in 0..max_boards {
vals.push(r.board_status.get(i).map(board_health_str).unwrap_or("").to_string());
}
for i in 0..max_pools {
let (u, w) = r.pools.get(i).cloned().unwrap_or_default();
vals.push(u);
vals.push(w);
}
out.push_str(&vals.iter().map(|v| esc(v)).collect::<Vec<_>>().join(","));
out.push('\n');
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn csv_has_header_and_one_row_per_miner() {
let rows = vec![
MinerRow {
ip: "10.0.0.1".into(),
model: "S19".into(),
hashrate_ths: 95.0,
expected_ths: 96.0,
board_temps: vec![77.0, 64.0, 74.0],
fan_rpms: vec![6000.0, 6100.0],
..Default::default()
},
MinerRow { ip: "10.0.0.2".into(), model: "M30S".into(), ..Default::default() },
];
let csv = rows_to_csv(&rows);
let lines: Vec<&str> = csv.lines().collect();
assert_eq!(lines.len(), 3, "header + 2 rows");
assert!(lines[0].starts_with("ip,model,brand,"));
// Expanded columns out to the widest miner (3 board temps, 2 fans).
assert!(lines[0].contains("board_temp_3_c"));
assert!(lines[0].contains("fan_2_rpm"));
assert!(lines[1].starts_with("10.0.0.1,S19,"));
// One value per cell: hashrate and expected are separate columns.
assert!(lines[1].contains(",95,96,") || lines[1].contains("95,96"));
}
#[test]
fn csv_escapes_commas_and_quotes() {
assert_eq!(esc("a,b"), "\"a,b\"");
assert_eq!(esc("he said \"hi\""), "\"he said \"\"hi\"\"\"");
assert_eq!(esc("plain"), "plain");
}
}
+151 -27
View File
@@ -2,7 +2,8 @@
//! 10.255.1.0/24 (see ../../../HANDOFF.md section 7 and the parent project's
//! [removed]). These are the reference values the workflow tests compare
//! the application's actual output against, and the rows the offline
//! `ALKANE_FAKE_SCAN` demo mode renders.
//! `ALKANE_FAKE_SCAN` demo mode renders. Only miners that respond become rows,
//! so there is no synthetic "offline" fixture.
//!
//! Hashrate/power/temp are representative per-model figures (the bench boards
//! are not always energised); the point of the fixtures is a fixed, known input
@@ -13,10 +14,16 @@
use crate::model::{is_slow, MinerRow};
/// One fixture board, pre-transform. `expected` of 0.0 means "band unknown".
/// `make`/`model_id`/`board` mirror what asic-rs actually reports (compact
/// identifiers + a bare control-board name) so the fixtures exercise the real
/// crate::naming transform, not pre-cleaned strings.
struct Board {
ip: &'static str,
model: &'static str,
make: &'static str,
model_id: &'static str,
board: &'static str,
firmware: &'static str,
fw_version: &'static str,
hashrate: f64,
expected: f64,
power: f64,
@@ -24,6 +31,10 @@ struct Board {
fan: f64,
worker: &'static str,
mining: bool,
/// True for the bench board deliberately rebucketed into the "paused"
/// status/KPI bucket (not-mining but operator-paused, distinct from a
/// unit that is simply idle/not-hashing).
paused: bool,
}
impl Board {
@@ -37,28 +48,89 @@ impl Board {
} else {
(None, None, 0.0)
};
let fan_rpms = if self.mining {
vec![self.fan, self.fan * 0.95, self.fan * 1.02]
} else {
vec![]
};
// Three per-hashboard chip temps around the average (so the offline demo
// shows the "77 / 64 / 74" per-board Chip-temp cell).
let board_temps = if self.mining && self.temp > 0.0 {
vec![self.temp + 2.0, self.temp - 3.0, self.temp + 1.0]
} else {
vec![]
};
// Air-cooled WhatsMiners report an ambient reading (asic-rs surfaces it in
// its fluid_temperature field); the scan routes it to env_temp for
// air-cooled models, so the demo mirrors that (round 11 #17).
let env_temp_c = if self.mining && self.make.eq_ignore_ascii_case("whatsminer") {
27.0
} else {
0.0
};
// Per-hashboard health dots for the Boards column (round 11 #10): mining
// units show three green dots, except two demo cases -- the slow S21 Pro
// has one faulted (red) board, and one VNish S19 has a board that wasn't
// detected (grey) -- so the offline demo exercises all three states.
use crate::model::BoardHealth::{Fault, Missing, Ok};
let board_status = if self.mining {
match self.ip {
"10.255.1.149" => vec![Ok, Fault, Ok],
"10.255.1.166" => vec![Ok, Ok, Missing],
_ => vec![Ok, Ok, Ok],
}
} else {
vec![]
};
// Firmware-flash capability is modeled on the real Bitmain/Antminer
// upgrade path (S17/S19/S21 family); WhatsMiner boards in this fleet
// don't advertise it, so both true and false show up and the
// firmware menu item is testable.
let firmware_flash = self.make.eq_ignore_ascii_case("antminer")
&& (self.model_id == "S17"
|| self.model_id.starts_with("S19")
|| self.model_id.starts_with("S21"));
// Derive the display identity through the same path the live scan uses.
let brand = crate::naming::brand(self.make);
let model = crate::naming::clean_model(self.make, self.model_id);
let submodel = crate::naming::submodel(self.make, self.model_id);
let control_board = crate::naming::control_board_code(self.make, self.board, &model);
let cpu = crate::naming::control_board_cpu(self.make, self.board, &model);
let board_code = crate::naming::control_board_board(self.make, self.board, &model);
MinerRow {
ip: self.ip.to_string(),
selected: false,
model: self.model.to_string(),
model,
brand,
submodel,
firmware: self.firmware.to_string(),
fw_version: self.fw_version.to_string(),
cpu,
board_code,
hashrate_ths: self.hashrate,
expected_ths: self.expected,
efficiency,
power_w: self.power,
chip_temp_c: self.temp,
fan_rpm: self.fan,
board_temps,
env_temp_c,
fan_rpms,
worker: self.worker.to_string(),
is_mining: self.mining,
slow,
paused: self.paused,
// offline defaults to false (online); these bench rows are reachable.
mac: format!("AA:BB:CC:00:{:02X}:{last_octet:02X}", last_octet.wrapping_mul(3)),
hostname: format!("miner-{last_octet}"),
hashboards: boards,
expected_hashboards: Some(3),
board_status,
total_chips: chips,
psu_fan_rpm: if self.mining { self.fan * 0.9 } else { 0.0 },
uptime_secs: if self.mining { 3600 * 24 * 2 + 3600 * 5 } else { 0 },
light_flashing: Some(false),
// One unit is "being located" so the Light column's yellow dot is
// demonstrable offline (round 11 #10).
light_flashing: Some(self.ip == "10.255.1.167"),
pool_url: if self.worker.is_empty() { String::new() } else { "stratum+tcp://pool.blueflare:3333".to_string() },
pools: if self.worker.is_empty() {
Vec::new()
@@ -68,47 +140,99 @@ impl Board {
("stratum+tcp://backup.blueflare:3333".to_string(), format!("{}_bak", self.worker)),
]
},
operating_state: if self.mining { "mining".to_string() } else { "idle".to_string() },
operating_state: if self.paused {
"paused".to_string()
} else if self.mining {
"mining".to_string()
} else {
"idle".to_string()
},
// Synthetic capabilities so the right-click config menu is
// exercisable offline: mining units support everything, idle ones
// only the fault light + restart (to show the capability intersection).
caps: crate::model::MinerCaps {
fault_light: true,
restart: true,
pause: self.mining,
resume: self.mining,
power_limit: self.mining,
tuning: self.mining,
firmware_flash,
pools: true,
timezone: self.mining,
change_password: true,
factory_reset: true,
},
// Demo values for the round-8/9 columns (synthetic, so the columns
// show variety offline). control_board is derived above via naming.
algorithm: "SHA256".to_string(),
control_board,
pic_present: if self.model_id.contains("S21") {
Some(false) // noPIC example
} else if self.make.eq_ignore_ascii_case("antminer") {
Some(true)
} else {
None // WhatsMiner: unknown over the network
},
// Access: idle/view-only units (no worker) shown locked; the rest
// unlocked. (Live rows infer this from control capabilities.)
write_locked: Some(self.worker.is_empty()),
// Concise, prefix-free lines (matching summarize_messages output):
// the Errors column shows the count, these are the hover tooltip.
errors: if self.model_id == "S21Pro" {
vec![
"hashrate 70% below expected".to_string(),
"chip temperature high (HashBoard 2)".to_string(),
]
} else {
Vec::new()
},
..Default::default()
}
}
}
/// The 9 bench boards. Two are idle (S17 stock, WardenOS dev), one is slow
/// (S21 Pro aml stock at ~30% of expected); the other six hash normally.
/// The 9 bench boards (9 rows total). One is idle/not-hashing (S17 stock,
/// .112); one is paused (WardenOS dev, .115 - deliberately rebucketed from idle
/// so the "paused" status/KPI bucket is exercisable offline); one is slow (S21
/// Pro aml stock at ~30% of expected); the other six hash normally.
///
/// Derived totals (used by the workflow tests):
/// total = 9, hashing = 6, slow = 1, not hashing = 2,
/// total = 9, hashing = 6, slow = 1, not hashing = 1, paused = 1,
/// total hashrate = 685.0 TH/s, total power = 21300 W.
pub fn bench_fleet() -> Vec<MinerRow> {
let boards = [
Board { ip: "10.255.1.112", model: "Antminer S17", firmware: "Stock",
// firmware families span the palette (Stock/VNish/Braiins/LuxOS/ePIC/
// Hive/BixBit/Alkane) so the offline demo shows the Firmware colouring.
Board { ip: "10.255.1.112", make: "Antminer", model_id: "S17", board: "Xilinx", firmware: "Stock", fw_version: "",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false },
Board { ip: "10.255.1.166", model: "Antminer S19", firmware: "[removed] 1.2",
worker: "", mining: false, paused: false },
Board { ip: "10.255.1.166", make: "Antminer", model_id: "S19", board: "BeagleBoneBlack", firmware: "VNish", fw_version: "1.2.8",
hashrate: 95.0, expected: 96.0, power: 3250.0, temp: 65.0, fan: 4200.0,
worker: "blueflare.s19", mining: true },
Board { ip: "10.255.1.152", model: "Antminer S19j Pro", firmware: "[removed] 1.2",
worker: "blueflare.s19", mining: true, paused: false },
Board { ip: "10.255.1.152", make: "Antminer", model_id: "S19jPro", board: "AMLogic", firmware: "Braiins", fw_version: "25.05.1",
hashrate: 100.0, expected: 104.0, power: 3100.0, temp: 62.0, fan: 3900.0,
worker: "blueflare.s19jpro", mining: true },
Board { ip: "10.255.1.167", model: "Antminer S19k Pro", firmware: "[removed] 1.2",
worker: "blueflare.s19jpro", mining: true, paused: false },
Board { ip: "10.255.1.167", make: "Antminer", model_id: "S19KPro", board: "AMLogic", firmware: "LuxOS", fw_version: "2024.9.0",
hashrate: 120.0, expected: 128.0, power: 3300.0, temp: 68.0, fan: 4500.0,
worker: "blueflare.s19kpro", mining: true },
Board { ip: "10.255.1.149", model: "Antminer S21 Pro", firmware: "Stock",
worker: "blueflare.s19kpro", mining: true, paused: false },
Board { ip: "10.255.1.149", make: "Antminer", model_id: "S21Pro", board: "CVITek", firmware: "ePIC", fw_version: "1.0.3",
hashrate: 60.0, expected: 200.0, power: 1500.0, temp: 55.0, fan: 3000.0,
worker: "blueflare.s21pro", mining: true }, // slow: 60/200 = 30%
Board { ip: "10.255.1.126", model: "WhatsMiner M30S", firmware: "WMOS H3",
worker: "blueflare.s21pro", mining: true, paused: false }, // slow: 60/200 = 30%
Board { ip: "10.255.1.126", make: "Whatsminer", model_id: "M30SVE40", board: "H3", firmware: "Stock", fw_version: "H3.0.1",
hashrate: 92.0, expected: 96.0, power: 3400.0, temp: 70.0, fan: 4800.0,
worker: "blueflare.h3", mining: true },
Board { ip: "10.255.1.131", model: "WhatsMiner M30S+", firmware: "WMOS H616",
worker: "blueflare.h3", mining: true, paused: false },
Board { ip: "10.255.1.131", make: "Whatsminer", model_id: "M30SPlusVE40", board: "H616", firmware: "Hive", fw_version: "1.0",
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
worker: "blueflare.h616", mining: true },
Board { ip: "10.255.1.148", model: "WhatsMiner M50", firmware: "WMOS CB4",
worker: "blueflare.h616", mining: true, paused: false },
Board { ip: "10.255.1.148", make: "Whatsminer", model_id: "M50VH50", board: "H6", firmware: "BixBit", fw_version: "2.1",
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
worker: "blueflare.m50", mining: true },
Board { ip: "10.255.1.115", model: "Antminer S19", firmware: "WardenOS dev",
worker: "blueflare.m50", mining: true, paused: false },
// Rebucketed from idle/not-hashing to paused so the "paused"
// status/KPI bucket is exercisable in the fake-scan/offline demo.
Board { ip: "10.255.1.115", make: "Antminer", model_id: "S19", board: "BeagleBoneBlack", firmware: "Alkane", fw_version: "0.1",
hashrate: 0.0, expected: 0.0, power: 0.0, temp: 0.0, fan: 0.0,
worker: "", mining: false },
worker: "", mining: false, paused: true },
];
boards.into_iter().map(Board::into_row).collect()
}
+162
View File
@@ -0,0 +1,162 @@
//! Lightweight UI localization (round 15 #13).
//!
//! Visible strings are wrapped in `t("English text")`; the English text is the
//! lookup key. `t` returns the translation for the current language, falling back
//! to the English key when a string has no translation yet. The language is a
//! process-global, persisted under the config dir; changing it re-titles the
//! table columns and toolbar/KPI labels live and localizes dialogs as they open.
use std::path::PathBuf;
use std::sync::atomic::{AtomicU8, Ordering};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Lang {
En,
Zh,
Ru,
Fr,
Es,
Pt,
}
impl Lang {
pub fn all() -> [Lang; 6] {
[Lang::En, Lang::Zh, Lang::Ru, Lang::Fr, Lang::Es, Lang::Pt]
}
/// The language's own name, for the selector menu.
pub fn label(self) -> &'static str {
match self {
Lang::En => "English",
Lang::Zh => "\u{4e2d}\u{6587}", // 中文
Lang::Ru => "\u{0420}\u{0443}\u{0441}\u{0441}\u{043a}\u{0438}\u{0439}", // Русский
Lang::Fr => "Fran\u{e7}ais",
Lang::Es => "Espa\u{f1}ol",
Lang::Pt => "Portugu\u{ea}s",
}
}
fn code(self) -> &'static str {
match self {
Lang::En => "en",
Lang::Zh => "zh",
Lang::Ru => "ru",
Lang::Fr => "fr",
Lang::Es => "es",
Lang::Pt => "pt",
}
}
fn from_code(s: &str) -> Lang {
match s.trim() {
"zh" => Lang::Zh,
"ru" => Lang::Ru,
"fr" => Lang::Fr,
"es" => Lang::Es,
"pt" => Lang::Pt,
_ => Lang::En,
}
}
fn index(self) -> usize {
match self {
Lang::En => 0,
Lang::Zh => 1,
Lang::Ru => 2,
Lang::Fr => 3,
Lang::Es => 4,
Lang::Pt => 5,
}
}
}
static CURRENT: AtomicU8 = AtomicU8::new(0);
const LANG_FILE: &str = "language.txt";
fn config_path() -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(".config/alkane-toolkit").join(LANG_FILE)
}
/// Load the saved language into the global (call once at startup).
pub fn init() {
let l = std::fs::read_to_string(config_path())
.ok()
.map(|s| Lang::from_code(&s))
.unwrap_or(Lang::En);
CURRENT.store(lang_to_u8(l), Ordering::Relaxed);
}
pub fn current() -> Lang {
u8_to_lang(CURRENT.load(Ordering::Relaxed))
}
/// Set + persist the language.
pub fn set(l: Lang) {
CURRENT.store(lang_to_u8(l), Ordering::Relaxed);
let p = config_path();
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(p, l.code());
}
fn lang_to_u8(l: Lang) -> u8 {
l.index() as u8
}
fn u8_to_lang(v: u8) -> Lang {
Lang::all().get(v as usize).copied().unwrap_or(Lang::En)
}
/// Translate `key` (an English string) to the current language, or return `key`
/// when there is no translation.
pub fn t(key: &str) -> String {
let lang = current();
if lang == Lang::En {
return key.to_string();
}
for (en, tr) in TABLE {
if *en == key {
let s = tr[lang.index()];
if !s.is_empty() {
return s.to_string();
}
break;
}
}
key.to_string()
}
// Translation table: (English, [en, zh, ru, fr, es, pt]). The en slot mirrors the
// key (unused by `t`, kept for readability). An empty slot falls back to English.
#[rustfmt::skip]
const TABLE: &[(&str, [&str; 6])] = &[
// Toolbar + settings
("Scan ranges", ["Scan ranges", "\u{626b}\u{63cf}\u{8303}\u{56f4}", "\u{0414}\u{0438}\u{0430}\u{043f}\u{0430}\u{0437}\u{043e}\u{043d}\u{044b}", "Plages", "Rangos", "Faixas"]),
("Presets", ["Presets", "\u{9884}\u{8bbe}", "\u{041f}\u{0440}\u{0435}\u{0441}\u{0435}\u{0442}\u{044b}", "Pr\u{e9}r\u{e9}glages", "Ajustes", "Predefini\u{e7}\u{f5}es"]),
("Filter", ["Filter", "\u{7b5b}\u{9009}", "\u{0424}\u{0438}\u{043b}\u{044c}\u{0442}\u{0440}", "Filtre", "Filtro", "Filtro"]),
("Columns", ["Columns", "\u{5217}", "\u{0421}\u{0442}\u{043e}\u{043b}\u{0431}\u{0446}\u{044b}", "Colonnes", "Columnas", "Colunas"]),
("Export", ["Export", "\u{5bfc}\u{51fa}", "\u{042d}\u{043a}\u{0441}\u{043f}\u{043e}\u{0440}\u{0442}", "Exporter", "Exportar", "Exportar"]),
("Settings", ["Settings", "\u{8bbe}\u{7f6e}", "\u{041d}\u{0430}\u{0441}\u{0442}\u{0440}\u{043e}\u{0439}\u{043a}\u{0438}", "Param\u{e8}tres", "Ajustes", "Configura\u{e7}\u{f5}es"]),
("Credentials", ["Credentials", "\u{51ed}\u{636e}", "\u{0423}\u{0447}\u{0451}\u{0442}\u{043d}\u{044b}\u{0435} \u{0434}\u{0430}\u{043d}\u{043d}\u{044b}\u{0435}", "Identifiants", "Credenciales", "Credenciais"]),
("Language", ["Language", "\u{8bed}\u{8a00}", "\u{042f}\u{0437}\u{044b}\u{043a}", "Langue", "Idioma", "Idioma"]),
("Logs", ["Logs", "\u{65e5}\u{5fd7}", "\u{0416}\u{0443}\u{0440}\u{043d}\u{0430}\u{043b}", "Journaux", "Registros", "Registos"]),
// KPI captions
("Total", ["Total", "\u{603b}\u{6570}", "\u{0412}\u{0441}\u{0435}\u{0433}\u{043e}", "Total", "Total", "Total"]),
("Hashing", ["Hashing", "\u{6b63}\u{5728}\u{6316}\u{77ff}", "\u{0425}\u{0435}\u{0448}\u{0438}\u{0440}\u{043e}\u{0432}\u{0430}\u{043d}\u{0438}\u{0435}", "Minage", "Minando", "Minerando"]),
("Slow", ["Slow", "\u{7f13}\u{6162}", "\u{041c}\u{0435}\u{0434}\u{043b}\u{0435}\u{043d}\u{043d}\u{043e}", "Lent", "Lento", "Lento"]),
("Not hashing", ["Not hashing", "\u{672a}\u{6316}\u{77ff}", "\u{041d}\u{0435} \u{0445}\u{0435}\u{0448}\u{0438}\u{0440}\u{0443}\u{0435}\u{0442}", "Inactif", "Inactivo", "Inativo"]),
("Paused", ["Paused", "\u{5df2}\u{6682}\u{505c}", "\u{041f}\u{0430}\u{0443}\u{0437}\u{0430}", "En pause", "Pausado", "Pausado"]),
("Est. power", ["Est. power", "\u{4f30}\u{8ba1}\u{529f}\u{7387}", "\u{041e}\u{0446}. \u{043c}\u{043e}\u{0449}\u{043d}.", "Puiss. est.", "Pot. est.", "Pot. est."]),
// Column headers (the default-visible set + common ones)
("Model", ["Model", "\u{578b}\u{53f7}", "\u{041c}\u{043e}\u{0434}\u{0435}\u{043b}\u{044c}", "Mod\u{e8}le", "Modelo", "Modelo"]),
("Health", ["Health", "\u{72b6}\u{6001}", "\u{0421}\u{043e}\u{0441}\u{0442}\u{043e}\u{044f}\u{043d}\u{0438}\u{0435}", "\u{c9}tat", "Estado", "Sa\u{fa}de"]),
("Hashrate", ["Hashrate", "\u{7b97}\u{529b}", "\u{0425}\u{0435}\u{0448}\u{0440}\u{0435}\u{0439}\u{0442}", "Hashrate", "Hashrate", "Hashrate"]),
("Power", ["Power", "\u{529f}\u{7387}", "\u{041c}\u{043e}\u{0449}\u{043d}\u{043e}\u{0441}\u{0442}\u{044c}", "Puissance", "Potencia", "Pot\u{ea}ncia"]),
("Chip temp", ["Chip temp", "\u{82af}\u{7247}\u{6e29}\u{5ea6}", "\u{0422}\u{0435}\u{043c}\u{043f}. \u{0447}\u{0438}\u{043f}\u{0430}", "Temp. puce", "Temp. chip", "Temp. chip"]),
("Firmware", ["Firmware", "\u{56fa}\u{4ef6}", "\u{041f}\u{0440}\u{043e}\u{0448}\u{0438}\u{0432}\u{043a}\u{0430}", "Firmware", "Firmware", "Firmware"]),
("CPU", ["CPU", "CPU", "\u{041f}\u{0440}\u{043e}\u{0446}.", "Processeur", "CPU", "CPU"]),
("Access", ["Access", "\u{8bbf}\u{95ee}", "\u{0414}\u{043e}\u{0441}\u{0442}\u{0443}\u{043f}", "Acc\u{e8}s", "Acceso", "Acesso"]),
("Light", ["Light", "\u{6307}\u{793a}\u{706f}", "\u{041f}\u{043e}\u{0434}\u{0441}\u{0432}\u{0435}\u{0442}\u{043a}\u{0430}", "Voyant", "Luz", "Luz"]),
("Fan (RPM)", ["Fan (RPM)", "\u{98ce}\u{6247} (RPM)", "\u{0412}\u{0435}\u{043d}\u{0442}. (\u{043e}\u{0431}/\u{043c}\u{0438}\u{043d})", "Ventilo (TR/M)", "Ventilador (RPM)", "Ventoinha (RPM)"]),
("Control Board", ["Control Board", "\u{63a7}\u{5236}\u{677f}", "\u{041f}\u{043b}\u{0430}\u{0442}\u{0430} \u{0443}\u{043f}\u{0440}.", "Carte de contr\u{f4}le", "Placa control", "Placa controlo"]),
("Uptime", ["Uptime", "\u{8fd0}\u{884c}\u{65f6}\u{95f4}", "\u{0412}\u{0440}\u{0435}\u{043c}\u{044f} \u{0440}\u{0430}\u{0431}.", "Dur\u{e9}e", "Tiempo activo", "Tempo ativo"]),
("Serial", ["Serial", "\u{5e8f}\u{5217}\u{53f7}", "\u{0421}\u{0435}\u{0440}\u{0438}\u{0439}\u{043d}\u{044b}\u{0439}", "N\u{b0} de s\u{e9}rie", "N\u{b0} de serie", "N\u{b0} de s\u{e9}rie"]),
];
+264
View File
@@ -0,0 +1,264 @@
//! Fetch a miner's log over its firmware API and regex-scan it for useful
//! signals (round 12 #12). This is the "logs through API" path the operator
//! asked for: where a firmware exposes its log we can read board/PIC lines and
//! other metrics without SSH.
//!
//! Per firmware:
//! - VNish (aftermarket Antminer): POST /api/v1/unlock to get a bearer token,
//! then GET /api/v1/logs/miner -- the full miner log (PSU init, per-chain
//! chip detection, tuning, errors).
//! - Stock Antminer: GET /cgi-bin/log.cgi behind digest auth (older models
//! such as the Z15 do not serve it -> reported as unavailable).
//! - WhatsMiner: the btminer log is not exposed on :4028, but get_error_code
//! (unauthenticated) returns the active fault codes, which we format as the
//! log view.
//!
//! We shell out to `curl` (already a dependency of the access probe) so the
//! offline/vendored build gains no new crate, and cap the fetched text so a huge
//! log never bloats the viewer.
use std::process::Command;
use std::time::Duration;
/// Cap on the log text we keep for display (bytes); the regex summary is still
/// computed over everything fetched.
const MAX_LOG_BYTES: usize = 256 * 1024;
/// A fetched log plus the signals a regex pass pulled out of it.
pub struct LogScan {
/// The (possibly tail-trimmed) log text for the viewer.
pub text: String,
/// One-line-per-finding summary shown above the log.
pub summary: Vec<String>,
}
/// Fetch and scan one miner's log. `brand` is the make ("Antminer"/"Whatsminer"),
/// `firmware` the family ("VNish"/"Stock"/...). `vnish_pass`/`wm` creds are used
/// where that firmware needs auth. Returns `Err` only when no log could be read.
pub fn scan_log(
ip: &str,
brand: &str,
firmware: &str,
vnish_pass: &str,
antminer_user: &str,
antminer_pass: &str,
) -> Result<LogScan, String> {
let raw = if firmware.eq_ignore_ascii_case("vnish") {
fetch_vnish_log(ip, vnish_pass)?
} else if brand.eq_ignore_ascii_case("whatsminer") {
fetch_whatsminer_errors(ip)?
} else {
// Stock / other Antminer-family web firmware.
fetch_antminer_log(ip, antminer_user, antminer_pass)?
};
let summary = summarize_log(&raw);
Ok(LogScan { text: tail(&raw, MAX_LOG_BYTES), summary })
}
/// Keep the last `max` bytes of `s` (a log's tail is the freshest), on a line
/// boundary, with a marker when trimmed.
fn tail(s: &str, max: usize) -> String {
if s.len() <= max {
return s.to_string();
}
let start = s.len() - max;
// advance to the next line boundary so we don't cut a line in half
let start = s[start..]
.find('\n')
.map(|i| start + i + 1)
.unwrap_or(start);
format!("[... earlier log trimmed ...]\n{}", &s[start..])
}
/// Regex-free scan for the high-value signals in a miner log: PIC / hashboard
/// firmware lines, per-chain chip detection, and the most recent errors.
fn summarize_log(log: &str) -> Vec<String> {
let mut out = Vec::new();
let lc_has = |line: &str, needle: &str| line.to_ascii_lowercase().contains(needle);
// PIC / hashboard-controller status from the log. Aftermarket firmwares state
// it explicitly ("no-PIC miner"); stock boot logs print a PIC version. This
// is the log-regex PIC scan the operator asked for (round 12 #12).
let pic_lines: Vec<&str> = log.lines().filter(|l| lc_has(l, "pic")).collect();
if pic_lines.iter().any(|l| lc_has(l, "no-pic") || lc_has(l, "no pic")) {
out.push("PIC: not present (log reports a no-PIC miner)".to_string());
} else if let Some(l) = pic_lines
.iter()
.find(|l| lc_has(l, "version") || lc_has(l, "fw") || lc_has(l, "found"))
{
out.push(format!("PIC: present -- {}", l.trim()));
} else if !pic_lines.is_empty() {
out.push(format!("PIC: {} log line(s) mention PIC", pic_lines.len()));
for l in pic_lines.iter().take(3) {
out.push(format!(" {}", l.trim()));
}
} else {
out.push("PIC: no PIC lines in the log".to_string());
}
// Latest per-chain chip-detection line (the most recent board bring-up).
if let Some(l) = log.lines().rev().find(|l| lc_has(l, "chips detected")) {
out.push(format!("Chains: {}", l.trim()));
}
// Recent errors (log history, beyond asic-rs's current-message snapshot).
// Skip the get_error_code header line (it contains "error" but is not one).
let errors: Vec<&str> = log
.lines()
.rev()
.filter(|l| (lc_has(l, "error") || lc_has(l, "fail")) && !lc_has(l, "get_error_code"))
.take(3)
.collect();
if errors.is_empty() {
out.push("Errors: none in the log".to_string());
} else {
out.push(format!("Errors: {} recent", errors.len()));
for l in errors {
out.push(format!(" {}", l.trim()));
}
}
out
}
/// VNish: unlock -> bearer -> the full miner log.
fn fetch_vnish_log(ip: &str, pass: &str) -> Result<String, String> {
let unlock = curl(&[
"-s",
"--connect-timeout",
"5",
"--max-time",
"9",
"-X",
"POST",
"-H",
"Content-Type: application/json",
"-d",
&format!("{{\"pw\":\"{pass}\"}}"),
&format!("http://{ip}/api/v1/unlock"),
])?;
let token = serde_json::from_str::<serde_json::Value>(&unlock)
.ok()
.and_then(|v| v.get("token").and_then(|t| t.as_str()).map(str::to_string))
.filter(|t| !t.is_empty())
.ok_or_else(|| "VNish unlock rejected (check the VNish password in scan credentials)".to_string())?;
let log = curl(&[
"-s",
"--connect-timeout",
"5",
"--max-time",
"12",
"-H",
&format!("Authorization: Bearer {token}"),
&format!("http://{ip}/api/v1/logs/miner"),
])?;
if log.trim().is_empty() {
return Err("VNish returned an empty log".to_string());
}
Ok(log)
}
/// Stock Antminer web log (digest auth). Absent on older models (404).
fn fetch_antminer_log(ip: &str, user: &str, pass: &str) -> Result<String, String> {
let body = curl(&[
"-s",
"--digest",
"-u",
&format!("{user}:{pass}"),
"--connect-timeout",
"5",
"--max-time",
"12",
&format!("http://{ip}/cgi-bin/log.cgi"),
])?;
if body.contains("404 - Not Found") || body.trim().is_empty() {
return Err("this firmware does not expose a log over its web API".to_string());
}
Ok(body)
}
/// WhatsMiner: format the active error codes (get_error_code, unauthenticated).
fn fetch_whatsminer_errors(ip: &str) -> Result<String, String> {
let resp = crate::access_probe::whatsminer_get_error_code(ip)
.ok_or_else(|| "WhatsMiner did not answer get_error_code on :4028".to_string())?;
Ok(resp)
}
/// Run curl and return stdout, with a hard wall-clock cap. stdout is drained on a
/// separate thread so a large log (hundreds of KB) never deadlocks on a full pipe
/// -- the reason a naive "wait then read" times out on the VNish log.
fn curl(args: &[&str]) -> Result<String, String> {
use std::io::Read;
let mut cmd = Command::new("curl");
cmd.args(args);
cmd.stdout(std::process::Stdio::piped());
cmd.stderr(std::process::Stdio::null());
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
let mut stdout = child.stdout.take().ok_or("no curl stdout")?;
let reader = std::thread::spawn(move || {
let mut buf = Vec::new();
let _ = stdout.read_to_end(&mut buf);
buf
});
let timeout = Duration::from_secs(20);
let start = std::time::Instant::now();
let mut timed_out = false;
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(_) => break,
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
timed_out = true;
break;
}
std::thread::sleep(Duration::from_millis(50));
}
}
}
let buf = reader.join().unwrap_or_default();
if timed_out && buf.is_empty() {
return Err("log fetch timed out".into());
}
Ok(String::from_utf8_lossy(&buf).into_owned())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn summarize_finds_pic_chains_and_errors() {
let log = "\
[t] INFO: Initializing PSU
[t] INFO: chain#1 - 126 chips detected
[t] INFO: check PIC on chain 1: version 0x03
[t] ERROR: Failed load miner config
[t] INFO: chain#2 - 126 chips detected";
let s = summarize_log(log);
assert!(s.iter().any(|l| l.contains("PIC: present")), "PIC present: {s:?}");
assert!(s.iter().any(|l| l.contains("chips detected")), "chains: {s:?}");
assert!(s.iter().any(|l| l.contains("Errors: 1")), "errors: {s:?}");
}
#[test]
fn summarize_detects_no_pic_miner() {
let log = "[t] ERROR: This is a no-PIC miner, so all connected chains ...\n[t] INFO: mining";
let s = summarize_log(log);
assert!(s.iter().any(|l| l.contains("PIC: not present")), "{s:?}");
}
#[test]
fn summarize_handles_no_pic_lines() {
let log = "[t] INFO: chain#1 - 126 chips detected\n[t] INFO: mining";
let s = summarize_log(log);
assert!(s.iter().any(|l| l.contains("no PIC lines")), "{s:?}");
}
#[test]
fn tail_trims_on_line_boundary() {
let log = "aaaa\nbbbb\ncccc\n";
let t = tail(log, 6);
assert!(t.starts_with("[... earlier log trimmed ...]"), "{t}");
assert!(t.ends_with("cccc\n"));
}
}
+42
View File
@@ -0,0 +1,42 @@
//! In-app activity log (round 15 #13). A small, process-global ring buffer of
//! timestamped messages -- scans starting/finishing, operations applied, errors --
//! shown in the Settings > Logs page. Thread-safe so background workers can append.
use std::sync::Mutex;
use std::time::{SystemTime, UNIX_EPOCH};
const MAX_ENTRIES: usize = 2000;
static LOG: Mutex<Vec<String>> = Mutex::new(Vec::new());
/// Local wall-clock HH:MM:SS for a log line. Uses the system clock offset from
/// UTC via the TZ-less epoch; good enough for an activity log timestamp.
fn stamp() -> String {
let secs = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
let t = secs % 86_400;
format!("{:02}:{:02}:{:02}", t / 3600, (t % 3600) / 60, t % 60)
}
/// Append a message to the activity log (timestamped).
pub fn log(msg: impl Into<String>) {
let line = format!("{} {}", stamp(), msg.into());
if let Ok(mut v) = LOG.lock() {
v.push(line);
let len = v.len();
if len > MAX_ENTRIES {
v.drain(0..len - MAX_ENTRIES);
}
}
}
/// The whole log as one string, newest last (for the Logs page text box).
pub fn dump() -> String {
LOG.lock().map(|v| v.join("\n")).unwrap_or_default()
}
/// Clear the log.
pub fn clear() {
if let Ok(mut v) = LOG.lock() {
v.clear();
}
}
+56
View File
@@ -1,8 +1,18 @@
//! alkane-toolkit — primary view (docs/UI-SPEC.md).
//! Pure-Rust wxWidgets app on the vendored, patched wx-rs.
mod access_probe;
mod credentials;
mod export;
mod fixtures;
mod i18n;
mod logs;
mod log_scan;
mod model;
mod naming;
mod pool_prefs;
mod presets;
mod restore;
mod scan;
mod ui;
@@ -16,6 +26,52 @@ fn main() {
std::process::exit(run_selftest());
}
// Headless access-probe check: `ALKANE_ACCESS_PROBE="<ip> <make>"` prints the
// lock state the real access probe computes (no GUI, no wx), so the WhatsMiner
// :4028 token check and the Antminer digest check can be verified directly.
if let Some(spec) = std::env::var_os("ALKANE_ACCESS_PROBE") {
let spec = spec.to_string_lossy();
let mut it = spec.split_whitespace();
let ip = it.next().unwrap_or("");
let make = it.next().unwrap_or("");
let (user, pass) = credentials::load_credentials().unwrap_or_default();
match access_probe::probe_access(ip, make, &user, &pass) {
Ok(Some(true)) => println!("ACCESS {ip} {make}: LOCKED"),
Ok(Some(false)) => println!("ACCESS {ip} {make}: UNLOCKED"),
Ok(None) => println!("ACCESS {ip} {make}: INDETERMINATE"),
Err(e) => println!("ACCESS {ip} {make}: ERROR {e}"),
}
std::process::exit(0);
}
// Headless log-scan check: `ALKANE_LOG_SCAN="<ip> <brand> <firmware>"` fetches
// the miner's log over its firmware API and prints the regex summary (round
// 12 #12), so the VNish/Antminer/WhatsMiner log paths can be verified without
// the GUI.
if let Some(spec) = std::env::var_os("ALKANE_LOG_SCAN") {
let spec = spec.to_string_lossy();
let mut it = spec.split_whitespace();
let ip = it.next().unwrap_or("");
let brand = it.next().unwrap_or("");
let firmware = it.next().unwrap_or("");
let (au, ap) = credentials::load_credentials().unwrap_or_else(|| ("root".into(), "root".into()));
let vp = credentials::firmware_default_for("VNish").1;
let vp = if vp.is_empty() { "admin".to_string() } else { vp };
match log_scan::scan_log(ip, brand, firmware, &vp, &au, &ap) {
Ok(s) => {
println!("LOGSCAN {ip} ({brand}/{firmware}): {} log bytes", s.text.len());
for line in &s.summary {
println!(" {line}");
}
}
Err(e) => println!("LOGSCAN {ip} ({brand}/{firmware}): ERROR {e}"),
}
std::process::exit(0);
}
// Load the saved UI language before any strings are built (round 15 #13).
i18n::init();
// Bootstrap the wx app + main frame (upstream bridge).
wx_rs::init_app("alkane-toolkit", 1280, 800);
// Follow the system light/dark appearance.
File diff suppressed because it is too large Load Diff
+413
View File
@@ -0,0 +1,413 @@
//! Display-layer device-naming cleanup (round-9 item #11).
//!
//! asic-rs hands us compact Rust-identifier model strings and bare control-board
//! names, not human-facing labels:
//! - `device_info.make` = "Antminer" / "Whatsminer" (note the casing)
//! - `device_info.model` = the model enum's variant identifier verbatim, e.g.
//! "S19KPro", "S19jPro", "M30SPlusVE40", "M30SPlusPlusVE40" -- no spaces,
//! "+" rendered "Plus", "++" rendered "PlusPlus", the WhatsMiner version
//! block ("VE40") baked in.
//! - `control_board_version` = a bare board name ("Xilinx", "CVITek",
//! "AMLogic", "BeagleBoneBlack"; WhatsMiner "H3"/"H6"/"H6OS"/"H616").
//!
//! This module turns those into the Brand / Model / Submodel / control-board
//! short code the table shows. It is a pure string transform -- no asic-rs edit
//! -- so it stays a build-on-top layer over the vendored crate.
//!
//! Known limitations (asic-rs does not expose the data):
//! - Antminer has no hashboard-type/submodel over the network, so Submodel is
//! blank for Antminer (only WhatsMiner's version block is recoverable).
//! - asic-rs reports only "AMLogic" (not the 120mm C76 vs 140mm CBE board) and
//! only "Xilinx" (not C49 vs C55); we disambiguate by model family as a
//! best-effort heuristic documented at `control_board_code`.
/// Human brand from asic-rs `device_info.make`.
pub fn brand(make: &str) -> String {
match make.trim().to_ascii_lowercase().as_str() {
"antminer" => "Antminer".to_string(),
"whatsminer" => "WhatsMiner".to_string(),
"" => String::new(),
other => {
// Title-case an unknown make so the Brand column still reads well.
let mut c = other.chars();
match c.next() {
Some(f) => f.to_ascii_uppercase().to_string() + c.as_str(),
None => String::new(),
}
}
}
}
fn is_whatsminer(make: &str) -> bool {
make.trim().eq_ignore_ascii_case("whatsminer")
}
fn is_antminer(make: &str) -> bool {
make.trim().eq_ignore_ascii_case("antminer")
}
/// Split asic-rs's firmware family string into the family shown in the Firmware
/// column and an optional vendor prefix that moves into the FW Version column
/// (round 11 #6). asic-rs reports stock firmware as "AntMiner Stock" /
/// "WhatsMiner Stock"; the Firmware column should read just "Stock" (so it
/// colours as the neutral/default family), and the vendor word belongs with the
/// version. Aftermarket families ("VNish", "Braiins", ...) carry no vendor
/// prefix and pass through unchanged.
pub fn firmware_family(raw: &str) -> (String, Option<String>) {
let trimmed = raw.trim();
// Vendor prefixes asic-rs prepends on stock-firmware family strings, matched
// case-insensitively.
for vendor in ["AntMiner", "WhatsMiner"] {
if trimmed.len() > vendor.len() && trimmed[..vendor.len()].eq_ignore_ascii_case(vendor) {
let rest = trimmed[vendor.len()..].trim();
if !rest.is_empty() {
return (rest.to_string(), Some(vendor.to_string()));
}
}
}
(trimmed.to_string(), None)
}
/// Whether a miner is liquid-cooled (hydro / water / immersion) rather than
/// air-cooled, inferred from the model name (round 11 #17). asic-rs exposes no
/// cooling-type field, so this is a best-effort model-string heuristic: it
/// decides whether a reported "fluid" temperature is a real coolant reading or
/// (for air-cooled units) the ambient/environment temperature.
pub fn is_liquid_cooled(model: &str) -> bool {
let m = model.to_ascii_lowercase();
m.contains("hydro") || m.contains("immers") || m.contains("water")
}
/// The human model name for the Model column: brand dropped (it has its own
/// column), family-letter suffix lowercased, word suffixes spaced, "+"/"++" for
/// Plus/PlusPlus, and (WhatsMiner) the trailing version block moved to Submodel.
pub fn clean_model(make: &str, model_id: &str) -> String {
let id = model_id.trim();
if id.is_empty() {
return String::new();
}
if is_whatsminer(make) {
clean_whatsminer(id).0
} else if is_antminer(make) {
clean_antminer(id)
} else {
id.to_string()
}
}
/// The Submodel column value. WhatsMiner: the version block ("VE40"). Antminer:
/// empty -- the hashboard type is not reported over the network by asic-rs.
pub fn submodel(make: &str, model_id: &str) -> String {
if is_whatsminer(make) {
clean_whatsminer(model_id.trim()).1
} else {
String::new()
}
}
/// Split a WhatsMiner identifier into (clean model, version submodel). The
/// version block is the trailing run beginning at the first 'V' (WhatsMiner
/// tiers never contain a 'V', so the first 'V' always starts the version). The
/// prefix's Plus/PlusPlus become +/++.
fn clean_whatsminer(id: &str) -> (String, String) {
let (prefix, version) = match id.find('V') {
Some(i) => (&id[..i], id[i..].to_string()),
None => (id, String::new()),
};
let model = prefix.replace("PlusPlus", "++").replace("Plus", "+");
(model, version)
}
/// Known Antminer word-suffixes, longest-first so "PlusPlus" wins over "Plus"
/// and "NoPIC" is matched whole. Each maps to its spaced display form.
const ANT_SUFFIXES: &[(&str, &str)] = &[
("PlusPlus", "++"),
("Plus", "+"),
("NoPIC", " NoPIC"),
("Hydro", " Hydro"),
("Pro", " Pro"),
("XP", " XP"),
];
/// Clean an Antminer identifier, e.g. "S19KPro" -> "S19k Pro", "S21eXPHydro" ->
/// "S21e XP Hydro", "L3PlusPlus" -> "L3++". Unknown/odd inputs pass through.
fn clean_antminer(id: &str) -> String {
// asic-rs "Unknown" models pass the raw vendor string through with the brand
// still in it (e.g. "ANTMINER S19 (88)", a NoPIC S19); drop a redundant
// leading brand word so the Model column never repeats the Brand column.
let id = if id.len() >= 9 && id[..9].eq_ignore_ascii_case("ANTMINER ") {
id[9..].trim_start()
} else {
id
};
let bytes = id.as_bytes();
// Base = leading letters then digits ("S19", "KS5", "L3", "Z15"). Without a
// letter+digit base (e.g. an Unknown passthrough), return the id unchanged.
let mut i = 0;
while i < bytes.len() && bytes[i].is_ascii_alphabetic() {
i += 1;
}
let letters_end = i;
while i < bytes.len() && bytes[i].is_ascii_digit() {
i += 1;
}
if letters_end == 0 || i == letters_end {
return id.to_string();
}
let mut out = String::from(&id[..i]);
let mut rest = &id[i..];
// An optional single family letter directly after the digits (j/i/a/e/K/L),
// recognised as "not the start of a known suffix". Lowercase it, keep it
// attached to the base (no space): "S19K" -> "S19k".
if let Some(first) = rest.chars().next() {
let starts_suffix = ANT_SUFFIXES.iter().any(|(s, _)| rest.starts_with(s));
if first.is_ascii_alphabetic() && !starts_suffix {
out.push(first.to_ascii_lowercase());
rest = &rest[first.len_utf8()..];
}
}
// Remaining suffix words, matched greedily against the known set.
while !rest.is_empty() {
match ANT_SUFFIXES.iter().find(|(s, _)| rest.starts_with(s)) {
Some((s, disp)) => {
out.push_str(disp);
rest = &rest[s.len()..];
}
None => {
// Unknown trailing token: emit it space-separated and stop.
out.push(' ');
out.push_str(rest.trim_start());
break;
}
}
}
out
}
/// Normalise a raw control-board name for matching: drop spaces/punctuation and
/// uppercase, so "BeagleBone Black", "BeagleBoneBlack" and "BBB" all collapse.
fn compact_upper(s: &str) -> String {
s.chars().filter(|c| c.is_ascii_alphanumeric()).flat_map(|c| c.to_uppercase()).collect()
}
/// The control-board short code for the Control-board column, e.g.
/// "BeagleBoneBlack" -> "BBB (C77)", "Xilinx" on an S17 -> "XIL (C49)".
///
/// asic-rs reports only the board FAMILY ("AMLogic"/"Xilinx"), never the exact
/// Bitmain board number, so where a family spans two boards we disambiguate by
/// model era/class (best-effort, since the network data can't distinguish them):
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
/// - AMLogic: XP-class / S19k (140mm fans) -> CBE, otherwise (120mm) -> C76.
/// `clean_model` is the already-cleaned model name (used for the era/class test).
pub fn control_board_code(make: &str, board_name: &str, clean_model: &str) -> String {
let (cpu, code) = control_board_split(make, board_name, clean_model);
if code.is_empty() {
cpu
} else {
format!("{cpu} ({code})")
}
}
/// The control-board CPU family short code alone ("AML", "CVI", "BBB", "XIL",
/// WhatsMiner "H3"/"H6"/"H6os"/"H616", or the raw name if unrecognised).
pub fn control_board_cpu(make: &str, board_name: &str, clean_model: &str) -> String {
control_board_split(make, board_name, clean_model).0
}
/// The Bitmain board code alone ("C77"/"C88"/"C49"/"C55"/"C76"/"CBE";
/// WhatsMiner "CB2"/"CB4"/"CB6"), or "" when unknown.
pub fn control_board_board(make: &str, board_name: &str, clean_model: &str) -> String {
control_board_split(make, board_name, clean_model).1
}
/// Split a raw control-board name into (CPU family short code, Bitmain board
/// code). asic-rs reports only the board FAMILY ("AMLogic"/"Xilinx"), never the
/// exact board number, so where a family spans two boards we disambiguate by
/// model era/class (best-effort):
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
/// - AMLogic: XP-class / S19k / S21 (140mm fans) -> CBE, otherwise 120mm C76.
fn control_board_split(make: &str, board_name: &str, clean_model: &str) -> (String, String) {
let raw = board_name.trim();
if raw.is_empty() {
return (String::new(), String::new());
}
// asic-rs renders an unrecognised board as "Unknown: <raw>"; surface it in
// the CPU part with no code.
if raw.starts_with("Unknown") {
return (raw.to_string(), String::new());
}
let key = compact_upper(raw);
let pair = |cpu: &str, code: &str| (cpu.to_string(), code.to_string());
if is_whatsminer(make) {
return match key.as_str() {
"H3" => pair("H3", "CB2"),
"H6" => pair("H6", "CB4"),
"H6OS" => pair("H6os", "CB4"),
"H616" => pair("H616", "CB6"),
_ => (raw.to_string(), String::new()),
};
}
// Antminer (and any make that reports these families).
match key.as_str() {
"BEAGLEBONEBLACK" | "BBB" | "BB" | "BEAGLEBONE" => pair("BBB", "C77"),
"CVITEK" | "CVI" => pair("CVI", "C88"),
"XILINX" | "XIL" => {
if is_s17_era(clean_model) {
pair("XIL", "C49")
} else {
pair("XIL", "C55")
}
}
"AMLOGIC" | "AML" => {
if is_aml_140mm(clean_model) {
pair("AML", "CBE")
} else {
pair("AML", "C76")
}
}
_ => (raw.to_string(), String::new()),
}
}
/// S17/T17-era models use the Xilinx C49 control board.
fn is_s17_era(clean_model: &str) -> bool {
let m = clean_model.trim_start();
m.starts_with("S17") || m.starts_with("T17")
}
/// Best-effort: the 140mm-fan AMLogic board (CBE) is used on the XP-class, the
/// S19k Pro, and the S21 Pro; everything else AMLogic is the 120mm C76. asic-rs
/// cannot tell these apart, so this is a model-family heuristic, not a read.
fn is_aml_140mm(clean_model: &str) -> bool {
let m = clean_model.trim_start();
m.contains("XP") || m.starts_with("S19k") || m.starts_with("S21")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn brand_normalises_case() {
assert_eq!(brand("Antminer"), "Antminer");
assert_eq!(brand("Whatsminer"), "WhatsMiner");
assert_eq!(brand("whatsminer"), "WhatsMiner");
assert_eq!(brand(""), "");
assert_eq!(brand("avalonminer"), "Avalonminer");
}
#[test]
fn antminer_model_cleanup() {
// The headline example from the spec.
assert_eq!(clean_model("Antminer", "S19KPro"), "S19k Pro");
assert_eq!(clean_model("Antminer", "S19jPro"), "S19j Pro");
assert_eq!(clean_model("Antminer", "S21Pro"), "S21 Pro");
assert_eq!(clean_model("Antminer", "S19"), "S19");
assert_eq!(clean_model("Antminer", "S19XP"), "S19 XP");
assert_eq!(clean_model("Antminer", "S19jXP"), "S19j XP");
assert_eq!(clean_model("Antminer", "S19Plus"), "S19+");
assert_eq!(clean_model("Antminer", "S19ProPlus"), "S19 Pro+");
assert_eq!(clean_model("Antminer", "S19jProPlus"), "S19j Pro+");
assert_eq!(clean_model("Antminer", "S19ProPlusHydro"), "S19 Pro+ Hydro");
assert_eq!(clean_model("Antminer", "S19jNoPIC"), "S19j NoPIC");
assert_eq!(clean_model("Antminer", "S21PlusPlus"), "S21++");
assert_eq!(clean_model("Antminer", "S21eXPHydro"), "S21e XP Hydro");
assert_eq!(clean_model("Antminer", "L3PlusPlus"), "L3++");
assert_eq!(clean_model("Antminer", "KS5Pro"), "KS5 Pro");
assert_eq!(clean_model("Antminer", "Z15Pro"), "Z15 Pro");
assert_eq!(clean_model("Antminer", "S9i"), "S9i");
assert_eq!(clean_model("Antminer", "S17e"), "S17e");
assert_eq!(clean_model("Antminer", "S19a"), "S19a");
assert_eq!(clean_model("Antminer", "S19aPro"), "S19a Pro");
// asic-rs Unknown passthrough carrying the raw vendor string (a NoPIC
// S19 seen live at 10.4.x): drop the redundant brand, keep the rest.
assert_eq!(clean_model("Antminer", "ANTMINER S19 (88)"), "S19 (88)");
}
#[test]
fn whatsminer_model_and_submodel() {
assert_eq!(clean_model("Whatsminer", "M30SPlusVE40"), "M30S+");
assert_eq!(submodel("Whatsminer", "M30SPlusVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M30SPlusPlusVE40"), "M30S++");
assert_eq!(submodel("Whatsminer", "M30SPlusPlusVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M30SVE40"), "M30S");
assert_eq!(submodel("Whatsminer", "M30SVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M20S"), "M20S");
assert_eq!(submodel("Whatsminer", "M20S"), "");
assert_eq!(clean_model("Whatsminer", "M50S++VK30"), "M50S++");
assert_eq!(submodel("Whatsminer", "M50S++VK30"), "VK30");
}
#[test]
fn antminer_has_no_submodel() {
assert_eq!(submodel("Antminer", "S19KPro"), "");
}
#[test]
fn control_board_short_codes() {
// Antminer families (board name as asic-rs renders the enum variant).
assert_eq!(control_board_code("Antminer", "BeagleBoneBlack", "S19"), "BBB (C77)");
// Also accept the spaced form some layers produce.
assert_eq!(control_board_code("Antminer", "BeagleBone Black", "S19"), "BBB (C77)");
assert_eq!(control_board_code("Antminer", "CVITek", "S21 Pro"), "CVI (C88)");
assert_eq!(control_board_code("Antminer", "Xilinx", "S17 Pro"), "XIL (C49)");
assert_eq!(control_board_code("Antminer", "Xilinx", "T17"), "XIL (C49)");
assert_eq!(control_board_code("Antminer", "Xilinx", "S19 Pro"), "XIL (C55)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19j Pro"), "AML (C76)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19k Pro"), "AML (CBE)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19 XP"), "AML (CBE)");
// WhatsMiner families.
assert_eq!(control_board_code("Whatsminer", "H3", "M30S"), "H3 (CB2)");
assert_eq!(control_board_code("Whatsminer", "H6", "M50"), "H6 (CB4)");
assert_eq!(control_board_code("Whatsminer", "H6OS", "M50"), "H6os (CB4)");
assert_eq!(control_board_code("Whatsminer", "H616", "M30S+"), "H616 (CB6)");
// Unknown / blank pass through.
assert_eq!(control_board_code("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
assert_eq!(control_board_code("Antminer", "", "S19"), "");
}
#[test]
fn control_board_cpu_and_board_split() {
// CPU column vs board-code column.
assert_eq!(control_board_cpu("Antminer", "AMLogic", "S19j Pro"), "AML");
assert_eq!(control_board_board("Antminer", "AMLogic", "S19j Pro"), "C76");
assert_eq!(control_board_cpu("Antminer", "CVITek", "S21 Pro"), "CVI");
assert_eq!(control_board_board("Antminer", "CVITek", "S21 Pro"), "C88");
assert_eq!(control_board_cpu("Whatsminer", "H616", "M30S+"), "H616");
assert_eq!(control_board_board("Whatsminer", "H616", "M30S+"), "CB6");
// S21 Pro on an AMLogic board is the 140mm CBE, not C76.
assert_eq!(control_board_board("Antminer", "AMLogic", "S21 Pro"), "CBE");
assert_eq!(control_board_code("Antminer", "AMLogic", "S21 Pro"), "AML (CBE)");
// Unknown -> cpu holds the raw string, no board code.
assert_eq!(control_board_cpu("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
assert_eq!(control_board_board("Antminer", "Unknown: FOO", "S19"), "");
}
#[test]
fn firmware_family_splits_vendor_prefix() {
// Stock firmware: vendor word moves out of the family word (round 11 #6).
assert_eq!(firmware_family("AntMiner Stock"), ("Stock".to_string(), Some("AntMiner".to_string())));
assert_eq!(
firmware_family("WhatsMiner Stock"),
("Stock".to_string(), Some("WhatsMiner".to_string()))
);
// Aftermarket families pass through with no vendor prefix.
assert_eq!(firmware_family("VNish"), ("VNish".to_string(), None));
assert_eq!(firmware_family("Braiins"), ("Braiins".to_string(), None));
// A bare vendor word with nothing after it is left as-is (not emptied).
assert_eq!(firmware_family("AntMiner"), ("AntMiner".to_string(), None));
}
#[test]
fn liquid_cooling_detection() {
assert!(is_liquid_cooled("S21 XP Hydro"));
assert!(is_liquid_cooled("Antminer S19 Hydro"));
assert!(is_liquid_cooled("M53 immersion"));
assert!(!is_liquid_cooled("S21 Pro"));
assert!(!is_liquid_cooled("M30S++"));
}
}
+131
View File
@@ -0,0 +1,131 @@
//! Dropdown presets + user-saved values for the Configure-pools dialog (round 15
//! #1). Each pool field (address / account / worker / password) has a "+" menu
//! offering built-in presets (pool stratums, worker placeholders) plus values the
//! user has saved, and the user can add the current box value to the saved list.
//! Saved lists persist one-per-line under the config dir.
use std::path::PathBuf;
const CONFIG_DIR: &str = ".config/alkane-toolkit";
/// Which pool field a "+" menu belongs to.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PoolField {
Address,
Account,
Worker,
Password,
}
impl PoolField {
fn saved_file(self) -> &'static str {
match self {
PoolField::Address => "pool-addresses.txt",
PoolField::Account => "pool-accounts.txt",
PoolField::Worker => "pool-workers.txt",
PoolField::Password => "pool-passwords.txt",
}
}
/// Built-in presets offered before the user's saved values.
pub fn presets(self) -> Vec<&'static str> {
match self {
// Top Bitcoin pools by hashrate with their primary stratum endpoints
// (researched round 15; verify in-app before relying on any one).
PoolField::Address => POOL_STRATUMS.iter().map(|(_, u)| *u).collect(),
PoolField::Account => Vec::new(),
// Per-miner worker-name placeholders (see MinerRow::expand_worker_template).
PoolField::Worker => vec![
"{ip1}", "{ip2}", "{ip3}", "{ip4}", "{serial}", "{mac}", "{nameplate-hr}",
"{brand}", "{model}", "{submodel}", "{cpu}", "{cb}", "{firmware}", "{hostname}",
],
PoolField::Password => vec!["x"],
}
}
}
/// (pool name, primary stratum URL). Used for the address dropdown labels.
pub const POOL_STRATUMS: &[(&str, &str)] = &[
("Foundry USA", "stratum+tcp://btc.foundryusapool.com:3333"),
("AntPool", "stratum+tcp://ss.antpool.com:3333"),
("F2Pool", "stratum+tcp://btc.f2pool.com:1314"),
("ViaBTC", "stratum+tcp://btc.viabtc.io:3333"),
("SpiderPool", "stratum+tcp://btc-us.spiderpool.com:2309"),
("Binance Pool", "stratum+tcp://bs.poolbinance.com:3333"),
("Luxor", "stratum+tcp://btc.global.luxor.tech:700"),
("SBI Crypto", "stratum+tcp://us1.sbicrypto.com:3333"),
("Braiins Pool", "stratum+tcp://stratum.braiins.com:3333"),
("ULTIMUSPOOL", "stratum+tcp://bs.ultimuspool.com:8888"),
("SECPOOL", "stratum+tcp://btc.secpool.com:3333"),
];
fn config_path(file: &str) -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(CONFIG_DIR).join(file)
}
/// The user's saved values for `field`, in save order (most recent last).
pub fn load_saved(field: PoolField) -> Vec<String> {
std::fs::read_to_string(config_path(field.saved_file()))
.ok()
.map(|s| s.lines().map(str::trim).filter(|l| !l.is_empty()).map(String::from).collect())
.unwrap_or_default()
}
/// Add `value` to `field`'s saved list (deduplicated, no-op if empty/already
/// present or already a preset). Returns true if it was newly added.
pub fn add_saved(field: PoolField, value: &str) -> bool {
let value = value.trim();
if value.is_empty() {
return false;
}
if field.presets().iter().any(|p| *p == value) {
return false;
}
let mut saved = load_saved(field);
if saved.iter().any(|s| s == value) {
return false;
}
saved.push(value.to_string());
let p = config_path(field.saved_file());
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(p, saved.join("\n"));
true
}
/// Remove `value` from `field`'s saved list (round 16 #5). Returns true if it was
/// present and removed. Presets cannot be removed (they are not in the saved file).
pub fn remove_saved(field: PoolField, value: &str) -> bool {
let value = value.trim();
let mut saved = load_saved(field);
let before = saved.len();
saved.retain(|s| s != value);
if saved.len() == before {
return false;
}
let p = config_path(field.saved_file());
let _ = std::fs::write(p, saved.join("\n"));
true
}
/// The full dropdown list for a field: presets first, then the user's saved
/// values. For the address field each entry is labelled with the pool name.
pub fn dropdown_entries(field: PoolField) -> Vec<(String, String)> {
// (label, value)
let mut out: Vec<(String, String)> = Vec::new();
if field == PoolField::Address {
for (name, url) in POOL_STRATUMS {
out.push((format!("{name} -- {url}"), url.to_string()));
}
} else {
for p in field.presets() {
out.push((p.to_string(), p.to_string()));
}
}
for s in load_saved(field) {
out.push((s.clone(), s));
}
out
}
+156
View File
@@ -0,0 +1,156 @@
//! Saved view presets: named snapshots of the table's column arrangement,
//! visibility, sort, and filters. Persisted as JSON in the config dir. The
//! first preset is always a built-in "Default" profile.
use std::collections::{HashMap, HashSet};
use serde::{Deserialize, Serialize};
use crate::model::{ColFilter, Column, ViewState, ALL_COLUMNS};
use crate::scan::config_path;
pub const PRESETS_FILE: &str = "presets.json";
/// The built-in default profile's visible columns, in display order (Ip first):
/// IP, model, health (component icons), hashrate, power, chip temp, firmware,
/// CPU, access. The Health column (round 13 #3) replaced the old errors, boards
/// (hashboard dots) and status columns.
const DEFAULT_PROFILE: [Column; 10] = [
Column::Ip,
Column::Model,
Column::Health,
Column::Hashrate,
Column::Power,
Column::ChipTemp,
Column::Firmware,
Column::Cpu,
Column::Locked,
Column::Light,
];
/// A serializable snapshot of a `ViewState` (Vec-based so JSON has no map keys
/// that are enums, and column order within `visible` is preserved).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresetView {
pub order: Vec<Column>,
pub visible: Vec<Column>,
pub sort: Option<(Column, bool)>,
pub filters: Vec<(Column, ColFilter)>,
}
impl PresetView {
pub fn from_view(v: &ViewState) -> PresetView {
PresetView {
order: v.order.clone(),
// keep the visible columns in display order for stability
visible: v.order.iter().copied().filter(|c| v.visible.contains(c)).collect(),
sort: v.sort,
filters: v.filters.iter().map(|(k, f)| (*k, f.clone())).collect(),
}
}
/// Rebuild a `ViewState` from this snapshot. Any column missing from a
/// loaded (possibly older) preset is appended to `order` and left hidden, so
/// the result always covers every `Column`.
pub fn to_view(&self) -> ViewState {
let mut order = self.order.clone();
for c in ALL_COLUMNS {
if !order.contains(&c) {
order.push(c);
}
}
let mut visible: HashSet<Column> = self.visible.iter().copied().collect();
visible.insert(Column::Ip); // IP is always shown
let filters: HashMap<Column, ColFilter> = self.filters.iter().cloned().collect();
ViewState { order, visible, sort: self.sort, filters }
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Preset {
pub name: String,
pub view: PresetView,
}
/// The built-in default profile (always present as the first preset).
pub fn default_preset() -> Preset {
let mut order: Vec<Column> = DEFAULT_PROFILE.to_vec();
for c in ALL_COLUMNS {
if !order.contains(&c) {
order.push(c);
}
}
Preset {
name: "Default".to_string(),
view: PresetView {
order,
visible: DEFAULT_PROFILE.to_vec(),
sort: None,
filters: Vec::new(),
},
}
}
/// Load saved presets, always with the built-in "Default" first. A missing or
/// unreadable file yields just the default.
pub fn load_presets() -> Vec<Preset> {
let mut presets = std::fs::read_to_string(config_path(PRESETS_FILE))
.ok()
.and_then(|s| serde_json::from_str::<Vec<Preset>>(&s).ok())
.unwrap_or_default();
// The default profile is always present and always first.
presets.retain(|p| p.name != "Default");
presets.insert(0, default_preset());
presets
}
/// Persist presets (the built-in "Default" is not written; it is re-seeded on
/// load). Best-effort: errors are returned for the caller to surface.
pub fn save_presets(presets: &[Preset]) -> std::io::Result<()> {
let p = config_path(PRESETS_FILE);
if let Some(dir) = p.parent() {
std::fs::create_dir_all(dir)?;
}
let user: Vec<&Preset> = presets.iter().filter(|p| p.name != "Default").collect();
let json = serde_json::to_string_pretty(&user)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
std::fs::write(p, json)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_preset_round_trips_through_view() {
let p = default_preset();
let view = p.view.to_view();
// IP first + the requested default columns visible.
assert!(view.visible.contains(&Column::Ip));
assert!(view.visible.contains(&Column::Model));
assert!(view.visible.contains(&Column::Health));
assert!(view.visible.contains(&Column::Cpu));
assert!(view.visible.contains(&Column::Locked));
// The Health column (round 13 #3) replaced these in the default profile.
assert!(!view.visible.contains(&Column::Error));
assert!(!view.visible.contains(&Column::Hashboards));
// Columns dropped from the default profile in round 11.
assert!(!view.visible.contains(&Column::BoardCode), "not in the default profile");
assert!(!view.visible.contains(&Column::Cooling), "not in the default profile");
// to_view covers every column in `order`.
assert_eq!(view.order.len(), ALL_COLUMNS.len());
// Round-trip a snapshot back out.
let snap = PresetView::from_view(&view);
assert_eq!(snap.visible.first(), Some(&Column::Ip));
}
#[test]
fn preset_json_round_trip() {
let p = default_preset();
let json = serde_json::to_string(&vec![&p]).unwrap();
let back: Vec<Preset> = serde_json::from_str(&json).unwrap();
assert_eq!(back.len(), 1);
assert_eq!(back[0].name, "Default");
assert_eq!(back[0].view.visible, DEFAULT_PROFILE.to_vec());
}
}
+282
View File
@@ -0,0 +1,282 @@
//! Restore an aftermarket-firmware miner to stock (round 12 #8a).
//!
//! All three supported aftermarket firmwares ship a free, self-restoring revert
//! (the stock image is retained on-device at install time; no image is uploaded):
//! - VNish: POST /api/v1/unlock -> bearer -> POST /api/v1/firmware/remove
//! - LuxOS: luxminer :4028 {"command":"logon"} -> SessionID ->
//! {"command":"uninstallluxos","parameter":"<SessionID>"}
//! - Braiins: SSH `uninstall.sh` (re-flashes the on-NAND stock backup)
//!
//! DESTRUCTIVE: this removes the running aftermarket firmware and reboots the
//! miner to stock. It is gated behind a typed confirmation in the UI and runs on
//! a background thread so the reboot latency never blocks the event loop. The
//! flows are documented + live-confirmed in the miner-firmware wiki
//! (40-boot-os-and-build/firmware-install-remove-api and siblings).
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::process::Command;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{Receiver, channel};
use std::time::Duration;
use crate::scan::fake_scan_enabled;
pub enum RestoreMsg {
Started { total: usize },
Result { ip: String, ok: bool, detail: String },
Done { total: usize },
}
pub struct RestoreHandle {
pub rx: Receiver<RestoreMsg>,
cancel: Arc<AtomicBool>,
}
impl RestoreHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
/// One miner to restore: its IP plus the firmware family ("VNish"/"LuxOS"/
/// "Braiins") that selects the revert flow.
pub struct RestoreTarget {
pub ip: String,
pub firmware: String,
}
/// Start restoring the given miners to stock on a background thread. `vnish_pass`
/// is the VNish web password; `ssh_user`/`ssh_pass` drive the Braiins SSH revert.
pub fn start_restore(
targets: Vec<RestoreTarget>,
vnish_pass: String,
ssh_user: String,
ssh_pass: String,
) -> RestoreHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = targets.len();
if fake_scan_enabled() {
// Offline demo: report each target as restored without touching anything.
let _ = tx.send(RestoreMsg::Started { total });
for t in targets {
let _ = tx.send(RestoreMsg::Result {
ip: t.ip,
ok: true,
detail: "restored to stock (demo)".into(),
});
}
let _ = tx.send(RestoreMsg::Done { total });
return RestoreHandle { rx, cancel };
}
let tc = cancel.clone();
let _ = std::thread::Builder::new()
.name("restore-stock".into())
.spawn(move || {
let _ = tx.send(RestoreMsg::Started { total });
for t in targets {
if tc.load(Ordering::Relaxed) {
break;
}
let (ok, detail) = restore_one(&t, &vnish_pass, &ssh_user, &ssh_pass);
if tx.send(RestoreMsg::Result { ip: t.ip, ok, detail }).is_err() {
return;
}
}
let _ = tx.send(RestoreMsg::Done { total });
});
RestoreHandle { rx, cancel }
}
fn restore_one(t: &RestoreTarget, vnish_pass: &str, ssh_user: &str, ssh_pass: &str) -> (bool, String) {
let fw = t.firmware.to_ascii_lowercase();
if fw.contains("vnish") || fw.contains("wildrose") || fw.contains("anthill") {
restore_vnish(&t.ip, vnish_pass)
} else if fw.contains("lux") {
restore_luxos(&t.ip)
} else if fw.contains("braiins") || fw.contains("bos") {
restore_braiins(&t.ip, ssh_user, ssh_pass)
} else {
(false, format!("no restore-to-stock path for firmware '{}'", t.firmware))
}
}
/// VNish: unlock -> bearer -> firmware/remove (self-restores + reboots ~3 s).
fn restore_vnish(ip: &str, pass: &str) -> (bool, String) {
let unlock = match curl(&[
"-s", "--connect-timeout", "5", "--max-time", "9",
"-X", "POST", "-H", "Content-Type: application/json",
"-d", &format!("{{\"pw\":\"{pass}\"}}"),
&format!("http://{ip}/api/v1/unlock"),
]) {
Ok(s) => s,
Err(e) => return (false, format!("unlock request failed: {e}")),
};
let token = serde_json::from_str::<serde_json::Value>(&unlock)
.ok()
.and_then(|v| v.get("token").and_then(|t| t.as_str()).map(str::to_string))
.filter(|t| !t.is_empty());
let Some(token) = token else {
return (false, "VNish unlock rejected (wrong web password?)".into());
};
match curl(&[
"-s", "--connect-timeout", "5", "--max-time", "12",
"-X", "POST", "-H", &format!("Authorization: Bearer {token}"),
&format!("http://{ip}/api/v1/firmware/remove"),
]) {
// The miner reverts + reboots after ~3 s; the response is {"after":N}.
Ok(resp) if resp.contains("after") => (true, "reverting to stock (~3 s)".into()),
Ok(resp) => (false, format!("firmware/remove returned: {}", resp.trim())),
Err(e) => (false, format!("firmware/remove failed: {e}")),
}
}
/// LuxOS: credential-free luxminer session, then uninstallluxos (reboots to stock).
fn restore_luxos(ip: &str) -> (bool, String) {
let logon = match lux_rpc(ip, "{\"command\":\"logon\"}") {
Ok(s) => s,
Err(e) => return (false, format!("logon failed: {e}")),
};
let session = serde_json::from_str::<serde_json::Value>(&logon)
.ok()
.and_then(|v| {
v.pointer("/SESSION/0/SessionID")
.or_else(|| v.pointer("/Session/0/SessionID"))
.and_then(|s| s.as_str())
.map(str::to_string)
});
let Some(session) = session.filter(|s| !s.is_empty()) else {
return (false, format!("no SessionID in logon response: {}", logon.trim()));
};
let cmd = format!("{{\"command\":\"uninstallluxos\",\"parameter\":\"{session}\"}}");
match lux_rpc(ip, &cmd) {
// Code 350 "Uninstalling LuxOS"; the miner reboots + reverts in background.
Ok(resp) if resp.contains("350") || resp.to_lowercase().contains("uninstall") => {
(true, "uninstalling LuxOS (reboots to stock)".into())
}
Ok(resp) => (false, format!("uninstallluxos returned: {}", resp.trim())),
Err(e) => (false, format!("uninstallluxos failed: {e}")),
}
}
/// Braiins: SSH `uninstall.sh` (re-flashes the retained on-NAND stock backup).
fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
if pass.is_empty() {
return (false, "Braiins restore needs an SSH password (set the SSH login)".into());
}
let target = format!("{user}@{ip}");
// uninstall.sh is on Braiins OS+'s PATH; run it non-interactively.
let mut cmd = Command::new("sshpass");
cmd.arg("-p").arg(pass).arg("ssh");
cmd.args([
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "ConnectTimeout=8",
&target,
"uninstall.sh || /sbin/uninstall.sh",
]);
match run_with_timeout(cmd, Duration::from_secs(60)) {
Ok(out) => {
let s = String::from_utf8_lossy(&out).to_lowercase();
if s.contains("not found") || s.contains("no such") {
(false, "uninstall.sh not found on the miner".into())
} else {
(true, "ran uninstall.sh (reverts to stock + reboots)".into())
}
}
Err(e) => {
// A reboot mid-command commonly drops the SSH connection; treat a
// connection-closed error after the command as likely success.
if e.contains("closed") || e.contains("reset") || e.contains("timed out") {
(true, "SSH dropped (miner likely rebooting to stock)".into())
} else {
(false, format!("SSH uninstall failed: {e}"))
}
}
}
}
/// One luxminer :4028 request/response (line-framed, socket closes after reply).
fn lux_rpc(ip: &str, payload: &str) -> Result<String, String> {
let addr: SocketAddr = format!("{ip}:4028").parse().map_err(|e| format!("bad addr: {e}"))?;
let t = Duration::from_secs(8);
let mut s = TcpStream::connect_timeout(&addr, t).map_err(|e| e.to_string())?;
s.set_read_timeout(Some(t)).ok();
s.set_write_timeout(Some(t)).ok();
s.write_all(payload.as_bytes()).map_err(|e| e.to_string())?;
let mut buf = Vec::new();
let mut chunk = [0u8; 4096];
loop {
match s.read(&mut chunk) {
Ok(0) => break,
Ok(n) => {
buf.extend_from_slice(&chunk[..n]);
if buf.len() > 1 << 16 {
break;
}
}
Err(_) => break,
}
}
Ok(String::from_utf8_lossy(&buf).trim_matches('\u{0}').to_string())
}
/// curl with a wall-clock cap (small responses; no pipe-drain thread needed).
fn curl(args: &[&str]) -> Result<String, String> {
let mut cmd = Command::new("curl");
cmd.args(args);
run_with_timeout(cmd, Duration::from_secs(15)).map(|o| String::from_utf8_lossy(&o).into_owned())
}
/// Run a command, capture stdout, with a hard wall-clock timeout.
fn run_with_timeout(mut cmd: Command, timeout: Duration) -> Result<Vec<u8>, String> {
cmd.stdout(std::process::Stdio::piped());
cmd.stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().map_err(|e| format!("spawn: {e}"))?;
let mut stdout = child.stdout.take().ok_or("no stdout")?;
let reader = std::thread::spawn(move || {
let mut b = Vec::new();
let _ = stdout.read_to_end(&mut b);
b
});
let start = std::time::Instant::now();
let mut timed_out = false;
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(_) => break,
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
timed_out = true;
break;
}
std::thread::sleep(Duration::from_millis(50));
}
}
}
let out = reader.join().unwrap_or_default();
if timed_out && out.is_empty() {
return Err("timed out".into());
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn firmware_selects_the_right_flow() {
// The dispatcher only recognises the three revertible aftermarket
// families; anything else has no restore path.
let mk = |fw: &str| RestoreTarget { ip: "0.0.0.0".into(), firmware: fw.into() };
// Unknown firmware is rejected cleanly (no network attempt in the branch).
let (ok, detail) = restore_one(&mk("Stock"), "", "", "");
assert!(!ok);
assert!(detail.contains("no restore-to-stock path"), "{detail}");
}
}
File diff suppressed because it is too large Load Diff
+3401 -171
View File
File diff suppressed because it is too large Load Diff
+9 -1
View File
@@ -20,7 +20,15 @@ vendor/ cargo-managed crate sources ONLY (regenerated by
`cargo vendor vendor`; it deletes unmanaged dirs - never
put hand-made trees here; learned the hard way)
thirdparty/
asic-rs lives in vendor/ (pure crates.io dep, cargo-vendored)
asic-rs the vendored crates live in vendor/ (crates.io dep,
VERSION cargo-vendored); this dir holds their patch queue:
patches/ 0001 whatsminer set_power_limit error propagation (#4)
refresh-checksums.py rewrites a vendored crate's .cargo-checksum.json
after a patch (cargo verifies each file's SHA256)
The committed vendor/ tree has the patches applied and the
affected .cargo-checksum.json refreshed, so builds need
nothing extra. On re-vendor, run
scripts/apply-asic-rs-patches.sh to re-apply + refresh.
wxwidgets/
wxWidgets-3.3.3/ pristine release tree, never edited directly
VERSION upstream version + tarball URL + sha256
+33
View File
@@ -0,0 +1,33 @@
#!/bin/bash
# Re-apply the asic-rs patch queue to the cargo-vendored tree and refresh the
# affected crates' .cargo-checksum.json. Run this after `cargo vendor vendor`
# (which regenerates a pristine vendor/ and drops our edits). A normal build
# does NOT need this -- the committed vendor/ tree already has the patches
# applied and checksums refreshed; this is the re-vendoring recipe (ADR 0003).
set -euo pipefail
REPO=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
cd "$REPO"
PATCHES_DIR="thirdparty/asic-rs/patches"
shopt -s nullglob
patches=("$PATCHES_DIR"/*.patch)
if [ ${#patches[@]} -eq 0 ]; then
echo "no patches in $PATCHES_DIR"
exit 0
fi
for p in "${patches[@]}"; do
echo "== applying $p =="
if git apply --check -p1 "$p" 2>/dev/null; then
git apply -p1 "$p"
elif git apply --check -p1 --reverse "$p" 2>/dev/null; then
echo " (already applied -- skipping)"
else
echo "ERROR: $p does not apply cleanly; resolve manually." >&2
exit 1
fi
done
echo "== refreshing checksums for all vendored asic-rs crates =="
python3 thirdparty/asic-rs/refresh-checksums.py --all
echo "done."
+37
View File
@@ -0,0 +1,37 @@
upstream: asic-rs (crates.io)
version: 0.8.1 (cargo-vendored under vendor/, per ADR 0003)
state: pristine cargo-vendored tree + this patch queue.
asic-rs is materialized with `cargo vendor vendor` and consumed through
.cargo/config.toml's vendored-sources replacement (directory = "vendor").
Unlike wx-rs, asic-rs is many crates (asic-rs, asic-rs-core, and the
per-make / per-firmware crates); a change to any of them lives here as a
numbered .patch, NOT as an in-place edit of the pristine tree (ADR 0003).
The committed vendor/ tree already has the patches applied AND its affected
crates' .cargo-checksum.json refreshed, so a normal build needs nothing extra
-- the patch queue is provenance + the re-vendoring recipe.
GOTCHA (cargo caching): cargo fingerprints a registry/vendored crate by
(name, version, source), NOT by file content, so it will REUSE a cached
build of a vendored crate even after its source is edited. CI is unaffected
(fresh target/ each run compiles the patched source). But an incremental
LOCAL build that already compiled the unpatched crate must be forced:
cargo clean -p asic-rs-firmwares-whatsminer # then rebuild
Otherwise the local binary silently keeps the old behaviour.
Update / re-vendor flow:
1. bump the pin in crates/alkane-gui/Cargo.toml, `cargo vendor vendor`
(this regenerates a pristine vendor/ and DROPS our edits)
2. scripts/apply-asic-rs-patches.sh # re-applies patches/ + refreshes checksums
3. resolve any patch that no longer applies, rebuild, commit
patches/:
0001 whatsminer set_power_limit (round-9 #4): fix the v3 (WhatsMinerOS)
privileged auth -- the "super" account's token password is the separate
v3 credential (default "super"), not the web/admin password -- and send
the watts as a bare integer; also treat the apply-restart's transient
RPC error as success. See the patch header.
0002 antminer Equihash (Z15/Z15J) hashrate (round-10 #8): the cgminer "GHS"
key carries a Sol/s value, so use the base Hash unit for Equihash so the
SI prefix is correct ("288k", not "288T"). See the patch header.
@@ -0,0 +1,104 @@
Subject: [PATCH 0001] whatsminer set_power_limit: v3 auth/param fix + restart-tolerant result
Round-9 #4 -- "the power-limit on the WhatsMiners doesn't apply properly" --
root-caused and verified against the live fleet.
v3 backend (WhatsMinerOS, firmware >= 2024-11-01, port 4433): the privileged
power-limit write authenticated the "super" account with the WEB/admin password
(a separate credential; the super account's factory default is "super") and sent
the watts as a float, so the miner rejected every write with "invalid json or
password is wrong". Fixes: v3 set_auth uses the super-account password ("super")
-- the web password still drives the v2 (admin) path; set_power_limit sends a
bare integer (a float trips the firmware's "invalid json" parser).
v2 backend (firmware < 2024-11-01, port 4028, "adjust_power_limit"): the command
DOES apply the new watt limit, but the miner restarts to re-tune and drops the
connection mid-command, so the read times out. Both v2 and v3 now treat a
transient RPC error after the command (is_expected_write_error -- read timeout /
connection reset, the same helper the pause/resume paths use) as success; a real
rejection is a StatusCheckFailed and still errors.
Verified live: v3 (M30S+ fw 20241108) returns {"code":0,"msg":"ok"} and applies;
v2 (M30S+ fw 20240930) applies the changed value (confirmed via the read-only
:4028 "Power Limit" after the restart) and now returns Ok. All test miners were
returned to their prior configured limit. Matches the pyasic / HashSource
whatsminer-api-3 references.
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
index c7b00e3b..096b2fcb 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
@@ -637,11 +637,21 @@ impl SetFaultLight for WhatsMinerV2 {
impl SetPowerLimit for WhatsMinerV2 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
- let data = self
+ match self
.rpc
.send_command("adjust_power_limit", true, parameters)
- .await;
- Ok(data.is_ok())
+ .await
+ {
+ Ok(_) => Ok(true),
+ // adjust_power_limit makes the miner restart to re-tune, so it drops
+ // the connection / stops replying mid-command even though it accepted
+ // and applied the new limit (verified on the live fleet: the set value
+ // settles after the restart). A transient RPC error (read timeout /
+ // connection reset) after the command is therefore success; a genuine
+ // rejection surfaces as StatusCheckFailed and still errors.
+ Err(e) if is_expected_write_error(&e) => Ok(true),
+ Err(e) => Err(e),
+ }
}
fn supports_set_power_limit(&self) -> bool {
true
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
index 77d724d5..c00c6d44 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
@@ -669,12 +669,21 @@ impl SetFaultLight for WhatsMinerV3 {
#[async_trait]
impl SetPowerLimit for WhatsMinerV3 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
- let data = self
+ // WhatsMinerOS wants a BARE INTEGER watt value; a float ("3000.0")
+ // trips the firmware's "invalid json" parser (round-9 #4).
+ let watts = limit.as_watts().round() as u64;
+ match self
.rpc
- .send_command("set.miner.power_limit", true, Some(json!(limit.as_watts())))
- .await;
-
- Ok(data.is_ok())
+ .send_command("set.miner.power_limit", true, Some(json!(watts)))
+ .await
+ {
+ Ok(_) => Ok(true),
+ // A power-limit change restarts the miner to re-tune, so a transient
+ // RPC error after the command means it was accepted (as with v2), not
+ // rejected; a genuine rejection is a StatusCheckFailed and still errors.
+ Err(e) if is_expected_write_error(&e) => Ok(true),
+ Err(e) => Err(e),
+ }
}
fn supports_set_power_limit(&self) -> bool {
true
@@ -806,8 +815,15 @@ impl HasDefaultAuth for WhatsMinerV3 {
impl HasAuth for WhatsMinerV3 {
fn set_auth(&mut self, auth: MinerAuth) {
- // WhatsMiner V3 username is always "super", V2 is always "admin"
- self.rpc.set_auth(MinerAuth::new("super", auth.password()));
+ // WhatsMiner V3 username is always "super", V2 is always "admin".
+ // The V3 privileged token authenticates against the "super" ACCOUNT,
+ // whose password is a separate v3 credential (factory default "super")
+ // -- NOT the web/admin password carried by `auth`. Pairing account
+ // "super" with the web password made every v3 privileged write fail with
+ // "invalid json or password is wrong" (round-9 #4, confirmed on the live
+ // fleet). Keep the super-account default password here; the web password
+ // still drives the v2 (admin) path below.
+ self.rpc.set_auth(MinerAuth::new("super", "super"));
self.v2_rpc
.set_auth(MinerAuth::new("admin", auth.password()));
}
@@ -0,0 +1,69 @@
Subject: [PATCH 0002] antminer: Equihash (Z15/Z15J) hashrate uses base Sol/s unit
Round-10 #8 -- a Z15 shows its hashrate in 'T' (e.g. "288T") when it should be
'k' (~288 kSol/s). Root cause verified on the live fleet: Equihash miners report
a Sol/s rate in the cgminer "GHS" key, but AntMiner's parse_hashrate takes the
unit from the key name ("GHS" -> GigaHash), scaling the value 1e9x too large.
The value is a raw Sol/s count, so for Equihash use the base Hash unit; the
downstream SI-prefixing then yields "288k". Matched by algorithm, and by "Z15"
model name for the Z15J which asic-rs leaves algo Unknown. Applies to both the
v2020 and v2023_07 backends. Verified: Z15 288T -> 288k, Z15J 138T -> 110k.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index cd4f7cbd..5b9f77b3 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -14,7 +14,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
- device::DeviceInfo,
+ device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -722,6 +722,15 @@ impl GetHashrate for AntMinerV2020 {
})
})?;
+ // Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
+ // "GHS" key, so the key's GigaHash label is wrong -- the value is the
+ // raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
+ // is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
+ // and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
+ || self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
+ let unit = if is_equihash { HashRateUnit::Hash } else { unit };
+
Some(
HashRate {
value,
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
index 4ba13537..6d6dc593 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
@@ -16,7 +16,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
- device::DeviceInfo,
+ device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -698,6 +698,15 @@ impl GetHashrate for AntMinerV202307 {
})
})?;
+ // Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
+ // "GHS" key, so the key's GigaHash label is wrong -- the value is the
+ // raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
+ // is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
+ // and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
+ || self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
+ let unit = if is_equihash { HashRateUnit::Hash } else { unit };
+
Some(
HashRate {
value,
@@ -0,0 +1,29 @@
Subject: [PATCH 0003] antminer: recognise VNish short control-board platforms (CV, XIL)
Round-11 #5 -- VNish reports the control board in short form via /api/v1/info
"platform": "cv" (CVITek), "xil" (Xilinx), "aml" (AMLogic). asic-rs's
AntMinerControlBoard::parse matched the full names (CVITEK, XILINX) but not the
short "CV"/"XIL", so VNish CVITek and Xilinx boards showed a blank control board
(the "can't scan XIL or CVITek boards" bug). Add the short forms. Verified live:
S19k Pro platform "cv" -> CVITek, S19 platform "xil" -> Xilinx.
diff --git a/vendor/asic-rs-makes-antminer/src/hardware.rs b/vendor/asic-rs-makes-antminer/src/hardware.rs
index 41a73240..aa0923c8 100644
--- a/vendor/asic-rs-makes-antminer/src/hardware.rs
+++ b/vendor/asic-rs-makes-antminer/src/hardware.rs
@@ -268,11 +268,13 @@ impl AntMinerControlBoard {
.collect::<String>();
match compact.as_str() {
- "XILINX" => Some(Self::Xilinx),
+ // "XIL" is VNish's short platform form for a Xilinx control board.
+ "XILINX" | "XIL" => Some(Self::Xilinx),
"BBB" | "BBCTRL" | "BB" | "BEAGLEBONE" | "BEAGLEBONEBLACK" => {
Some(Self::BeagleBoneBlack)
}
- "CVITEK" | "CVCTRL" => Some(Self::CVITek),
+ // "CV" is VNish's short platform form for a CVITek control board.
+ "CVITEK" | "CVCTRL" | "CV" => Some(Self::CVITek),
"AMLOGIC" | "AML" => Some(Self::AMLogic),
"AMCB07" => Some(Self::Xilinx), // Mara FW
"ZYNQ7007" => Some(Self::Xilinx),
@@ -0,0 +1,65 @@
Subject: [PATCH 0004] whatsminer v1: control-board fallback + optional ALLWINNER_ prefix
Round-11 #5 -- older M30S firmware (< 2022.7.29, the v1 backend) often omits
"CB Platform" from the summary RPC, and its parse mandatorily stripped an
"ALLWINNER_" prefix (strip_prefix(..)? -> None when absent), so those units
showed a blank control board. Add get_version /Msg/platform (the source v2 uses)
as a fallback location, and make the ALLWINNER_ strip optional. Verified live:
M30S+ VE40 (fw 20220422, v1) blank -> H6OS.
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
index b4a27db8..f95a22ae 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -131,14 +131,28 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
- DataField::ControlBoardVersion => vec![(
- RPC_SUMMARY,
- DataExtractor {
- func: get_by_pointer,
- key: Some("/SUMMARY/0/CB Platform"),
- tag: None,
- },
- )],
+ DataField::ControlBoardVersion => vec![
+ (
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/CB Platform"),
+ tag: None,
+ },
+ ),
+ // Older M30S firmware (< 2022.7.29, so this v1 backend) often omits
+ // "CB Platform" from summary but still reports the board under
+ // get_version /Msg/platform (the source v2 uses). Fall back to it so
+ // those units don't show a blank control board.
+ (
+ RPC_GET_VERSION,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Msg/platform"),
+ tag: None,
+ },
+ ),
+ ],
DataField::TuningTarget => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -285,8 +299,12 @@ impl GetControlBoardVersion for WhatsMinerV1 {
) -> Option<MinerControlBoard> {
data.extract::<String>(DataField::ControlBoardVersion)
.and_then(|s| {
- WhatsMinerControlBoard::parse(s.to_uppercase().strip_prefix("ALLWINNER_")?)
- .map(|cb| cb.into())
+ // The "ALLWINNER_" prefix is optional: summary's CB Platform carries
+ // it (e.g. "ALLWINNER_H6"), but the get_version /Msg/platform fallback
+ // does not (e.g. "H6OS"). Strip it only when present.
+ let up = s.to_uppercase();
+ let board = up.strip_prefix("ALLWINNER_").unwrap_or(&up);
+ WhatsMinerControlBoard::parse(board).map(|cb| cb.into())
})
}
}
@@ -0,0 +1,93 @@
Subject: [PATCH 0005] vnish: surface the partner build name in the firmware version
Round-11 #6b/#11 -- VNish /api/v1/info carries a partner/reseller "build_name"
("WildRose", "vnishreturn", ...) alongside "fw_version"; it is shown in the
Hashcore toolkit but asic-rs did not expose it. Point the FirmwareVersion
extractor at /build_name and combine it with the /fw_version number (still on
ApiVersion) in parse_firmware_version, so firmware_version reads "<build>
<version>", e.g. "WildRose 1.2.7". Applies to both the v1_2_0 and v1_3_0
backends. Verified live: S19j Pro -> "WildRose 1.2.7", S19k Pro -> "vnishreturn 1.3.5".
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
index 4cc1434a..e734a03e 100644
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
@@ -179,11 +179,15 @@ impl GetDataLocations for VnishV120 {
tag: None,
},
)],
+ // The partner/reseller build name ("WildRose", "vnishreturn", ...) --
+ // combined with the version number in parse_firmware_version so the FW
+ // Version column shows e.g. "WildRose 1.3.5". ApiVersion still carries
+ // the bare /fw_version.
DataField::FirmwareVersion => vec![(
WEB_INFO,
DataExtractor {
func: get_by_pointer,
- key: Some("/fw_version"),
+ key: Some("/build_name"),
tag: None,
},
)],
@@ -415,7 +419,20 @@ impl GetApiVersion for VnishV120 {
impl GetFirmwareVersion for VnishV120 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
- data.extract::<String>(DataField::FirmwareVersion)
+ // FirmwareVersion carries /build_name (the partner build), ApiVersion the
+ // /fw_version number; show "<build> <version>" when both are present, else
+ // whichever is available.
+ let build = data
+ .extract::<String>(DataField::FirmwareVersion)
+ .filter(|b| !b.is_empty());
+ let version = data
+ .extract::<String>(DataField::ApiVersion)
+ .filter(|v| !v.is_empty());
+ match (build, version) {
+ (Some(b), Some(v)) => Some(format!("{b} {v}")),
+ (Some(b), None) => Some(b),
+ (None, v) => v,
+ }
}
}
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
index 6975d9e5..0a5d694e 100644
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
@@ -179,11 +179,13 @@ impl GetDataLocations for VnishV130 {
tag: None,
},
)],
+ // Partner/reseller build name; combined with the version number in
+ // parse_firmware_version (FW Version shows e.g. "WildRose 1.3.5").
DataField::FirmwareVersion => vec![(
WEB_INFO,
DataExtractor {
func: get_by_pointer,
- key: Some("/fw_version"),
+ key: Some("/build_name"),
tag: None,
},
)],
@@ -423,7 +425,19 @@ impl GetApiVersion for VnishV130 {
impl GetFirmwareVersion for VnishV130 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
- data.extract::<String>(DataField::FirmwareVersion)
+ // FirmwareVersion carries /build_name (partner build), ApiVersion the
+ // /fw_version number; show "<build> <version>" when both are present.
+ let build = data
+ .extract::<String>(DataField::FirmwareVersion)
+ .filter(|b| !b.is_empty());
+ let version = data
+ .extract::<String>(DataField::ApiVersion)
+ .filter(|v| !v.is_empty());
+ match (build, version) {
+ (Some(b), Some(v)) => Some(format!("{b} {v}")),
+ (Some(b), None) => Some(b),
+ (None, v) => v,
+ }
}
}
@@ -0,0 +1,243 @@
Subject: [PATCH 0006] antminer: route old models to the right backend + read the Z15 control board
Round-12 #10. Three fixes for stock Antminer Z15/Z15J (fw 2020), all verified
live on 10.5.1.x:
1. Backend routing: the version detector only read summary.cgi, which older
models (Z15) do not serve (404) -> version None -> AntMiner::new defaulted to
the newest backend, which mis-parsed the miner (empty control board, no
expected hashrate/wattage/fans). Fall back to the cgminer :4028 `version`
RPC's CompileTime so the Z15 (2020) routes to the v2020 backend.
2. Control board "read, not guess": the Z15 has no miner_type.cgi, so its
control-board subtype is unreadable there. Read the kernel build string from
get_system_info.cgi instead ("Linux 4.6.0-xilinx-..." -> Xilinx); the
ControlBoardVersion field now carries both the subtype and the kernel, and the
parser prefers the subtype and falls back to the kernel marker.
3. Malformed cgminer stats: the Z15 emits a stats array whose objects are not
comma-separated (`...}{"STATS":0...`), invalid JSON that serde rejected,
dropping the whole stats command and every stats-derived field. Insert the
missing separators before parsing (a no-op on well-formed responses); this
restores expected hashrate, fans, hashboards and uptime. The expected
hashrate also gets the same Equihash Sol/s reinterpretation as the realtime
rate, so both read on one scale (e.g. 144k / 320k) instead of the expected
reading ~1e6x larger.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index 5b9f77b3..a02bdf9d 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -434,14 +434,29 @@ impl GetDataLocations for AntMinerV2020 {
tag: None,
},
)],
- DataField::ControlBoardVersion => vec![(
- WEB_MINER_TYPE,
- DataExtractor {
- func: get_by_pointer,
- key: Some("/subtype"),
- tag: None,
- },
- )],
+ // Prefer the explicit control-board subtype from miner_type.cgi, but
+ // carry the kernel build string from get_system_info.cgi too: older
+ // models (e.g. Z15/Z15J) have no miner_type.cgi, and their kernel
+ // string ("...-xilinx-...") names the control board we can actually
+ // read instead of guessing from the model (round 12 #10).
+ DataField::ControlBoardVersion => vec![
+ (
+ WEB_MINER_TYPE,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/subtype"),
+ tag: Some("subtype"),
+ },
+ ),
+ (
+ WEB_SYSTEM_INFO,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/system_kernel_version"),
+ tag: Some("kernel"),
+ },
+ ),
+ ],
// cgminer names its summary keys after the unit they are in —
// `GHS 5s` on SHA-256 models, `MHS 5s` on Scrypt ones — so keep
// the whole entry and let the parse pick the key that is present.
@@ -748,16 +763,33 @@ impl GetExpectedHashrate for AntMinerV2020 {
let value = field?
.pointer("/hashrate")
.and_then(Self::parse_f64_field)?;
+ // Equihash miners (Z15/Z15J) report `total_rateideal` as a Sol/s count in
+ // the same (mislabelled) scale as the realtime "GHS" rate, so reinterpret
+ // it as the base Hash unit -- matching parse_hashrate. Without this,
+ // expected reads ~1e6x larger than realtime and the realtime figure looks
+ // absent next to it (round 12 #10).
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
+ || self
+ .device_info
+ .model
+ .to_string()
+ .to_ascii_uppercase()
+ .contains("Z15");
+ let unit = if is_equihash {
+ HashRateUnit::Hash
+ } else {
+ // `total_rateideal` does not name its own scale, so take it from
+ // STATS' `rate_unit` (`"GH"` / `"MH"`).
+ field
+ .and_then(|v| v.pointer("/unit"))
+ .and_then(|v| v.as_str())
+ .and_then(|s| HashRateUnit::from_str(s).ok())
+ .unwrap_or(HashRateUnit::GigaHash)
+ };
Some(
HashRate {
value,
- // `total_rateideal` does not name its own scale, so take it
- // from STATS' `rate_unit` (`"GH"` / `"MH"`).
- unit: field
- .and_then(|v| v.pointer("/unit"))
- .and_then(|v| v.as_str())
- .and_then(|s| HashRateUnit::from_str(s).ok())
- .unwrap_or(HashRateUnit::GigaHash),
+ unit,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default()),
@@ -888,11 +920,34 @@ impl GetControlBoardVersion for AntMinerV2020 {
&self,
data: &HashMap<DataField, Value>,
) -> Option<MinerControlBoard> {
- let cb_type = data.extract::<String>(DataField::ControlBoardVersion)?;
- match cb_type.as_str() {
- s if s.to_uppercase().contains("AML") => Some(AntMinerControlBoard::AMLogic.into()),
- _ => AntMinerControlBoard::parse(cb_type.split("_").collect::<Vec<&str>>()[0])
- .map(|cb| cb.into()),
+ let field = data.get(&DataField::ControlBoardVersion)?;
+ // Explicit control-board subtype (miner_type.cgi) wins when present.
+ let subtype = field
+ .pointer("/subtype")
+ .and_then(|v| v.as_str())
+ .unwrap_or("");
+ if !subtype.is_empty() {
+ return match subtype {
+ s if s.to_uppercase().contains("AML") => Some(AntMinerControlBoard::AMLogic.into()),
+ _ => AntMinerControlBoard::parse(subtype.split('_').next().unwrap_or(subtype))
+ .map(|cb| cb.into()),
+ };
+ }
+ // No subtype (older models): read the control board from the kernel build
+ // string instead of guessing from the model (round 12 #10). Bitmain names
+ // the SoC in the kernel version, e.g. "Linux 4.6.0-xilinx-..." (Z15) or an
+ // AMLogic/Meson kernel on newer AMLogic boards.
+ let kernel = field
+ .pointer("/kernel")
+ .and_then(|v| v.as_str())
+ .unwrap_or("")
+ .to_ascii_lowercase();
+ if kernel.contains("xilinx") || kernel.contains("zynq") {
+ Some(AntMinerControlBoard::Xilinx.into())
+ } else if kernel.contains("aml") || kernel.contains("meson") {
+ Some(AntMinerControlBoard::AMLogic.into())
+ } else {
+ None
}
}
}
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/rpc.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/rpc.rs
index 23962f35..52232c1f 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/rpc.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/rpc.rs
@@ -71,7 +71,17 @@ impl AntMinerRPCAPI {
read_stream_response(&mut stream, DEFAULT_RPC_TIMEOUT).await
};
let response = response?;
- self.parse_rpc_result(&response)
+ self.parse_rpc_result(&Self::sanitize_cgminer(&response))
+ }
+
+ /// Antminer's cgminer `stats` sometimes emits an array whose objects are not
+ /// comma-separated (`...}{"STATS":0,...` on the Z15/Z15J), which is invalid
+ /// JSON that serde rejects -- dropping the whole stats command and with it
+ /// every stats-derived field (expected hashrate, wattage, fans, hashboards,
+ /// uptime). Insert the missing separators. Well-formed JSON never contains an
+ /// unseparated `}{`, so this is a no-op on valid responses (round 12 #10).
+ fn sanitize_cgminer(response: &str) -> String {
+ response.replace("}{", "},{")
}
fn parse_rpc_result(&self, response: &str) -> anyhow::Result<Value> {
diff --git a/vendor/asic-rs-firmwares-antminer/src/firmware.rs b/vendor/asic-rs-firmwares-antminer/src/firmware.rs
index fce5e8ff..46abbc9d 100644
--- a/vendor/asic-rs-firmwares-antminer/src/firmware.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/firmware.rs
@@ -142,18 +142,9 @@ async fn get_model_with_auth(
}
}
-/// Fetch the firmware version from a miner using digest auth.
-async fn get_version_with_auth(ip: IpAddr, auth: &MinerAuth) -> Option<semver::Version> {
- let client = build_discovery_client().ok()?;
- let data: Response = client
- .get(format!("http://{ip}/cgi-bin/summary.cgi"))
- .send_digest_auth((auth.username(), auth.password()))
- .await
- .ok()?;
-
- let json_data = data.json::<serde_json::Value>().await.ok()?;
- let fw_version = json_data["INFO"]["CompileTime"].as_str().unwrap_or("");
-
+/// Parse an Antminer cgminer `CompileTime` string ("Mon Dec 14 18:01:42 CST
+/// 2020") into a date-based semver (year.month.day) used to pick the backend.
+fn parse_antminer_compile_time(fw_version: &str) -> Option<semver::Version> {
let cleaned: String = {
let mut parts: Vec<&str> = fw_version.split_whitespace().collect();
if parts.len() > 4 {
@@ -161,9 +152,7 @@ async fn get_version_with_auth(ip: IpAddr, auth: &MinerAuth) -> Option<semver::V
}
parts.join(" ")
};
-
let dt = NaiveDateTime::parse_from_str(&cleaned, "%a %b %e %H:%M:%S %Y").ok()?;
-
Some(semver::Version::new(
dt.year() as u64,
dt.month() as u64,
@@ -171,6 +160,34 @@ async fn get_version_with_auth(ip: IpAddr, auth: &MinerAuth) -> Option<semver::V
))
}
+/// Fetch the firmware version (as a date-based semver) to pick the backend.
+async fn get_version_with_auth(ip: IpAddr, auth: &MinerAuth) -> Option<semver::Version> {
+ // Newer Antminers expose the firmware CompileTime via summary.cgi.
+ if let Ok(client) = build_discovery_client()
+ && let Ok(data) = client
+ .get(format!("http://{ip}/cgi-bin/summary.cgi"))
+ .send_digest_auth((auth.username(), auth.password()))
+ .await
+ && let Ok(json_data) = data.json::<serde_json::Value>().await
+ && let Some(v) =
+ parse_antminer_compile_time(json_data["INFO"]["CompileTime"].as_str().unwrap_or(""))
+ {
+ return Some(v);
+ }
+
+ // Older models (e.g. Z15/Z15J) have no summary.cgi, so summary-based version
+ // detection returns nothing and the miner would default to the newest
+ // backend and be mis-parsed. Fall back to the cgminer :4028 `version` RPC,
+ // which still reports the CompileTime, so the right (older) backend is picked
+ // (round 12 #10).
+ let rpc = asic_rs_core::util::send_rpc_command(&ip, "version").await?;
+ parse_antminer_compile_time(
+ rpc.pointer("/VERSION/0/CompileTime")
+ .and_then(|v| v.as_str())
+ .unwrap_or(""),
+ )
+}
+
#[async_trait]
impl MinerFirmware for AntMinerStockFirmware {
/// Uses default credentials. For custom credentials, use `build_miner`
@@ -0,0 +1,205 @@
Subject: [PATCH 0007] whatsminer: enable control commands on the V1 backend
Round-12 #8b part 2. Pre-2022-07-29 WhatsMiners route to the V1 backend, which
exposed no control commands (every supports_* returned false), so older units
could be monitored but not controlled -- and the GUI's capability-based actions
never lit up for them. V1-era firmware speaks the same classic btminer token
write API (get_token + md5crypt + AES-256-ECB) as V2 (the access-probe token
handshake proved V1 accepts it), so V1 now reuses V2's proven RPC client for
writes: set_fault_light, set_power_limit, update_pools, restart, pause, resume
are implemented exactly as V2, going through a new `write_rpc`
(crate::backends::v2::rpc), and HasAuth routes the admin password to it.
Verified on a live V1 unit that the token AES key (password) is accepted; the
control-command write path is identical to V2's, which is validated live on the
fleet. Note: some V1 units keep their API in read-only mode and answer write
commands with Code 45 "can't access write cmd" until an operator enables write
access via the WhatsMiner Tool -- that is a per-device setting, and the backend
now fails such a write gracefully rather than not offering the command at all.
The 40 whatsminer crate tests pass unchanged.
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
index f95a22ae..c9c96713 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -26,8 +26,9 @@ use async_trait::async_trait;
use macaddr::MacAddr;
use measurements::{AngularVelocity, Frequency, Power, Temperature};
use rpc::WhatsMinerRPCAPI;
+use asic_rs_core::util::is_expected_write_error;
use semver::Version;
-use serde_json::Value;
+use serde_json::{Value, json};
use crate::firmware::WhatsMinerFirmware;
@@ -37,6 +38,12 @@ mod rpc;
pub struct WhatsMinerV1 {
pub ip: IpAddr,
pub rpc: WhatsMinerRPCAPI,
+ // Privileged (token-authenticated) writes reuse the V2 btminer RPC client:
+ // pre-2022-07-29 miners speak the same classic get_token + AES-ECB write API
+ // as V2 (proven live via the access-probe token handshake), so the control
+ // commands share V2's implementation instead of the read-only V1 rpc above
+ // (round 12 #8b part 2).
+ pub write_rpc: crate::backends::v2::rpc::WhatsMinerRPCAPI,
pub device_info: DeviceInfo,
}
@@ -45,6 +52,11 @@ impl WhatsMinerV1 {
WhatsMinerV1 {
ip,
rpc: WhatsMinerRPCAPI::new(ip, None),
+ write_rpc: crate::backends::v2::rpc::WhatsMinerRPCAPI::new(
+ ip,
+ None,
+ MinerAuth::new("admin", "admin"),
+ ),
device_info: DeviceInfo::new(
model,
WhatsMinerFirmware::default(),
@@ -560,17 +572,45 @@ impl GetPools for WhatsMinerV1 {
}
}
+#[async_trait]
+// Control commands (round 12 #8b part 2): the classic btminer token write API is
+// the same on V1-era firmware as on V2, so these mirror the V2 backend but go
+// through `write_rpc`. The write path was validated live on a V1 unit with the
+// reversible locate-light command (safe, non-disruptive to mining).
#[async_trait]
impl SetFaultLight for WhatsMinerV1 {
+ async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
+ let parameters = match fault {
+ false => Some(json!({"param": "auto"})),
+ true => Some(json!({"color": "red", "period": 200, "duration": 100, "start": 0})),
+ };
+ let data = self.write_rpc.send_command("set_led", true, parameters).await;
+ Ok(data.is_ok())
+ }
fn supports_set_fault_light(&self) -> bool {
- false
+ true
}
}
#[async_trait]
impl SetPowerLimit for WhatsMinerV1 {
+ async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
+ let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
+ match self
+ .write_rpc
+ .send_command("adjust_power_limit", true, parameters)
+ .await
+ {
+ Ok(_) => Ok(true),
+ // adjust_power_limit restarts the miner to re-tune, dropping the
+ // connection mid-command even though the limit was accepted; a
+ // transient write error is success, a genuine rejection still errors.
+ Err(e) if is_expected_write_error(&e) => Ok(true),
+ Err(e) => Err(e),
+ }
+ }
fn supports_set_power_limit(&self) -> bool {
- false
+ true
}
}
@@ -585,29 +625,77 @@ impl SupportsPoolsConfig for WhatsMinerV1 {
.collect())
}
+ async fn set_pools_config(&self, config: Vec<PoolGroupConfig>) -> anyhow::Result<bool> {
+ let group = config
+ .into_iter()
+ .next()
+ .ok_or_else(|| anyhow::anyhow!("No pool groups provided"))?;
+ let mut params = serde_json::Map::new();
+ for n in 1..=3 {
+ let pool = group.pools.get(n - 1);
+ params.insert(
+ format!("pool{n}"),
+ json!(pool.map(|p| p.url.to_string()).unwrap_or_default()),
+ );
+ params.insert(
+ format!("worker{n}"),
+ json!(pool.map(|p| p.username.as_str()).unwrap_or_default()),
+ );
+ params.insert(
+ format!("passwd{n}"),
+ json!(pool.map(|p| p.password.as_str()).unwrap_or_default()),
+ );
+ }
+ Ok(self
+ .write_rpc
+ .send_command("update_pools", true, Some(json!(params)))
+ .await
+ .is_ok())
+ }
+
fn supports_pools_config(&self) -> bool {
- false
+ true
}
}
#[async_trait]
impl Restart for WhatsMinerV1 {
+ async fn restart(&self) -> anyhow::Result<bool> {
+ // The miner often reboots before replying, so any error is treated as
+ // "rebooting".
+ let _ = self.write_rpc.send_command("reboot", true, None).await;
+ Ok(true)
+ }
fn supports_restart(&self) -> bool {
- false
+ true
}
}
#[async_trait]
impl Pause for WhatsMinerV1 {
+ #[allow(unused_variables)]
+ async fn pause(&self, at_time: Option<Duration>) -> anyhow::Result<bool> {
+ // Fire-and-forget: the miner may power off before responding.
+ let _ = self
+ .write_rpc
+ .send_command("power_off", true, Some(json!({"respbefore": "true"})))
+ .await;
+ Ok(true)
+ }
fn supports_pause(&self) -> bool {
- false
+ true
}
}
#[async_trait]
impl Resume for WhatsMinerV1 {
+ #[allow(unused_variables)]
+ async fn resume(&self, at_time: Option<Duration>) -> anyhow::Result<bool> {
+ let data = self.write_rpc.send_command("power_on", true, None).await;
+ Ok(data.is_ok())
+ }
fn supports_resume(&self) -> bool {
- false
+ true
}
}
@@ -643,7 +731,13 @@ impl UpgradeFirmware for WhatsMinerV1 {
}
}
-impl HasAuth for WhatsMinerV1 {}
+impl HasAuth for WhatsMinerV1 {
+ fn set_auth(&mut self, auth: MinerAuth) {
+ // WhatsMiner's token account is always "admin"; only the password varies.
+ // Route it to the privileged write RPC (round 12 #8b part 2).
+ self.write_rpc.set_auth(MinerAuth::new("admin", auth.password()));
+ }
+}
impl HasDefaultAuth for WhatsMinerV1 {}
impl Validate for WhatsMinerV1 {
@@ -0,0 +1,143 @@
Subject: [PATCH 0008] antminer: resolve Z15J / unknown-model algorithm
Round-13 #4/#5. A Z15J reports its model as "ANTMINER Z15J", which asic-rs' alias
table did not recognise, so it deserialised to AntMinerModel::Unknown and its
hash algorithm resolved to HashAlgorithm::Unknown. That left the miner's Sol/s
hashrate un-bucketed as "unknown hashrate" in the GUI, even though the round-10
unit reinterpretation already read the value correctly. (The older ANTMINER Z15
matched the table and reported Equihash; only the J revision was affected.)
Two layers of fix:
- models.rs / hardware.rs: add a first-class Z15J model (Equihash, same 3-chip
x 3-board / 2-fan chassis profile as the Z15) so it parses to a named model
and carries the right algorithm, and shows a clean "Z15J" model name.
- v2020 backend: when the alias table still can't place a model, infer the
algorithm from the Antminer family letter for the lines that are
single-algorithm end to end (Z -> Equihash, L -> Scrypt, S/T -> SHA-256), so
other not-yet-tabled models are bucketed sensibly instead of Unknown.
Ambiguous families (K spans Kadena/KHeavyHash/Eaglesong; DR is Blake256 while
D is X11) are deliberately left Unknown rather than guessed wrong.
Live-verified on 10.5.1.{50,72,196,205}: Z15 and Z15J now both report
algo=Equihash with their real Sol/s rates (e.g. 305k, 132k; 0 on idle units).
The antminer crate tests pass, plus two new unit tests (z15j_parses_as_equihash,
unknown_models_infer_algo_from_family_letter).
diff --git a/vendor/asic-rs-makes-antminer/src/models.rs b/vendor/asic-rs-makes-antminer/src/models.rs
--- a/vendor/asic-rs-makes-antminer/src/models.rs
+++ b/vendor/asic-rs-makes-antminer/src/models.rs
@@ -78,6 +78,9 @@
#[serde(alias = "ANTMINER Z15 PRO")]
#[algorithm(HashAlgorithm::Equihash)]
Z15Pro,
+ #[serde(alias = "ANTMINER Z15J")]
+ #[algorithm(HashAlgorithm::Equihash)]
+ Z15J,
#[serde(alias = "ANTMINER S17")]
#[algorithm(HashAlgorithm::SHA256)]
S17,
@@ -281,12 +284,22 @@
(AntMinerModel::E9Pro, HashAlgorithm::EtHash),
(AntMinerModel::Z15, HashAlgorithm::Equihash),
(AntMinerModel::Z15Pro, HashAlgorithm::Equihash),
+ (AntMinerModel::Z15J, HashAlgorithm::Equihash),
] {
assert_eq!(model.hash_algorithm(), expected, "{model}");
}
}
#[test]
+ fn z15j_parses_as_equihash() {
+ // The Z15J reports "ANTMINER Z15J"; before it had an alias it fell back to
+ // Unknown, which left its Sol/s hashrate un-bucketed (round 13 #5).
+ let model = AntMinerModel::from_str("ANTMINER Z15J").unwrap();
+ assert_eq!(model, AntMinerModel::Z15J);
+ assert_eq!(model.hash_algorithm(), HashAlgorithm::Equihash);
+ }
+
+ #[test]
fn unknown_model_uses_unknown_algorithm() {
let model = AntMinerModel::from_str("ANTMINER S99").unwrap();
diff --git a/vendor/asic-rs-makes-antminer/src/hardware.rs b/vendor/asic-rs-makes-antminer/src/hardware.rs
--- a/vendor/asic-rs-makes-antminer/src/hardware.rs
+++ b/vendor/asic-rs-makes-antminer/src/hardware.rs
@@ -97,6 +97,10 @@
AntMinerModel::Z15Pro => Self {
fans: Some(2),
boards: Some(vec![Some(6), Some(6), Some(6)]),
+ },
+ AntMinerModel::Z15J => Self {
+ fans: Some(2),
+ boards: Some(vec![Some(3), Some(3), Some(3)]),
},
AntMinerModel::S17 => Self {
fans: Some(4),
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -201,10 +201,41 @@
Value::Object(payload)
}
+/// Infer an Antminer's hash algorithm from its model-family letter, for models
+/// asic-rs' alias table doesn't recognise (round 13 #5). Only the families whose
+/// entire product line shares one algorithm are inferred; anything ambiguous
+/// (the K-series spans Kadena/KHeavyHash/Eaglesong, DR is Blake256 while D is
+/// X11) is left Unknown rather than guessed wrong.
+fn infer_antminer_algo(model: &str) -> HashAlgorithm {
+ let upper = model.to_ascii_uppercase();
+ let name = upper
+ .strip_prefix("ANTMINER ")
+ .unwrap_or(&upper)
+ .trim_start();
+ match name.chars().next() {
+ // Z9 / Z11 / Z15 / Z15 Pro / Z15J -- the whole Z line is Equihash.
+ Some('Z') => HashAlgorithm::Equihash,
+ // L3+ / L7 / L9 / L11 -- the whole L line is Scrypt.
+ Some('L') => HashAlgorithm::Scrypt,
+ // S9..S21 and T9..T21 (and future revisions) are all SHA-256.
+ Some('S') | Some('T') => HashAlgorithm::SHA256,
+ _ => HashAlgorithm::Unknown,
+ }
+}
+
impl AntMinerV2020 {
pub fn new(ip: IpAddr, model: impl MinerModel) -> Self {
let auth = Self::default_auth();
- let algo = model.hash_algorithm();
+ // asic-rs maps a model string to its algorithm through a fixed alias
+ // table; a model that is not in the table (a Z15J, a not-yet-added
+ // S-series, ...) resolves to HashAlgorithm::Unknown, which then leaves the
+ // miner's hashrate un-bucketed ("unknown hashrate", round 13 #5). When the
+ // table can't place the model, infer the algorithm from its Antminer
+ // family letter for the lines that are single-algorithm end to end.
+ let algo = match model.hash_algorithm() {
+ HashAlgorithm::Unknown => infer_antminer_algo(&model.to_string()),
+ known => known,
+ };
AntMinerV2020 {
ip,
rpc: AntMinerRPCAPI::new(ip),
@@ -1431,6 +1462,21 @@
};
#[test]
+ fn unknown_models_infer_algo_from_family_letter() {
+ // Round 13 #5: a model outside asic-rs' alias table must still resolve a
+ // sensible algorithm from its Antminer family letter instead of Unknown.
+ assert_eq!(infer_antminer_algo("ANTMINER Z15J"), HashAlgorithm::Equihash);
+ assert_eq!(infer_antminer_algo("Z9"), HashAlgorithm::Equihash);
+ assert_eq!(infer_antminer_algo("ANTMINER L15"), HashAlgorithm::Scrypt);
+ assert_eq!(infer_antminer_algo("ANTMINER S23"), HashAlgorithm::SHA256);
+ assert_eq!(infer_antminer_algo("ANTMINER T23"), HashAlgorithm::SHA256);
+ // Ambiguous / unrelated families stay Unknown (K-series spans three
+ // algorithms; a bare unknown string has no family).
+ assert_eq!(infer_antminer_algo("ANTMINER KS7"), HashAlgorithm::Unknown);
+ assert_eq!(infer_antminer_algo("WHATSMINER M30"), HashAlgorithm::Unknown);
+ }
+
+ #[test]
fn set_miner_conf_payload_matches_cgi_contract_for_pause_resume() {
let pre = json!({
"pools": [
@@ -0,0 +1,39 @@
Subject: [PATCH 0009] antminer: read Z15-style fans from higher fan slots
Round-15 #12. The v2020 backend's parse_fans only read fan1..hardware.fans, but
some models report their fans in higher slots and leave the low ones at 0 -- the
Z15 has fan_num=2 yet reports its two fans in fan3/fan4 with fan1/fan2 = 0, so no
fans were read. Scan a generous range of fan slots (1..16) and collect the
non-zero readings instead, renumbered 0.. in the order found. Verified against a
live Z15 (fan3=4920, fan4=5160). The antminer crate tests pass unchanged.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index 0ce462c9..38935a59 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -833,15 +833,23 @@ impl GetFans for AntMinerV2020 {
let mut fans: Vec<FanData> = Vec::new();
if let Some(stats_data) = data.get(&DataField::Fans) {
- for i in 1..=self.device_info.hardware.fans.unwrap_or(4) {
+ // Some models report their fans in higher fan slots and leave the low
+ // ones at 0 -- the Z15, for example, has fan_num=2 but reports its two
+ // fans in fan3/fan4 with fan1/fan2 = 0. So scan a generous range of
+ // slots and collect the non-zero readings rather than only reading
+ // fan1..hardware.fans (which missed the Z15 entirely). The collected
+ // fans are renumbered 0.. in the order found (round 14 #12).
+ let mut pos: i16 = 0;
+ for i in 1..=16 {
if let Some(fan_speed) =
stats_data.get(format!("fan{}", i)).and_then(|v| v.as_f64())
&& fan_speed > 0.0
{
fans.push(FanData {
- position: (i - 1) as i16,
+ position: pos,
rpm: Some(AngularVelocity::from_rpm(fan_speed)),
});
+ pos += 1;
}
}
}
@@ -0,0 +1,183 @@
Subject: [PATCH 0010] antminer: fix v2020 locate-LED + reboot for the legacy web UI
Round-15 #7. On old (< 2023.07) Antminer firmware -- the LuCI-derived web UI, e.g.
the Z15/Z15J -- the "flash the locate light" action never worked: set_fault_light
returned Ok(false) on real hardware even though the request "succeeded".
Root cause (confirmed against a live Z15): that firmware's blink.cgi does NOT take
the JSON body {"blink":"true"} the backend sent (it silently ignores it, answering
200 with an empty text/html body, so the JSON parse fails and the error is swallowed
into Ok(false)). Its own blink.html instead POSTs a form field action=startBlink /
stopBlink, and reads state back with action=onPageLoaded -> {"isBlinking":bool}.
The action handler also frequently answers 401/500 even when the toggle succeeds, so
its HTTP status is not a reliable success signal.
Fix: add send_web_form_command (application/x-www-form-urlencoded POST; this reqwest
build has no .form()); blink() now fires action=startBlink/stopBlink, ignores the
unreliable status, and reads the real state back via onPageLoaded; set_fault_light
reports success only when the observed isBlinking matches the request. The LightFlashing
data read is routed to the same onPageLoaded path (get_blink_status.cgi is 404 on this
firmware) and remapped to {"blink":bool} so the shared /blink extractor still works.
Also fixes reboot() for the same generation: reboot.html does type:'GET', but the
backend POSTed to reboot.cgi. Switched to GET to match the vendor UI (the Restart
action was affected). Not live-fired, to avoid rebooting production miners.
Verified live: Z15 and Z15J now return set_fault_light(on/off) -> Ok(true) with the
light genuinely toggling; VNish (AMLogic/CVITek/Xilinx/BeagleBoneBlack) and WhatsMiner
(H6OS/H616) remain Ok(true) with no regression.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index 38935a59..bd8662b1 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -1111,9 +1111,17 @@ impl SetFaultLight for AntMinerV2020 {
true
}
- #[allow(unused_variables)]
async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
- Ok(self.web.blink(fault).await.is_ok())
+ // `blink()` fires the toggle then reads the state back as `{"isBlinking":
+ // bool}` (the legacy CGI's own HTTP status is unreliable). Report success
+ // only when the observed locate-LED state matches what was requested.
+ let observed = self
+ .web
+ .blink(fault)
+ .await?
+ .get("isBlinking")
+ .and_then(serde_json::Value::as_bool);
+ Ok(observed == Some(fault))
}
}
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
index 7d6f237c..a50cc4ee 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/web.rs
@@ -240,6 +240,45 @@ impl AntMinerWebAPI {
Ok(response)
}
+ /// POST a form-encoded (`application/x-www-form-urlencoded`) body to a CGI
+ /// endpoint and parse the JSON reply. The legacy LuCI web UI endpoints (e.g.
+ /// `blink.cgi`) expect `action=...` form fields, not a JSON body. An empty
+ /// reply parses to `{}`; a non-2xx status bails.
+ async fn send_web_form_command(&self, command: &str, form: &[(&str, &str)]) -> Result<Value> {
+ let url = format!("http://{}:{}/cgi-bin/{}.cgi", self.ip, self.port, command);
+ // Build an application/x-www-form-urlencoded body by hand (this reqwest
+ // build has no `.form()` helper). The only fields used are `action` with
+ // fixed ASCII values, so percent-encoding is unnecessary.
+ let body = form
+ .iter()
+ .map(|(k, v)| format!("{k}={v}"))
+ .collect::<Vec<_>>()
+ .join("&");
+ let response = self
+ .client()?
+ .post(&url)
+ .header(
+ reqwest::header::CONTENT_TYPE,
+ "application/x-www-form-urlencoded",
+ )
+ .body(body)
+ .timeout(self.timeout)
+ .send_digest_auth((self.auth.username(), self.auth.password()))
+ .await
+ .map_err(|e| anyhow!(e.to_string()))?;
+
+ let status = response.status();
+ if !status.is_success() {
+ bail!("HTTP request failed with status code {}", status);
+ }
+ let text = response.text().await.map_err(|e| anyhow!(e.to_string()))?;
+ if text.trim().is_empty() {
+ Ok(json!({}))
+ } else {
+ serde_json::from_str(&text).map_err(|e| anyhow!(e.to_string()))
+ }
+ }
+
pub async fn get_miner_conf(&self) -> Result<Value> {
self.send_web_command("get_miner_conf", false, None, Method::GET)
.await
@@ -257,17 +296,31 @@ impl AntMinerWebAPI {
}
pub async fn blink(&self, blink: bool) -> Result<Value> {
- let param = if blink {
- json!({"blink": "true"})
- } else {
- json!({"blink": "false"})
- };
- self.send_web_command("blink", false, Some(param), Method::POST)
+ // Legacy LuCI web UI: the locate LED is toggled by POSTing an `action`
+ // form field to blink.cgi (`startBlink`/`stopBlink`) -- NOT a JSON body
+ // like the newer (>= 2023.07) firmware expects. The handler performs the
+ // action but frequently answers 401/500 even on success, so its HTTP
+ // status is not a reliable signal: fire it, ignore the response, then read
+ // the real state back via `onPageLoaded`.
+ let action = if blink { "startBlink" } else { "stopBlink" };
+ let _ = self
+ .send_web_form_command("blink", &[("action", action)])
+ .await;
+ self.blink_status().await
+ }
+
+ /// Query the locate-LED state via the legacy blink.cgi `onPageLoaded` action,
+ /// which reliably answers `200 {"isBlinking": bool}`.
+ pub async fn blink_status(&self) -> Result<Value> {
+ self.send_web_form_command("blink", &[("action", "onPageLoaded")])
.await
}
pub async fn reboot(&self) -> Result<Value> {
- self.send_web_command("reboot", false, None, Method::POST)
+ // The legacy LuCI web UI reboots via GET /cgi-bin/reboot.cgi (its own
+ // reboot.html does `type: 'GET'`); a POST is not what this firmware
+ // generation expects.
+ self.send_web_command("reboot", false, None, Method::GET)
.await
}
@@ -350,8 +403,17 @@ impl AntMinerWebAPI {
}
pub async fn get_blink_status(&self) -> Result<Value> {
- self.send_web_command("get_blink_status", false, None, Method::GET)
- .await
+ // The old firmware has no `get_blink_status.cgi` (it answers 404); the
+ // locate state lives behind blink.cgi's `onPageLoaded` action as
+ // `{"isBlinking": bool}`. Remap it to `{"blink": bool}` so the shared
+ // LightFlashing extractor (key `/blink`) keeps working.
+ let flashing = self
+ .blink_status()
+ .await?
+ .get("isBlinking")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ Ok(json!({ "blink": flashing }))
}
pub async fn set_network_conf(
@@ -383,10 +445,16 @@ impl APIClient for AntMinerWebAPI {
MinerCommand::WebAPI {
command,
parameters,
- } => self
- .send_web_command(command, false, parameters.clone(), Method::GET)
- .await
- .map_err(|e| anyhow!(e.to_string())),
+ } => {
+ // The legacy blink status lives behind a POST form action, not a
+ // GET .cgi (which 404s), so route it through the dedicated helper.
+ if *command == "get_blink_status" {
+ return self.get_blink_status().await;
+ }
+ self.send_web_command(command, false, parameters.clone(), Method::GET)
+ .await
+ .map_err(|e| anyhow!(e.to_string()))
+ }
_ => Err(anyhow!("Unsupported command type for Web client")),
}
}
@@ -0,0 +1,162 @@
Subject: [PATCH 0011] luxminer: implement set_power_limit; epic: document PSU gating
Round-15 follow-up. The toolkit reported supports_power_limit=false for LuxOS and
ePIC (UMC OS) miners. Investigated against the live corpus (S19j Pro on both).
LuxOS: genuinely under-reported. LuxOS tunes by discrete named profiles, each
carrying a Watts rating (the `profiles` RPC returns Step + Watts), applied with
profileset -- pure frequency/voltage tuning, no special PSU needed. Implemented
SetPowerLimit by mapping the requested watts to the highest profile whose Watts
does not exceed it (or the lowest profile when the target is below all of them),
then profileset. supports_set_power_limit now returns true. The pure mapping is
factored into parse_profile_watts + select_profile_at_or_below with a unit test.
Verified live: set_power_limit(2500) on an S19j Pro selected step -4 (2385 W, the
highest <= 2500) and the miner's active profile became 445MHz/-4.
ePIC: NOT under-reporting after all -- left at false, with a comment explaining
why. ePIC PowerPlay's only true power-limit path is the PowerTune perpetual-tune
algorithm, which the firmware gates on the PSU: on a fixed-voltage Bitmain PSU
(the APW12 on an S19j Pro) perpetualtune/algo rejects it with "Power optimization
is not supported by this PSU". That support is a per-PSU runtime property this
synchronous, no-I/O capability check cannot observe, so advertising true would
over-report on most reflashed Antminers. (Hashrate tuning stays available via
set_tuning_config.)
diff --git a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
index a6f555f7..c21e05b1 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -1369,6 +1369,14 @@ impl SetFaultLight for PowerPlayV1 {
#[async_trait]
impl SetPowerLimit for PowerPlayV1 {
fn supports_set_power_limit(&self) -> bool {
+ // ePIC PowerPlay's only true power-limit mechanism is the PowerTune
+ // perpetual-tune algorithm, which the firmware gates on the PSU: on a
+ // fixed-voltage Bitmain PSU (e.g. the APW12 on an S19j Pro) the
+ // perpetualtune/algo endpoint rejects it with "Power optimization is not
+ // supported by this PSU". Since that support is a per-PSU runtime property
+ // that this synchronous, no-I/O capability check cannot observe, report
+ // false rather than over-advertise a control that fails on most reflashed
+ // Antminers. (Hashrate tuning is exposed separately via set_tuning_config.)
false
}
}
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
index af89167c..aac39eb6 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -1052,10 +1052,66 @@ impl SetFaultLight for LuxMinerV1 {
}
}
+/// Parse a LuxOS `profiles` RPC reply into (step name, watts) pairs, keeping only
+/// profiles that report both a `Step` and a `Watts` value.
+fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
+ profiles
+ .get("PROFILES")
+ .and_then(Value::as_array)
+ .map(|arr| {
+ arr.iter()
+ .filter_map(|p| {
+ let step = p.get("Step").and_then(Value::as_str)?.to_string();
+ let watts = p.get("Watts").and_then(Value::as_f64)?;
+ Some((step, watts))
+ })
+ .collect()
+ })
+ .unwrap_or_default()
+}
+
+/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
+/// profile that does not exceed `target_w`, or -- when the target is below every
+/// profile -- the lowest-watt profile. Returns None only when there are no
+/// profiles to choose from.
+fn select_profile_at_or_below(steps: &[(String, f64)], target_w: f64) -> Option<String> {
+ if steps.is_empty() {
+ return None;
+ }
+ let mut sorted: Vec<&(String, f64)> = steps.iter().collect();
+ sorted.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
+ sorted
+ .iter()
+ .rev()
+ .find(|(_, w)| *w <= target_w)
+ .or_else(|| sorted.first())
+ .map(|(s, _)| s.clone())
+}
+
#[async_trait]
impl SetPowerLimit for LuxMinerV1 {
fn supports_set_power_limit(&self) -> bool {
- false
+ true
+ }
+
+ async fn set_power_limit(&self, power: Power) -> anyhow::Result<bool> {
+ // LuxOS tunes by discrete named profiles (each carries a Watts rating),
+ // not a raw watts setpoint. Map the requested limit to the highest profile
+ // whose Watts does not exceed it (or the lowest profile when the target is
+ // below every profile), then apply it with profileset.
+ let profiles = self.rpc.profiles().await?;
+ let steps = parse_profile_watts(&profiles);
+ let Some(chosen) = select_profile_at_or_below(&steps, power.as_watts()) else {
+ anyhow::bail!("LuxOS reported no tunable profiles with a Step/Watts pair");
+ };
+ let resp = self.rpc.profileset(&chosen).await?;
+ // LuxOS answers with a STATUS array; "S"/"I" is success. A missing status
+ // after a non-error reply is treated as applied.
+ Ok(resp
+ .pointer("/STATUS/0/STATUS")
+ .and_then(Value::as_str)
+ .map(|s| matches!(s, "S" | "I"))
+ .unwrap_or(true))
}
}
@@ -1231,6 +1287,46 @@ mod tests {
POWER, PROFILES, STATS, SUMMARY, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1, VOLTAGEGET_2,
};
+ #[test]
+ fn power_limit_profile_selection() {
+ // LuxOS reports a ladder of profiles, each with a Step name and Watts.
+ let steps = vec![
+ ("-16".to_string(), 865.0),
+ ("-4".to_string(), 2385.0),
+ ("-2".to_string(), 2790.0),
+ ("0".to_string(), 3100.0),
+ ];
+ // The highest profile at or below the requested watts limit.
+ assert_eq!(
+ select_profile_at_or_below(&steps, 2500.0).as_deref(),
+ Some("-4")
+ );
+ assert_eq!(
+ select_profile_at_or_below(&steps, 2790.0).as_deref(),
+ Some("-2")
+ );
+ // Above every profile -> the maximum profile (a limit can't exceed the
+ // hardware's top profile).
+ assert_eq!(
+ select_profile_at_or_below(&steps, 9000.0).as_deref(),
+ Some("0")
+ );
+ // Below every profile -> the minimum profile.
+ assert_eq!(
+ select_profile_at_or_below(&steps, 100.0).as_deref(),
+ Some("-16")
+ );
+ // No profiles -> nothing to choose.
+ assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
+
+ // parse_profile_watts against the captured LuxOS `profiles` reply: it
+ // yields tunable profiles and selection finds a real step among them.
+ let profiles: Value = serde_json::from_str(PROFILES).unwrap();
+ let parsed = parse_profile_watts(&profiles);
+ assert!(!parsed.is_empty(), "fixture should carry tunable profiles");
+ assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
+ }
+
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {
@@ -0,0 +1,229 @@
Subject: [PATCH 0012] whatsminer: robust per-component fault messages (V1 source + malformed-array repair)
Round-16 #1/#3. The toolkit could not attribute WhatsMiner faults to specific
hashboards. Two backend gaps, both found against live H6OS units:
1. V1 backend sourced messages from `summary` (/SUMMARY/0 "Error Code N"), which
is empty on these units -- the real faults are in get_error_code, like V2/V3.
Repointed DataField::Messages to get_error_code (/Msg/error_code) and rewrote
parse_messages to read the {code: timestamp} array (mirroring V2). asic-rs's
error_codes::error_info already maps each code to a MinerComponent (HashBoard
idx / PowerSupply / Fan / ControlBoard) and human text.
2. Some firmware emits an INVALID error_code array of bare "code":"timestamp"
pairs (`["540":"..","541":".."]`) instead of objects (`[{"540":".."}]`), which
fails the whole response parse so no messages surface at all. Added
error_codes::repair_error_code_array (targeted, no-op on valid input) and call
it in the V1 and V2 RPC read paths before parsing.
Verified live: 10.7.1.231 -> PowerSupply errors 205/206/217/251; 10.8.1.234 (the
malformed-array unit) -> 540 HashBoard 0, 541/561 HashBoard 1, 600 miner-level --
board 2 correctly clean. Unit test covers the repair; whatsminer tests pass.
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
index c9c96713..67907049 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -117,6 +117,10 @@ impl GetDataLocations for WhatsMinerV1 {
command: "get_psu",
parameters: None,
};
+ const RPC_GET_ERROR_CODE: MinerCommand = MinerCommand::RPC {
+ command: "get_error_code",
+ parameters: None,
+ };
match data_field {
DataField::Mac => vec![(
@@ -254,10 +258,10 @@ impl GetDataLocations for WhatsMinerV1 {
},
)],
DataField::Messages => vec![(
- RPC_SUMMARY,
+ RPC_GET_ERROR_CODE,
DataExtractor {
func: get_by_pointer,
- key: Some("/SUMMARY/0"),
+ key: Some("/Msg/error_code"),
tag: None,
},
)],
@@ -471,32 +475,43 @@ impl GetTuningCapabilities for WhatsMinerV1 {}
impl GetLightFlashing for WhatsMinerV1 {}
impl GetMessages for WhatsMinerV1 {
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
+ // WhatsMiner V1 (H6OS) reports faults via get_error_code -> Msg.error_code,
+ // an array of {code: timestamp} objects (the same shape as V2/V3; the RPC
+ // layer repairs the occasional invalid bare-pair array first). The older
+ // summary "Error Code N" fields are frequently empty on these units.
let mut messages = Vec::new();
-
- let error_count = data
- .get(&DataField::Messages)
- .and_then(|val| {
- val.pointer("/Error Code Count")
- .and_then(|val| val.as_u64())
- })
- .unwrap_or(0u64) as usize;
- for idx in 0..error_count {
- let e_code = data
- .get(&DataField::Messages)
- .and_then(|val| val.pointer(&format!("/Error Code {}", idx)))
- .and_then(|val| val.as_u64());
- if let Some(code) = e_code {
- let info = crate::error_codes::error_info(code);
+ let Some(errors) = data.get(&DataField::Messages) else {
+ return messages;
+ };
+ for obj in errors.as_array().unwrap_or(&Vec::new()).iter() {
+ let Some(obj) = obj.as_object() else {
+ continue;
+ };
+ for (code, time) in obj.iter() {
+ let Some(time_str) = time.as_str() else {
+ continue;
+ };
+ let timestamp =
+ chrono::NaiveDateTime::parse_from_str(time_str, "%Y-%m-%d %H:%M:%S")
+ .map(|t| {
+ chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
+ t,
+ chrono::Utc,
+ )
+ })
+ .map(|dt| dt.timestamp() as u32)
+ .unwrap_or(0);
+ let parsed_code = code.parse::<u64>().unwrap_or(0);
+ let info = crate::error_codes::error_info(parsed_code);
messages.push(MinerMessage::with_component(
- 0,
- code,
+ timestamp,
+ parsed_code,
info.message,
MessageSeverity::Error,
info.component,
));
}
}
-
messages
}
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
index 6e6c604e..384bbcd3 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/rpc.rs
@@ -106,6 +106,9 @@ impl RPCAPIClient for WhatsMinerRPCAPI {
let response = response
.replace('\n', "") // Fix for WM V1, can have newlines in version which breaks the json parser
.replace(",}", "}"); // Fix for WM V1, can have trailing commas which breaks the json parser
+ // Fix for WM V1 get_error_code, which can emit an invalid array of bare
+ // "code":"timestamp" pairs (`["540":".."]`) that fails the whole parse.
+ let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
index 9eec7a93..99da6a89 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/rpc.rs
@@ -202,6 +202,9 @@ impl WhatsMinerRPCAPI {
read_stream_response(&mut stream, DEFAULT_RPC_TIMEOUT).await
};
let response = response?;
+ // Repair the occasional invalid get_error_code array (bare
+ // "code":"timestamp" pairs) before parsing; a no-op on valid responses.
+ let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs b/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
index b442e9dc..5bd8b02a 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/error_codes.rs
@@ -2,6 +2,56 @@ use asic_rs_core::data::message::MinerComponent;
const UNKNOWN: &str = "Unknown error type.";
+/// Repair an invalid `error_code` array emitted by some WhatsMiner firmware.
+///
+/// Certain (older, H6OS) firmwares report the fault list as bare
+/// `"code":"timestamp"` pairs directly inside a JSON array
+/// (`"error_code":["540":"..","541":".."]`) rather than an array of single-key
+/// objects (`[{"540":".."},{"541":".."}]`). The bare form is not valid JSON and
+/// fails the whole response parse, so no messages are surfaced at all. Rewrite the
+/// bare pairs into objects; already-valid (object-wrapped or empty) arrays and
+/// responses without an `error_code` array are returned unchanged.
+pub fn repair_error_code_array(raw: &str) -> String {
+ const KEY: &str = "\"error_code\":[";
+ let Some(pos) = raw.find(KEY) else {
+ return raw.to_string();
+ };
+ let open = pos + KEY.len() - 1; // index of the '['
+ let bytes = raw.as_bytes();
+ let mut depth = 0i32;
+ let mut close = None;
+ for (i, &b) in bytes.iter().enumerate().skip(open) {
+ match b {
+ b'[' => depth += 1,
+ b']' => {
+ depth -= 1;
+ if depth == 0 {
+ close = Some(i);
+ break;
+ }
+ }
+ _ => {}
+ }
+ }
+ let Some(close) = close else {
+ return raw.to_string();
+ };
+ let inner = &raw[open + 1..close];
+ // Already valid (each entry object-wrapped) or empty -> leave untouched.
+ if inner.trim().is_empty() || inner.contains('{') {
+ return raw.to_string();
+ }
+ // Timestamps carry no commas, so a top-level comma split isolates each pair.
+ let wrapped = inner
+ .split(',')
+ .map(str::trim)
+ .filter(|s| !s.is_empty())
+ .map(|pair| format!("{{{pair}}}"))
+ .collect::<Vec<_>>()
+ .join(",");
+ format!("{}{}{}", &raw[..=open], wrapped, &raw[close..])
+}
+
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ErrorInfo {
pub message: String,
@@ -514,6 +564,27 @@ fn serial_info_error(sub: u64, val: u64) -> String {
mod tests {
use super::*;
+ #[test]
+ fn repair_malformed_error_code_array() {
+ // Bare "code":"timestamp" pairs inside the array (invalid JSON) -> objects.
+ let bad = r#"{"STATUS":"S","Msg":{"error_code":["540":"2026-09-22 07:08:14","561":"2026-09-21 22:26:36"]},"Description":""}"#;
+ let fixed = repair_error_code_array(bad);
+ let v: serde_json::Value = serde_json::from_str(&fixed).expect("repaired JSON must parse");
+ let arr = v["Msg"]["error_code"].as_array().unwrap();
+ assert_eq!(arr.len(), 2);
+ assert_eq!(arr[0]["540"], "2026-09-22 07:08:14");
+ assert_eq!(arr[1]["561"], "2026-09-21 22:26:36");
+
+ // Already-valid (object-wrapped) arrays are returned unchanged.
+ let good = r#"{"Msg":{"error_code":[{"205":"2026-09-20 03:35:44"}]}}"#;
+ assert_eq!(repair_error_code_array(good), good);
+ // Empty array and no-array responses are untouched.
+ let empty = r#"{"Msg":{"error_code":[]}}"#;
+ assert_eq!(repair_error_code_array(empty), empty);
+ let none = r#"{"STATUS":"S"}"#;
+ assert_eq!(repair_error_code_array(none), none);
+ }
+
#[test]
fn short_code_returns_unknown() {
// Act
@@ -0,0 +1,98 @@
Subject: [PATCH 0013] braiins+luxminer: implement best-share / session-best-share (round 16 G9)
The GetBestShare/GetSessionBestShare traits had empty impls on every backend, so
MinerData.best_share/session_best_share were always None and the toolkit's two
"Best share" / "Session best" columns were dead.
Braiins v26_04: map DataField::BestShare to the already-fetched miner/stats WebAPI
response (/miner_stats/best_share) and parse it. (BOS has no session-best field ->
session stays None.) Verified live read-only on 10.4.1.83: 130601978.
LuxMiner v1: map DataField::BestShare + SessionBestShare to the already-fetched
summary RPC (/SUMMARY/0/Best Share and /Best Session Share) and parse both.
Verified live read-only on 10.4.1.60 (638881749/638881749) and 10.4.1.67
(497802665/497802665).
No extra network calls (both reuse commands already collected by get_data).
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
index fa947aee..e65fb201 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/mod.rs
@@ -286,6 +286,14 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
+ DataField::BestShare => vec![(
+ WEB_MINER_STATS,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/miner_stats/best_share"),
+ tag: None,
+ },
+ )],
DataField::TuningTarget => vec![
(
WEB_MINER_CONFIGURATION,
@@ -548,7 +556,13 @@ impl GetUptime for BraiinsV2604 {
}
}
-impl GetBestShare for BraiinsV2604 {}
+impl GetBestShare for BraiinsV2604 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // Braiins OS reports the all-time best share at miner/stats -> miner_stats.best_share
+ // (round 16 / G9). Large diffs may exceed f64 exactness but are fine for display.
+ data.extract::<f64>(DataField::BestShare)
+ }
+}
impl GetSessionBestShare for BraiinsV2604 {}
impl GetOperatingState for BraiinsV2604 {
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
index aac39eb6..2d1331bf 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -445,6 +445,22 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
+ DataField::SessionBestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Session Share"),
+ tag: None,
+ },
+ )],
DataField::Uptime => vec![(
RPC_STATS,
DataExtractor {
@@ -888,8 +904,18 @@ impl GetUptime for LuxMinerV1 {
}
}
-impl GetBestShare for LuxMinerV1 {}
-impl GetSessionBestShare for LuxMinerV1 {}
+impl GetBestShare for LuxMinerV1 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // LuxOS summary -> "Best Share" (all-time), round 16 / G9.
+ data.extract::<f64>(DataField::BestShare)
+ }
+}
+impl GetSessionBestShare for LuxMinerV1 {
+ fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // LuxOS summary -> "Best Session Share" (since boot), round 16 / G9.
+ data.extract::<f64>(DataField::SessionBestShare)
+ }
+}
impl GetOperatingState for LuxMinerV1 {}
@@ -0,0 +1,88 @@
Subject: [PATCH 0014] luxminer: pool ops must be privileged (send session_id); add removepool
Round 16 / G13. The LuxOS pool write commands (addgroup, groupquota, removegroup,
addpool, switchpool, enablepool, disablepool) were sent with privileged=false, so
no session_id was included. That works on default units but FAILS with a
"Missing session_id" error on password-set LuxOS units (every other LuxOS write --
profileset/fanset/curtail/etc. -- is already privileged=true). Flip all seven pool
ops to privileged=true so send_command prepends the logon session token, and add
the missing rpc.removepool (privileged) for future incremental pool editing.
Verified no regression on a default corpus unit (10.4.1.60): set_pools_config still
applies correctly via the new privileged path. The password-set failure path is a
code-correct fix but needs a password-set LuxOS unit to reproduce/verify live.
diff --git a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
index 1afc686c..39d7ef63 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/rpc.rs
@@ -239,7 +239,7 @@ impl LUXMinerRPCAPI {
pub async fn addgroup(&self, name: &str, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"addgroup",
- false,
+ true,
Some(Value::String(format!("{name},{quota}"))),
)
.await
@@ -248,7 +248,7 @@ impl LUXMinerRPCAPI {
pub async fn groupquota(&self, group_id: u32, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"groupquota",
- false,
+ true,
Some(Value::String(format!("{group_id},{quota}"))),
)
.await
@@ -257,7 +257,7 @@ impl LUXMinerRPCAPI {
pub async fn removegroup(&self, group_id: u32) -> anyhow::Result<Value> {
self.send_command(
"removegroup",
- false,
+ true,
Some(Value::String(group_id.to_string())),
)
.await
@@ -275,14 +275,14 @@ impl LUXMinerRPCAPI {
params.push(group_id);
}
- self.send_command("addpool", false, Some(Value::String(params.join(","))))
+ self.send_command("addpool", true, Some(Value::String(params.join(","))))
.await
}
pub async fn switchpool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"switchpool",
- false,
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -291,7 +291,7 @@ impl LUXMinerRPCAPI {
pub async fn enablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"enablepool",
- false,
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -300,7 +300,16 @@ impl LUXMinerRPCAPI {
pub async fn disablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"disablepool",
- false,
+ true,
+ Some(Value::String(pool_id.to_string())),
+ )
+ .await
+ }
+
+ pub async fn removepool(&self, pool_id: i32) -> anyhow::Result<Value> {
+ self.send_command(
+ "removepool",
+ true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -0,0 +1,37 @@
Subject: [PATCH 0015] braiins v26_04: treat an empty 2xx body as success (not a parse error)
Found live verifying change-password (round 17 B / G11). The BOS REST setters like
PUT auth/password answer 2xx with an empty body; send_command tried
response.json() on it, which fails, so change_password (which does `.is_ok()`)
reported Ok(false) even though the password DID change. Read the body as text
first: an empty body on a success status is Null (success), a non-empty body must
still parse. Verified live on 10.4.1.27: change root->bftest2 now returns Ok(true),
the new password authenticates, and restore -> root returns Ok(true).
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
index 624eca4c..3e06b682 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
@@ -57,11 +57,20 @@ impl WebAPIClient for BraiinsWebAPI {
let status = response.status();
if status.is_success() {
- let json_data = response
- .json()
+ // Some setters (e.g. PUT auth/password) answer 2xx with an empty or
+ // non-JSON body. An empty body is success, not a parse error -- treat
+ // it as Null so callers using `.is_ok()` don't read a real success as
+ // failure. A non-empty body must still parse.
+ let body = response
+ .text()
.await
.map_err(|e| BraiinsError::ParseError(e.to_string()))?;
- Ok(json_data)
+ if body.trim().is_empty() {
+ Ok(Value::Null)
+ } else {
+ Ok(serde_json::from_str(&body)
+ .map_err(|e| BraiinsError::ParseError(e.to_string()))?)
+ }
} else {
// The API reports why it rejected a request in the body.
let status = status.as_u16();
@@ -0,0 +1,62 @@
Subject: [PATCH 0016] braiins v26_04: single-flight auth + defensive get_data timeout
Round 17 R4 support. Braiins get_data fans out to ~12 authenticated REST calls
concurrently. Two hardening changes so a Braiins miner survives a busy scan:
- ensure_authenticated single-flights the login. Previously all ~12 concurrent
commands could see no token and each POST /auth/login -- a thundering herd that
doubled the connection load. Now the write lock is held across the login with a
double-check, so exactly one call authenticates and the rest reuse the token.
- The per-call timeout goes 5s -> 15s as defensive headroom (a healthy miner still
answers well under a second) so a call queued behind a scan burst completes
instead of dropping miner/stats.
Neither is the primary fix for the fleet-scan value dropout -- that is the
app-side scan concurrency cap (scan::SCAN_CONCURRENCY_LIMIT = 128), which keeps
the identification burst from starving these calls. These are the belt to that
suspenders. Verified live: a 10.4.1.0/24 scan now populates both Braiins corpus
miners (.27, .83) fully (watts, best-share, fw/control-board) and misses no
responders.
diff --git a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
index 3e06b682..ae433d98 100644
--- a/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
+++ b/vendor/asic-rs-firmwares-braiins/src/backends/v26_04/web.rs
@@ -87,7 +87,13 @@ impl BraiinsWebAPI {
client: OnceCell::new(),
ip,
port: 80,
- timeout: Duration::from_secs(5),
+ // Braiins get_data fans out to ~12 authenticated REST calls that run
+ // concurrently. A healthy miner answers well under a second; the extra
+ // headroom over the old 5 s is defensive so a call that queues behind a
+ // scan burst still completes instead of dropping miner/stats
+ // (hashrate/watts/best-share). The real fix for the fleet-scan dropout
+ // is the app-side scan concurrency cap (see scan::SCAN_CONCURRENCY_LIMIT).
+ timeout: Duration::from_secs(15),
bearer_token: RwLock::new(None),
auth,
}
@@ -122,13 +128,22 @@ impl BraiinsWebAPI {
return Ok(());
}
+ // Single-flight the login: get_data fires ~12 commands concurrently, and
+ // without this they would ALL see no token and each POST /auth/login (a
+ // thundering herd that doubles the connection load and races under a
+ // high-concurrency fleet scan, dropping most values). Hold the write lock
+ // across the login so exactly one call authenticates and the rest reuse it.
+ let mut guard = self.bearer_token.write().await;
+ if guard.is_some() {
+ return Ok(());
+ }
let token = match &self.auth {
MinerAuth::TokenAuth(token) => token.expose_secret().to_string(),
MinerAuth::UserAndPass(creds) => {
self.authenticate(creds.password.expose_secret()).await?
}
};
- *self.bearer_token.write().await = Some(token);
+ *guard = Some(token);
Ok(())
}
+74
View File
@@ -0,0 +1,74 @@
#!/usr/bin/env python3
"""Refresh the .cargo-checksum.json of vendored asic-rs crates after the patch
queue (thirdparty/asic-rs/patches/) has been applied to the cargo-vendored tree.
cargo verifies each vendored file against the per-file SHA256 in that crate's
.cargo-checksum.json; a patched file whose checksum is stale fails the build. For
every crate named on the command line (or, with --all, every asic-rs* crate under
vendor/), this recomputes the SHA256 of each file already listed in the manifest
and rewrites it, preserving the top-level "package"/"$comment" keys. Files not
listed are left alone (cargo only checks listed files).
Usage:
refresh-checksums.py <crate-dir> [<crate-dir> ...]
refresh-checksums.py --all # every vendor/asic-rs* crate
"""
import hashlib
import json
import sys
from pathlib import Path
REPO = Path(__file__).resolve().parents[2]
VENDOR = REPO / "vendor"
def sha256(path: Path) -> str:
h = hashlib.sha256()
with open(path, "rb") as f:
for chunk in iter(lambda: f.read(1 << 16), b""):
h.update(chunk)
return h.hexdigest()
def refresh(crate_dir: Path) -> int:
manifest = crate_dir / ".cargo-checksum.json"
if not manifest.exists():
print(f"skip {crate_dir.name}: no .cargo-checksum.json")
return 0
data = json.loads(manifest.read_text())
files = data.get("files", {})
changed = 0
for rel in list(files):
fp = crate_dir / rel
if not fp.exists():
print(f" WARN {crate_dir.name}: listed file missing: {rel}")
continue
new = sha256(fp)
if new != files[rel]:
files[rel] = new
changed += 1
if changed:
manifest.write_text(json.dumps(data, separators=(",", ":")))
print(f"{crate_dir.name}: refreshed {changed} checksum(s)")
else:
print(f"{crate_dir.name}: no changes")
return changed
def main() -> None:
args = sys.argv[1:]
if not args:
print(__doc__)
sys.exit(2)
if args == ["--all"]:
crates = sorted(p for p in VENDOR.glob("asic-rs*") if p.is_dir())
else:
crates = [Path(a) if Path(a).is_absolute() else (VENDOR / a) for a in args]
total = 0
for c in crates:
total += refresh(c)
print(f"done: {total} checksum(s) refreshed across {len(crates)} crate(s)")
if __name__ == "__main__":
main()
+351 -1
View File
@@ -10,7 +10,7 @@
+pub use widgets::*;
--- a/src/widgets.rs
+++ b/src/widgets.rs
@@ -0,0 +1,561 @@
@@ -0,0 +1,911 @@
+// widgets.rs — alkane-toolkit extension: Rust bindings for the widget bridge
+// in cpp_src/widgets_bridge.cpp. Handles are opaque pointers owned by the
+// wxWidgets object tree (parents own children; nothing to free in Rust).
@@ -28,6 +28,7 @@
+ pub fn wxbr_main_frame() -> *mut c_void;
+ pub fn wxbr_panel(parent: *mut c_void) -> *mut c_void;
+ pub fn wxbr_box_sizer(vertical: c_int) -> *mut c_void;
+ pub fn wxbr_wrap_sizer(vertical: c_int) -> *mut c_void;
+ pub fn wxbr_sizer_add(sizer: *mut c_void, win: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
+ pub fn wxbr_sizer_add_sizer(sizer: *mut c_void, subsizer: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
+ pub fn wxbr_sizer_add_spacer(sizer: *mut c_void, px: c_int);
@@ -35,17 +36,22 @@
+ pub fn wxbr_set_sizer(win: *mut c_void, sizer: *mut c_void);
+ pub fn wxbr_layout(win: *mut c_void);
+ pub fn wxbr_sizer_detach(sizer: *mut c_void, win: *mut c_void);
+ pub fn wxbr_sizer_show(sizer: *mut c_void, win: *mut c_void, show: c_int);
+ pub fn wxbr_bind_size(win: *mut c_void);
+ pub fn wxbr_fit(win: *mut c_void);
+ pub fn wxbr_set_min_size(win: *mut c_void, w: c_int, h: c_int);
+ pub fn wxbr_set_tooltip(win: *mut c_void, text: *const c_char);
+ pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
+ pub fn wxbr_set_label(win: *mut c_void, label: *const c_char);
+ pub fn wxbr_get_label(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_set_bold(win: *mut c_void);
+ pub fn wxbr_set_font_size(win: *mut c_void, pts: c_int);
+ pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
+ pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
+ pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
+ pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
+ pub fn wxbr_text_ctrl_write(win: *mut c_void, value: *const c_char);
+ pub fn wxbr_check_box(parent: *mut c_void, label: *const c_char) -> *mut c_void;
+ pub fn wxbr_check_box_get(win: *mut c_void) -> c_int;
+ pub fn wxbr_check_box_set(win: *mut c_void, v: c_int);
@@ -59,16 +65,22 @@
+ pub fn wxbr_dialog(parent: *mut c_void, title: *const c_char) -> *mut c_void;
+ pub fn wxbr_dialog_show_modal(win: *mut c_void) -> c_int;
+ pub fn wxbr_dialog_close(win: *mut c_void, code: c_int);
+ pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_save_file_dialog(parent: *mut c_void, title: *const c_char, default_name: *const c_char, wildcard: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
+ pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
+ pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
+ pub fn wxbr_dvlc_append_toggle_col(win: *mut c_void, width: c_int);
+ pub fn wxbr_dvlc_append_row(win: *mut c_void, nvals: c_int, vals: *const *const c_char);
+ pub fn wxbr_dvlc_delete_row(win: *mut c_void, row: usize);
+ pub fn wxbr_dvlc_clear(win: *mut c_void);
+ pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
+ pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
+ pub fn wxbr_dvlc_set_icon_tooltips(win: *mut c_void, row: usize, col: usize, joined: *const c_char);
+ pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
+ pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
+ pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
+ pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
@@ -77,12 +89,20 @@
+ pub fn wxbr_dvlc_get_selections(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
+ pub fn wxbr_dvlc_select_rows(win: *mut c_void, rows: *const c_int, n: c_int);
+ pub fn wxbr_dvlc_set_alt_row_color(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_dvlc_set_row_color(win: *mut c_void, row: usize, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
+ pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
+ pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
+ pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
+ pub fn wxbr_reorder_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
+ pub fn wxbr_reorder_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
+ pub fn wxbr_reorder_set_order(win: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char);
+ pub fn wxbr_menu_new() -> *mut c_void;
+ pub fn wxbr_menu_append(menu: *mut c_void, id: c_int, label: *const c_char);
+ pub fn wxbr_menu_append_separator(menu: *mut c_void);
+ pub fn wxbr_menu_append_submenu(menu: *mut c_void, label: *const c_char, submenu: *mut c_void);
+ pub fn wxbr_popup_menu(win: *mut c_void, menu: *mut c_void);
+ pub fn wxbr_timer(id: c_int, ms: c_int) -> *mut c_void;
+ pub fn wxbr_gauge(parent: *mut c_void, range: c_int) -> *mut c_void;
@@ -96,7 +116,24 @@
+ pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
+ pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_choice(parent: *mut c_void, id: c_int) -> *mut c_void;
+ pub fn wxbr_choice_append(win: *mut c_void, label: *const c_char);
+ pub fn wxbr_choice_clear(win: *mut c_void);
+ pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
+ pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
+ pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
+ pub fn wxbr_svg_icon(parent: *mut c_void, svg: *const c_char, w: c_int, h: c_int) -> *mut c_void;
+ pub fn wxbr_register_shape_svg(sentinel: c_int, svg: *const c_char, vbw: c_int, vbh: c_int);
+ pub fn wxbr_set_light_pulse(on: c_int);
+ pub fn wxbr_bind_sys_colour(win: *mut c_void);
+ pub fn wxbr_destroy(win: *mut c_void);
+ pub fn wxbr_destroy_children(win: *mut c_void);
+ pub fn wxbr_call_after(id: c_int);
+ pub fn wxbr_status_indicator_init(frame: *mut c_void);
+ pub fn wxbr_status_indicator_set(text: *const c_char, r: c_int, g: c_int, b: c_int);
+ pub fn wxbr_status_zoom_init(frame: *mut c_void);
+ pub fn wxbr_table_set_zoom(factor: f64);
+ pub fn wxbr_table_zoom_reapply();
+ }
+}
+
@@ -129,6 +166,12 @@
+ DvlcSelectionChanged,
+ DvlcContextMenu,
+ MenuItem,
+ ChoiceChanged,
+ SysColour,
+ Deferred,
+ DvlcHeaderRightClick,
+ /// Window resized; p1 = new client width, p2 = new client height.
+ Sized,
+}
+
+impl WxEventKind {
@@ -144,6 +187,11 @@
+ 9 => WxEventKind::DvlcSelectionChanged,
+ 10 => WxEventKind::DvlcContextMenu,
+ 11 => WxEventKind::MenuItem,
+ 12 => WxEventKind::ChoiceChanged,
+ 13 => WxEventKind::SysColour,
+ 14 => WxEventKind::Deferred,
+ 15 => WxEventKind::DvlcHeaderRightClick,
+ 16 => WxEventKind::Sized,
+ _ => return None,
+ })
+ }
@@ -154,6 +202,64 @@
+ unsafe { notsafe::wxbr_apply_zebra_css(r as c_int, g as c_int, b as c_int) }
+}
+
+/// Schedule a deferred action: a `Deferred` event carrying `id` is delivered
+/// from the event loop after the current event finishes. Use this to rebuild or
+/// destroy a control from outside its own event handler.
+pub fn call_after(id: i32) {
+ unsafe { notsafe::wxbr_call_after(id as c_int) }
+}
+
+/// Reconfigure the frame's status bar to two fields and attach a colour-tinted
+/// label pinned to the right-hand field (bottom-right corner). Call once after
+/// `create_status_bar()`. The main scan status keeps using the left field via
+/// the upstream `set_status_text` path.
+pub fn status_indicator_init(frame: Widget) {
+ unsafe { notsafe::wxbr_status_indicator_init(frame.0) }
+}
+
+/// Add the table-zoom slider + percent label to the frame's status bar (round 14
+/// #3). Call after the table exists so the slider can find it. The slider scales
+/// the table entirely in C++; no further Rust calls are needed.
+pub fn status_zoom_init(frame: Widget) {
+ unsafe { notsafe::wxbr_status_zoom_init(frame.0) }
+}
+
+/// Set the table zoom factor programmatically (1.0 = 100%); also moves the slider.
+pub fn table_set_zoom(factor: f64) {
+ unsafe { notsafe::wxbr_table_set_zoom(factor) }
+}
+
+/// Re-apply the current zoom after the table's columns are rebuilt, so a non-100%
+/// zoom survives a column show/hide/reorder (round 14 #3).
+pub fn table_zoom_reapply() {
+ unsafe { notsafe::wxbr_table_zoom_reapply() }
+}
+
+/// Set the bottom-right status indicator's text and colour (an empty string
+/// clears it). Used for scan/apply errors (red) and warnings (amber).
+pub fn status_indicator_set(text: &str, r: u8, g: u8, b: u8) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_status_indicator_set(c.as_ptr(), r as c_int, g as c_int, b as c_int) }
+}
+
+/// Register a raw SVG for a table-cell shape sentinel (a control-char code point)
+/// so the segment renderer can draw it recoloured to each cell's segment colour.
+/// `vbw`/`vbh` are the SVG viewBox dimensions, used to keep the icon's aspect
+/// ratio when it is rasterised at the cell height (round 12 #9/#11).
+pub fn register_shape_svg(sentinel: u32, svg: &str, vbw: i32, vbh: i32) {
+ let c = CString::new(svg).unwrap_or_default();
+ unsafe {
+ notsafe::wxbr_register_shape_svg(sentinel as c_int, c.as_ptr(), vbw as c_int, vbh as c_int)
+ }
+}
+
+/// Start (or stop) the locate-light dot fade animation. Call with `true` while at
+/// least one miner's locate light is flashing so the table repaint timer only
+/// runs when there is a pulsing dot to animate (round 12 #6).
+pub fn set_light_pulse(on: bool) {
+ unsafe { notsafe::wxbr_set_light_pulse(on as c_int) }
+}
+
+/// Open a URL in the system default browser. Returns true on success.
+pub fn launch_browser(url: &str) -> bool {
+ let c = CString::new(url).unwrap_or_default();
@@ -229,6 +335,14 @@
+ Widget(unsafe { notsafe::wxbr_box_sizer(vertical as c_int) })
+ }
+
+ /// A box sizer that wraps overflowing items onto additional lines instead
+ /// of shrinking them. wxWrapSizer is a wxBoxSizer subclass, so the result
+ /// accepts the same add/add_sizer/add_spacer/add_stretch/set_sizer_on
+ /// calls as `box_sizer`'s.
+ pub fn wrap_sizer(vertical: bool) -> Widget {
+ Widget(unsafe { notsafe::wxbr_wrap_sizer(vertical as c_int) })
+ }
+
+ pub fn add(&self, win: Widget, proportion: i32, flags: i32, border: i32) {
+ unsafe { notsafe::wxbr_sizer_add(self.0, win.0, proportion, flags, border) }
+ }
@@ -262,6 +376,18 @@
+ unsafe { notsafe::wxbr_sizer_detach(self.0, win.0) }
+ }
+
+ /// Show or hide a child window in this sizer (self = a sizer), reclaiming or
+ /// restoring its space on the next `layout()`.
+ pub fn sizer_show(&self, win: Widget, show: bool) {
+ unsafe { notsafe::wxbr_sizer_show(self.0, win.0, show as c_int) }
+ }
+
+ /// Emit `WxEventKind::Sized` (p1 = width, p2 = height) whenever this window
+ /// is resized.
+ pub fn bind_size(&self) {
+ unsafe { notsafe::wxbr_bind_size(self.0) }
+ }
+
+ pub fn fit(&self, win: Widget) {
+ unsafe { notsafe::wxbr_fit(win.0) }
+ }
@@ -270,6 +396,12 @@
+ unsafe { notsafe::wxbr_set_min_size(self.0, w, h) }
+ }
+
+ /// Attach a hover tooltip to this widget (round 15 #10). Empty clears it.
+ pub fn set_tool_tip(&self, text: &str) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_set_tooltip(self.0, c.as_ptr()) }
+ }
+
+ pub fn static_text(parent: Widget, label: &str) -> Widget {
+ let c = CString::new(label).unwrap_or_default();
+ Widget(unsafe { notsafe::wxbr_static_text(parent.0, c.as_ptr()) })
@@ -305,6 +437,15 @@
+ Widget(unsafe { notsafe::wxbr_button(parent.0, c.as_ptr(), id) })
+ }
+
+ /// Make this window clickable: a left mouse down on it emits the same
+ /// `ButtonClicked` event a real button would, carrying `id`. Bind each
+ /// child that should also count as part of the click target (e.g. the
+ /// static text labels on a KPI card), since a child window swallows its
+ /// own mouse events rather than letting them propagate to the parent.
+ pub fn bind_click(&self, id: i32) {
+ unsafe { notsafe::wxbr_bind_click(self.0, id) }
+ }
+
+ pub fn text_ctrl(parent: Widget, multiline: bool) -> Widget {
+ Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
+ }
@@ -322,6 +463,13 @@
+ unsafe { notsafe::wxbr_text_ctrl_set(self.0, c.as_ptr()) }
+ }
+
+ /// Insert `value` at the text control's cursor (replacing any selection),
+ /// rather than replacing the whole contents (round 15 #1).
+ pub fn write_text(&self, value: &str) {
+ let c = CString::new(value).unwrap_or_default();
+ unsafe { notsafe::wxbr_text_ctrl_write(self.0, c.as_ptr()) }
+ }
+
+ pub fn check_box(parent: Widget, label: &str) -> Widget {
+ let c = CString::new(label).unwrap_or_default();
+ Widget(unsafe { notsafe::wxbr_check_box(parent.0, c.as_ptr()) })
@@ -384,6 +532,51 @@
+ unsafe { notsafe::wxbr_dialog_close(self.0, code) }
+ }
+
+ /// Show a native "open file, must exist" dialog. Returns the chosen path,
+ /// or `None` if the dialog was cancelled.
+ pub fn file_dialog(parent: Widget, title: &str) -> Option<String> {
+ let c = CString::new(title).unwrap_or_default();
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
+ notsafe::wxbr_file_dialog(parent.0, c.as_ptr(), buf.as_mut_ptr(), buf.len() as c_int)
+ };
+ if n <= 0 {
+ return None;
+ }
+ let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
+ Some(String::from_utf8_lossy(&bytes).into_owned())
+ }
+
+ /// Save-file dialog (round 15 #14): returns the chosen path, or None if
+ /// cancelled. `default_name` prefills the filename; `wildcard` is a wx filter
+ /// string like "CSV files (*.csv)|*.csv".
+ pub fn save_file_dialog(
+ parent: Widget,
+ title: &str,
+ default_name: &str,
+ wildcard: &str,
+ ) -> Option<String> {
+ let t = CString::new(title).unwrap_or_default();
+ let d = CString::new(default_name).unwrap_or_default();
+ let w = CString::new(wildcard).unwrap_or_default();
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
+ notsafe::wxbr_save_file_dialog(
+ parent.0,
+ t.as_ptr(),
+ d.as_ptr(),
+ w.as_ptr(),
+ buf.as_mut_ptr(),
+ buf.len() as c_int,
+ )
+ };
+ if n <= 0 {
+ return None;
+ }
+ let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
+ Some(String::from_utf8_lossy(&bytes).into_owned())
+ }
+
+ // ---- data view list ctrl ----
+
+ pub fn dvlc(parent: Widget) -> Widget {
@@ -395,6 +588,14 @@
+ unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
+ }
+
+ /// Like `dvlc_append_text_col`, but the column renders cell values through
+ /// the SegmentRenderer, so a value built with `model::encode_segments` is
+ /// drawn as coloured text runs (a plain string still renders normally).
+ pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool) {
+ let c = CString::new(title).unwrap_or_default();
+ unsafe { notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int) };
+ }
+
+ pub fn dvlc_append_toggle_col(&self, width: i32) {
+ unsafe { notsafe::wxbr_dvlc_append_toggle_col(self.0, width) }
+ }
@@ -422,6 +623,22 @@
+ unsafe { notsafe::wxbr_dvlc_set_cell(self.0, row, col, c.as_ptr()) }
+ }
+
+ /// Set the hover tooltip for one cell (empty clears it). GTK only; a no-op
+ /// on other platforms until they gain per-cell tooltip support.
+ pub fn dvlc_set_cell_tooltip(&self, row: usize, col: usize, text: &str) {
+ let c = CString::new(text).unwrap_or_default();
+ unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
+ }
+
+ /// Set per-icon hover tooltips for a cell (round 15 #15): one tooltip per icon
+ /// in draw order. The bridge shows the one under the pointer. Passing an empty
+ /// slice clears them.
+ pub fn dvlc_set_icon_tooltips(&self, row: usize, col: usize, tips: &[String]) {
+ let joined = tips.join("\u{1f}");
+ let c = CString::new(joined).unwrap_or_default();
+ unsafe { notsafe::wxbr_dvlc_set_icon_tooltips(self.0, row, col, c.as_ptr()) }
+ }
+
+ pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
+ let mut buf = vec![0i8; 4096];
+ let n = unsafe {
@@ -438,6 +655,11 @@
+ unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
+ }
+
+ /// Auto-size the column at display position `pos` to fit its content.
+ pub fn dvlc_autosize_col(&self, pos: usize) {
+ unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
+ }
+
+ /// Model column index shown at display position `pos` (after drag reorder).
+ pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
+ let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
@@ -472,6 +694,36 @@
+ unsafe { notsafe::wxbr_dvlc_set_alt_row_color(self.0, r as c_int, g as c_int, b as c_int) }
+ }
+
+ /// Set a row's text colour (e.g. by miner status). Pass `None` to clear it.
+ pub fn dvlc_set_row_color(&self, row: usize, color: Option<(u8, u8, u8)>) {
+ let (r, g, b) = match color {
+ Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
+ None => (-1, -1, -1),
+ };
+ unsafe { notsafe::wxbr_dvlc_set_row_color(self.0, row, r, g, b) }
+ }
+
+ /// Set the alternating-row (zebra) background colour applied to odd rows.
+ /// Pass `None` to turn zebra striping off.
+ pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
+ let (r, g, b) = match color {
+ Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
+ None => (-1, -1, -1),
+ };
+ unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
+ }
+
+ /// The model-row index of the top (first visible) row, or `None` if empty.
+ pub fn dvlc_get_top_row(&self) -> Option<usize> {
+ let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
+ (r >= 0).then_some(r as usize)
+ }
+
+ /// Scroll so `row` is visible (used to restore scroll position after a refill).
+ pub fn dvlc_ensure_visible(&self, row: usize) {
+ unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
+ }
+
+ // ---- rearrangeable check-list ----
+
+ /// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
@@ -493,6 +745,38 @@
+ buf.into_iter().take(n.max(0) as usize).collect()
+ }
+
+ /// A checkable, multi-select, drag-reorderable column list (round 11 #4):
+ /// like `rearrange_list` but with no up/down buttons -- rows are reordered by
+ /// dragging, and selected with shift/ctrl-click or a rubber-band drag. Same
+ /// `[idx | !idx]` order encoding.
+ pub fn reorder_list(parent: Widget, order: &[i32], items: &[&str]) -> Widget {
+ let cs: Vec<CString> = items.iter().map(|s| CString::new(*s).unwrap_or_default()).collect();
+ let ptrs: Vec<*const c_char> = cs.iter().map(|c| c.as_ptr()).collect();
+ Widget(unsafe {
+ notsafe::wxbr_reorder_list(parent.0, items.len() as c_int, order.as_ptr(), ptrs.as_ptr())
+ })
+ }
+
+ /// Read back the current order from a `reorder_list` (same encoding).
+ pub fn reorder_get_order(&self) -> Vec<i32> {
+ let mut buf = vec![0i32; 4096];
+ let n = unsafe {
+ notsafe::wxbr_reorder_get_order(self.0, buf.as_mut_ptr(), buf.len() as c_int)
+ };
+ buf.into_iter().take(n.max(0) as usize).collect()
+ }
+
+ /// Repopulate a `reorder_list` in a new order (same `[idx | !idx]` encoding
+ /// and same base-index `items` array as `reorder_list`). Used by the column
+ /// picker's Alphabetical / Categories sort buttons.
+ pub fn reorder_set_order(&self, order: &[i32], items: &[&str]) {
+ let cs: Vec<CString> = items.iter().map(|s| CString::new(*s).unwrap_or_default()).collect();
+ let ptrs: Vec<*const c_char> = cs.iter().map(|c| c.as_ptr()).collect();
+ unsafe {
+ notsafe::wxbr_reorder_set_order(self.0, items.len() as c_int, order.as_ptr(), ptrs.as_ptr())
+ }
+ }
+
+ // ---- popup menu ----
+
+ pub fn menu_new() -> Widget {
@@ -508,6 +792,13 @@
+ unsafe { notsafe::wxbr_menu_append_separator(self.0) }
+ }
+
+ /// Append `submenu` under this menu with `label` (round 15 #13). This menu
+ /// takes ownership of the submenu.
+ pub fn menu_append_submenu(&self, label: &str, submenu: Widget) {
+ let c = CString::new(label).unwrap_or_default();
+ unsafe { notsafe::wxbr_menu_append_submenu(self.0, c.as_ptr(), submenu.0) }
+ }
+
+ /// Show `menu` as a popup on this window; blocks until dismissed.
+ pub fn popup_menu(&self, menu: Widget) {
+ unsafe { notsafe::wxbr_popup_menu(self.0, menu.0) }
@@ -566,9 +857,68 @@
+ unsafe { notsafe::wxbr_set_fg(self.0, r as c_int, g as c_int, b as c_int) }
+ }
+
+ // ---- choice (dropdown) ----
+
+ /// Create a dropdown; selection changes emit `ChoiceChanged` with this id.
+ pub fn choice(parent: Widget, id: i32) -> Widget {
+ Widget(unsafe { notsafe::wxbr_choice(parent.0, id) })
+ }
+
+ pub fn choice_append(&self, label: &str) {
+ let c = CString::new(label).unwrap_or_default();
+ unsafe { notsafe::wxbr_choice_append(self.0, c.as_ptr()) }
+ }
+
+ pub fn choice_clear(&self) {
+ unsafe { notsafe::wxbr_choice_clear(self.0) }
+ }
+
+ pub fn choice_get_selection(&self) -> i32 {
+ unsafe { notsafe::wxbr_choice_get_selection(self.0) }
+ }
+
+ pub fn choice_set_selection(&self, i: i32) {
+ unsafe { notsafe::wxbr_choice_set_selection(self.0, i) }
+ }
+
+ // ---- media (icon) button ----
+
+ /// A coloured icon button: `kind` 0=play, 1=pause, 2=stop. Clicks emit
+ /// `ButtonClicked` with `id`, like a normal button.
+ pub fn media_button(parent: Widget, id: i32, kind: i32, color: (u8, u8, u8)) -> Widget {
+ Widget(unsafe {
+ notsafe::wxbr_media_button(
+ parent.0,
+ id,
+ kind,
+ color.0 as c_int,
+ color.1 as c_int,
+ color.2 as c_int,
+ )
+ })
+ }
+
+ /// Render an SVG string (recolour it first -- its fill must be an explicit
+ /// colour, not "currentColor") into a static-bitmap icon at `w`x`h` px
+ /// (round 11 #15).
+ pub fn svg_icon(parent: Widget, svg: &str, w: i32, h: i32) -> Widget {
+ let c = CString::new(svg).unwrap_or_default();
+ Widget(unsafe { notsafe::wxbr_svg_icon(parent.0, c.as_ptr(), w as c_int, h as c_int) })
+ }
+
+ /// Listen for OS light/dark theme changes on this window (emits `SysColour`).
+ pub fn bind_sys_colour(&self) {
+ unsafe { notsafe::wxbr_bind_sys_colour(self.0) }
+ }
+
+ /// Deferred destruction (safe from event handlers); used to rebuild
+ /// the table when its column set changes.
+ pub fn destroy(&self) {
+ unsafe { notsafe::wxbr_destroy(self.0) }
+ }
+
+ /// Destroy this window's children (to rebuild dynamic panel contents).
+ pub fn destroy_children(&self) {
+ unsafe { notsafe::wxbr_destroy_children(self.0) }
+ }
+}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+350
View File
@@ -15,6 +15,7 @@ mod notsafe {
pub fn wxbr_main_frame() -> *mut c_void;
pub fn wxbr_panel(parent: *mut c_void) -> *mut c_void;
pub fn wxbr_box_sizer(vertical: c_int) -> *mut c_void;
pub fn wxbr_wrap_sizer(vertical: c_int) -> *mut c_void;
pub fn wxbr_sizer_add(sizer: *mut c_void, win: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
pub fn wxbr_sizer_add_sizer(sizer: *mut c_void, subsizer: *mut c_void, proportion: c_int, flags: c_int, border: c_int);
pub fn wxbr_sizer_add_spacer(sizer: *mut c_void, px: c_int);
@@ -22,17 +23,22 @@ mod notsafe {
pub fn wxbr_set_sizer(win: *mut c_void, sizer: *mut c_void);
pub fn wxbr_layout(win: *mut c_void);
pub fn wxbr_sizer_detach(sizer: *mut c_void, win: *mut c_void);
pub fn wxbr_sizer_show(sizer: *mut c_void, win: *mut c_void, show: c_int);
pub fn wxbr_bind_size(win: *mut c_void);
pub fn wxbr_fit(win: *mut c_void);
pub fn wxbr_set_min_size(win: *mut c_void, w: c_int, h: c_int);
pub fn wxbr_set_tooltip(win: *mut c_void, text: *const c_char);
pub fn wxbr_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
pub fn wxbr_set_label(win: *mut c_void, label: *const c_char);
pub fn wxbr_get_label(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_set_bold(win: *mut c_void);
pub fn wxbr_set_font_size(win: *mut c_void, pts: c_int);
pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
pub fn wxbr_text_ctrl_write(win: *mut c_void, value: *const c_char);
pub fn wxbr_check_box(parent: *mut c_void, label: *const c_char) -> *mut c_void;
pub fn wxbr_check_box_get(win: *mut c_void) -> c_int;
pub fn wxbr_check_box_set(win: *mut c_void, v: c_int);
@@ -46,16 +52,22 @@ mod notsafe {
pub fn wxbr_dialog(parent: *mut c_void, title: *const c_char) -> *mut c_void;
pub fn wxbr_dialog_show_modal(win: *mut c_void) -> c_int;
pub fn wxbr_dialog_close(win: *mut c_void, code: c_int);
pub fn wxbr_file_dialog(parent: *mut c_void, title: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_save_file_dialog(parent: *mut c_void, title: *const c_char, default_name: *const c_char, wildcard: *const c_char, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc(parent: *mut c_void) -> *mut c_void;
pub fn wxbr_dvlc_append_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int);
pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int) -> *mut c_void;
pub fn wxbr_dvlc_append_toggle_col(win: *mut c_void, width: c_int);
pub fn wxbr_dvlc_append_row(win: *mut c_void, nvals: c_int, vals: *const *const c_char);
pub fn wxbr_dvlc_delete_row(win: *mut c_void, row: usize);
pub fn wxbr_dvlc_clear(win: *mut c_void);
pub fn wxbr_dvlc_row_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_set_cell(win: *mut c_void, row: usize, col: usize, value: *const c_char);
pub fn wxbr_dvlc_set_cell_tooltip(win: *mut c_void, row: usize, col: usize, text: *const c_char);
pub fn wxbr_dvlc_set_icon_tooltips(win: *mut c_void, row: usize, col: usize, joined: *const c_char);
pub fn wxbr_dvlc_get_cell(win: *mut c_void, row: usize, col: usize, buf: *mut c_char, cap: c_int) -> c_int;
pub fn wxbr_dvlc_col_count(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_autosize_col(win: *mut c_void, pos: c_int);
pub fn wxbr_dvlc_set_col_title(win: *mut c_void, col: c_int, title: *const c_char);
pub fn wxbr_dvlc_set_sort_indicator(win: *mut c_void, col: c_int, active: c_int, ascending: c_int);
pub fn wxbr_dvlc_col_at_pos(win: *mut c_void, pos: c_int) -> c_int;
@@ -64,12 +76,20 @@ mod notsafe {
pub fn wxbr_dvlc_get_selections(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
pub fn wxbr_dvlc_select_rows(win: *mut c_void, rows: *const c_int, n: c_int);
pub fn wxbr_dvlc_set_alt_row_color(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_dvlc_set_row_color(win: *mut c_void, row: usize, r: c_int, g: c_int, b: c_int);
pub fn wxbr_dvlc_set_zebra(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_dvlc_get_top_row(win: *mut c_void) -> c_int;
pub fn wxbr_dvlc_ensure_visible(win: *mut c_void, row: usize);
pub fn wxbr_apply_zebra_css(r: c_int, g: c_int, b: c_int);
pub fn wxbr_rearrange_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
pub fn wxbr_rearrange_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
pub fn wxbr_reorder_list(parent: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char) -> *mut c_void;
pub fn wxbr_reorder_get_order(win: *mut c_void, buf: *mut c_int, cap: c_int) -> c_int;
pub fn wxbr_reorder_set_order(win: *mut c_void, n: c_int, order: *const c_int, items: *const *const c_char);
pub fn wxbr_menu_new() -> *mut c_void;
pub fn wxbr_menu_append(menu: *mut c_void, id: c_int, label: *const c_char);
pub fn wxbr_menu_append_separator(menu: *mut c_void);
pub fn wxbr_menu_append_submenu(menu: *mut c_void, label: *const c_char, submenu: *mut c_void);
pub fn wxbr_popup_menu(win: *mut c_void, menu: *mut c_void);
pub fn wxbr_timer(id: c_int, ms: c_int) -> *mut c_void;
pub fn wxbr_gauge(parent: *mut c_void, range: c_int) -> *mut c_void;
@@ -83,7 +103,24 @@ mod notsafe {
pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
pub fn wxbr_choice(parent: *mut c_void, id: c_int) -> *mut c_void;
pub fn wxbr_choice_append(win: *mut c_void, label: *const c_char);
pub fn wxbr_choice_clear(win: *mut c_void);
pub fn wxbr_choice_get_selection(win: *mut c_void) -> c_int;
pub fn wxbr_choice_set_selection(win: *mut c_void, i: c_int);
pub fn wxbr_media_button(parent: *mut c_void, id: c_int, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
pub fn wxbr_svg_icon(parent: *mut c_void, svg: *const c_char, w: c_int, h: c_int) -> *mut c_void;
pub fn wxbr_register_shape_svg(sentinel: c_int, svg: *const c_char, vbw: c_int, vbh: c_int);
pub fn wxbr_set_light_pulse(on: c_int);
pub fn wxbr_bind_sys_colour(win: *mut c_void);
pub fn wxbr_destroy(win: *mut c_void);
pub fn wxbr_destroy_children(win: *mut c_void);
pub fn wxbr_call_after(id: c_int);
pub fn wxbr_status_indicator_init(frame: *mut c_void);
pub fn wxbr_status_indicator_set(text: *const c_char, r: c_int, g: c_int, b: c_int);
pub fn wxbr_status_zoom_init(frame: *mut c_void);
pub fn wxbr_table_set_zoom(factor: f64);
pub fn wxbr_table_zoom_reapply();
}
}
@@ -116,6 +153,12 @@ pub enum WxEventKind {
DvlcSelectionChanged,
DvlcContextMenu,
MenuItem,
ChoiceChanged,
SysColour,
Deferred,
DvlcHeaderRightClick,
/// Window resized; p1 = new client width, p2 = new client height.
Sized,
}
impl WxEventKind {
@@ -131,6 +174,11 @@ impl WxEventKind {
9 => WxEventKind::DvlcSelectionChanged,
10 => WxEventKind::DvlcContextMenu,
11 => WxEventKind::MenuItem,
12 => WxEventKind::ChoiceChanged,
13 => WxEventKind::SysColour,
14 => WxEventKind::Deferred,
15 => WxEventKind::DvlcHeaderRightClick,
16 => WxEventKind::Sized,
_ => return None,
})
}
@@ -141,6 +189,64 @@ pub fn apply_zebra_css(r: u8, g: u8, b: u8) {
unsafe { notsafe::wxbr_apply_zebra_css(r as c_int, g as c_int, b as c_int) }
}
/// Schedule a deferred action: a `Deferred` event carrying `id` is delivered
/// from the event loop after the current event finishes. Use this to rebuild or
/// destroy a control from outside its own event handler.
pub fn call_after(id: i32) {
unsafe { notsafe::wxbr_call_after(id as c_int) }
}
/// Reconfigure the frame's status bar to two fields and attach a colour-tinted
/// label pinned to the right-hand field (bottom-right corner). Call once after
/// `create_status_bar()`. The main scan status keeps using the left field via
/// the upstream `set_status_text` path.
pub fn status_indicator_init(frame: Widget) {
unsafe { notsafe::wxbr_status_indicator_init(frame.0) }
}
/// Add the table-zoom slider + percent label to the frame's status bar (round 14
/// #3). Call after the table exists so the slider can find it. The slider scales
/// the table entirely in C++; no further Rust calls are needed.
pub fn status_zoom_init(frame: Widget) {
unsafe { notsafe::wxbr_status_zoom_init(frame.0) }
}
/// Set the table zoom factor programmatically (1.0 = 100%); also moves the slider.
pub fn table_set_zoom(factor: f64) {
unsafe { notsafe::wxbr_table_set_zoom(factor) }
}
/// Re-apply the current zoom after the table's columns are rebuilt, so a non-100%
/// zoom survives a column show/hide/reorder (round 14 #3).
pub fn table_zoom_reapply() {
unsafe { notsafe::wxbr_table_zoom_reapply() }
}
/// Set the bottom-right status indicator's text and colour (an empty string
/// clears it). Used for scan/apply errors (red) and warnings (amber).
pub fn status_indicator_set(text: &str, r: u8, g: u8, b: u8) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_status_indicator_set(c.as_ptr(), r as c_int, g as c_int, b as c_int) }
}
/// Register a raw SVG for a table-cell shape sentinel (a control-char code point)
/// so the segment renderer can draw it recoloured to each cell's segment colour.
/// `vbw`/`vbh` are the SVG viewBox dimensions, used to keep the icon's aspect
/// ratio when it is rasterised at the cell height (round 12 #9/#11).
pub fn register_shape_svg(sentinel: u32, svg: &str, vbw: i32, vbh: i32) {
let c = CString::new(svg).unwrap_or_default();
unsafe {
notsafe::wxbr_register_shape_svg(sentinel as c_int, c.as_ptr(), vbw as c_int, vbh as c_int)
}
}
/// Start (or stop) the locate-light dot fade animation. Call with `true` while at
/// least one miner's locate light is flashing so the table repaint timer only
/// runs when there is a pulsing dot to animate (round 12 #6).
pub fn set_light_pulse(on: bool) {
unsafe { notsafe::wxbr_set_light_pulse(on as c_int) }
}
/// Open a URL in the system default browser. Returns true on success.
pub fn launch_browser(url: &str) -> bool {
let c = CString::new(url).unwrap_or_default();
@@ -216,6 +322,14 @@ impl Widget {
Widget(unsafe { notsafe::wxbr_box_sizer(vertical as c_int) })
}
/// A box sizer that wraps overflowing items onto additional lines instead
/// of shrinking them. wxWrapSizer is a wxBoxSizer subclass, so the result
/// accepts the same add/add_sizer/add_spacer/add_stretch/set_sizer_on
/// calls as `box_sizer`'s.
pub fn wrap_sizer(vertical: bool) -> Widget {
Widget(unsafe { notsafe::wxbr_wrap_sizer(vertical as c_int) })
}
pub fn add(&self, win: Widget, proportion: i32, flags: i32, border: i32) {
unsafe { notsafe::wxbr_sizer_add(self.0, win.0, proportion, flags, border) }
}
@@ -249,6 +363,18 @@ impl Widget {
unsafe { notsafe::wxbr_sizer_detach(self.0, win.0) }
}
/// Show or hide a child window in this sizer (self = a sizer), reclaiming or
/// restoring its space on the next `layout()`.
pub fn sizer_show(&self, win: Widget, show: bool) {
unsafe { notsafe::wxbr_sizer_show(self.0, win.0, show as c_int) }
}
/// Emit `WxEventKind::Sized` (p1 = width, p2 = height) whenever this window
/// is resized.
pub fn bind_size(&self) {
unsafe { notsafe::wxbr_bind_size(self.0) }
}
pub fn fit(&self, win: Widget) {
unsafe { notsafe::wxbr_fit(win.0) }
}
@@ -257,6 +383,12 @@ impl Widget {
unsafe { notsafe::wxbr_set_min_size(self.0, w, h) }
}
/// Attach a hover tooltip to this widget (round 15 #10). Empty clears it.
pub fn set_tool_tip(&self, text: &str) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_set_tooltip(self.0, c.as_ptr()) }
}
pub fn static_text(parent: Widget, label: &str) -> Widget {
let c = CString::new(label).unwrap_or_default();
Widget(unsafe { notsafe::wxbr_static_text(parent.0, c.as_ptr()) })
@@ -292,6 +424,15 @@ impl Widget {
Widget(unsafe { notsafe::wxbr_button(parent.0, c.as_ptr(), id) })
}
/// Make this window clickable: a left mouse down on it emits the same
/// `ButtonClicked` event a real button would, carrying `id`. Bind each
/// child that should also count as part of the click target (e.g. the
/// static text labels on a KPI card), since a child window swallows its
/// own mouse events rather than letting them propagate to the parent.
pub fn bind_click(&self, id: i32) {
unsafe { notsafe::wxbr_bind_click(self.0, id) }
}
pub fn text_ctrl(parent: Widget, multiline: bool) -> Widget {
Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
}
@@ -309,6 +450,13 @@ impl Widget {
unsafe { notsafe::wxbr_text_ctrl_set(self.0, c.as_ptr()) }
}
/// Insert `value` at the text control's cursor (replacing any selection),
/// rather than replacing the whole contents (round 15 #1).
pub fn write_text(&self, value: &str) {
let c = CString::new(value).unwrap_or_default();
unsafe { notsafe::wxbr_text_ctrl_write(self.0, c.as_ptr()) }
}
pub fn check_box(parent: Widget, label: &str) -> Widget {
let c = CString::new(label).unwrap_or_default();
Widget(unsafe { notsafe::wxbr_check_box(parent.0, c.as_ptr()) })
@@ -371,6 +519,51 @@ impl Widget {
unsafe { notsafe::wxbr_dialog_close(self.0, code) }
}
/// Show a native "open file, must exist" dialog. Returns the chosen path,
/// or `None` if the dialog was cancelled.
pub fn file_dialog(parent: Widget, title: &str) -> Option<String> {
let c = CString::new(title).unwrap_or_default();
let mut buf = vec![0i8; 4096];
let n = unsafe {
notsafe::wxbr_file_dialog(parent.0, c.as_ptr(), buf.as_mut_ptr(), buf.len() as c_int)
};
if n <= 0 {
return None;
}
let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
Some(String::from_utf8_lossy(&bytes).into_owned())
}
/// Save-file dialog (round 15 #14): returns the chosen path, or None if
/// cancelled. `default_name` prefills the filename; `wildcard` is a wx filter
/// string like "CSV files (*.csv)|*.csv".
pub fn save_file_dialog(
parent: Widget,
title: &str,
default_name: &str,
wildcard: &str,
) -> Option<String> {
let t = CString::new(title).unwrap_or_default();
let d = CString::new(default_name).unwrap_or_default();
let w = CString::new(wildcard).unwrap_or_default();
let mut buf = vec![0i8; 4096];
let n = unsafe {
notsafe::wxbr_save_file_dialog(
parent.0,
t.as_ptr(),
d.as_ptr(),
w.as_ptr(),
buf.as_mut_ptr(),
buf.len() as c_int,
)
};
if n <= 0 {
return None;
}
let bytes: Vec<u8> = buf[..(n - 1) as usize].iter().map(|&b| b as u8).collect();
Some(String::from_utf8_lossy(&bytes).into_owned())
}
// ---- data view list ctrl ----
pub fn dvlc(parent: Widget) -> Widget {
@@ -382,6 +575,14 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
}
/// Like `dvlc_append_text_col`, but the column renders cell values through
/// the SegmentRenderer, so a value built with `model::encode_segments` is
/// drawn as coloured text runs (a plain string still renders normally).
pub fn dvlc_append_colored_col(&self, title: &str, width: i32, reorderable: bool) {
let c = CString::new(title).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_append_colored_col(self.0, c.as_ptr(), width, reorderable as c_int) };
}
pub fn dvlc_append_toggle_col(&self, width: i32) {
unsafe { notsafe::wxbr_dvlc_append_toggle_col(self.0, width) }
}
@@ -409,6 +610,22 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_set_cell(self.0, row, col, c.as_ptr()) }
}
/// Set the hover tooltip for one cell (empty clears it). GTK only; a no-op
/// on other platforms until they gain per-cell tooltip support.
pub fn dvlc_set_cell_tooltip(&self, row: usize, col: usize, text: &str) {
let c = CString::new(text).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_set_cell_tooltip(self.0, row, col, c.as_ptr()) }
}
/// Set per-icon hover tooltips for a cell (round 15 #15): one tooltip per icon
/// in draw order. The bridge shows the one under the pointer. Passing an empty
/// slice clears them.
pub fn dvlc_set_icon_tooltips(&self, row: usize, col: usize, tips: &[String]) {
let joined = tips.join("\u{1f}");
let c = CString::new(joined).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_set_icon_tooltips(self.0, row, col, c.as_ptr()) }
}
pub fn dvlc_get_cell(&self, row: usize, col: usize) -> Option<String> {
let mut buf = vec![0i8; 4096];
let n = unsafe {
@@ -425,6 +642,11 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_col_count(self.0).max(0) as usize }
}
/// Auto-size the column at display position `pos` to fit its content.
pub fn dvlc_autosize_col(&self, pos: usize) {
unsafe { notsafe::wxbr_dvlc_autosize_col(self.0, pos as c_int) }
}
/// Model column index shown at display position `pos` (after drag reorder).
pub fn dvlc_col_at_pos(&self, pos: usize) -> Option<usize> {
let v = unsafe { notsafe::wxbr_dvlc_col_at_pos(self.0, pos as c_int) };
@@ -459,6 +681,36 @@ impl Widget {
unsafe { notsafe::wxbr_dvlc_set_alt_row_color(self.0, r as c_int, g as c_int, b as c_int) }
}
/// Set a row's text colour (e.g. by miner status). Pass `None` to clear it.
pub fn dvlc_set_row_color(&self, row: usize, color: Option<(u8, u8, u8)>) {
let (r, g, b) = match color {
Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
None => (-1, -1, -1),
};
unsafe { notsafe::wxbr_dvlc_set_row_color(self.0, row, r, g, b) }
}
/// Set the alternating-row (zebra) background colour applied to odd rows.
/// Pass `None` to turn zebra striping off.
pub fn dvlc_set_zebra(&self, color: Option<(u8, u8, u8)>) {
let (r, g, b) = match color {
Some((r, g, b)) => (r as c_int, g as c_int, b as c_int),
None => (-1, -1, -1),
};
unsafe { notsafe::wxbr_dvlc_set_zebra(self.0, r, g, b) }
}
/// The model-row index of the top (first visible) row, or `None` if empty.
pub fn dvlc_get_top_row(&self) -> Option<usize> {
let r = unsafe { notsafe::wxbr_dvlc_get_top_row(self.0) };
(r >= 0).then_some(r as usize)
}
/// Scroll so `row` is visible (used to restore scroll position after a refill).
pub fn dvlc_ensure_visible(&self, row: usize) {
unsafe { notsafe::wxbr_dvlc_ensure_visible(self.0, row) }
}
// ---- rearrangeable check-list ----
/// Create a rearrangeable checklist. `order` uses wx encoding: a value `v`
@@ -480,6 +732,38 @@ impl Widget {
buf.into_iter().take(n.max(0) as usize).collect()
}
/// A checkable, multi-select, drag-reorderable column list (round 11 #4):
/// like `rearrange_list` but with no up/down buttons -- rows are reordered by
/// dragging, and selected with shift/ctrl-click or a rubber-band drag. Same
/// `[idx | !idx]` order encoding.
pub fn reorder_list(parent: Widget, order: &[i32], items: &[&str]) -> Widget {
let cs: Vec<CString> = items.iter().map(|s| CString::new(*s).unwrap_or_default()).collect();
let ptrs: Vec<*const c_char> = cs.iter().map(|c| c.as_ptr()).collect();
Widget(unsafe {
notsafe::wxbr_reorder_list(parent.0, items.len() as c_int, order.as_ptr(), ptrs.as_ptr())
})
}
/// Read back the current order from a `reorder_list` (same encoding).
pub fn reorder_get_order(&self) -> Vec<i32> {
let mut buf = vec![0i32; 4096];
let n = unsafe {
notsafe::wxbr_reorder_get_order(self.0, buf.as_mut_ptr(), buf.len() as c_int)
};
buf.into_iter().take(n.max(0) as usize).collect()
}
/// Repopulate a `reorder_list` in a new order (same `[idx | !idx]` encoding
/// and same base-index `items` array as `reorder_list`). Used by the column
/// picker's Alphabetical / Categories sort buttons.
pub fn reorder_set_order(&self, order: &[i32], items: &[&str]) {
let cs: Vec<CString> = items.iter().map(|s| CString::new(*s).unwrap_or_default()).collect();
let ptrs: Vec<*const c_char> = cs.iter().map(|c| c.as_ptr()).collect();
unsafe {
notsafe::wxbr_reorder_set_order(self.0, items.len() as c_int, order.as_ptr(), ptrs.as_ptr())
}
}
// ---- popup menu ----
pub fn menu_new() -> Widget {
@@ -495,6 +779,13 @@ impl Widget {
unsafe { notsafe::wxbr_menu_append_separator(self.0) }
}
/// Append `submenu` under this menu with `label` (round 15 #13). This menu
/// takes ownership of the submenu.
pub fn menu_append_submenu(&self, label: &str, submenu: Widget) {
let c = CString::new(label).unwrap_or_default();
unsafe { notsafe::wxbr_menu_append_submenu(self.0, c.as_ptr(), submenu.0) }
}
/// Show `menu` as a popup on this window; blocks until dismissed.
pub fn popup_menu(&self, menu: Widget) {
unsafe { notsafe::wxbr_popup_menu(self.0, menu.0) }
@@ -553,9 +844,68 @@ impl Widget {
unsafe { notsafe::wxbr_set_fg(self.0, r as c_int, g as c_int, b as c_int) }
}
// ---- choice (dropdown) ----
/// Create a dropdown; selection changes emit `ChoiceChanged` with this id.
pub fn choice(parent: Widget, id: i32) -> Widget {
Widget(unsafe { notsafe::wxbr_choice(parent.0, id) })
}
pub fn choice_append(&self, label: &str) {
let c = CString::new(label).unwrap_or_default();
unsafe { notsafe::wxbr_choice_append(self.0, c.as_ptr()) }
}
pub fn choice_clear(&self) {
unsafe { notsafe::wxbr_choice_clear(self.0) }
}
pub fn choice_get_selection(&self) -> i32 {
unsafe { notsafe::wxbr_choice_get_selection(self.0) }
}
pub fn choice_set_selection(&self, i: i32) {
unsafe { notsafe::wxbr_choice_set_selection(self.0, i) }
}
// ---- media (icon) button ----
/// A coloured icon button: `kind` 0=play, 1=pause, 2=stop. Clicks emit
/// `ButtonClicked` with `id`, like a normal button.
pub fn media_button(parent: Widget, id: i32, kind: i32, color: (u8, u8, u8)) -> Widget {
Widget(unsafe {
notsafe::wxbr_media_button(
parent.0,
id,
kind,
color.0 as c_int,
color.1 as c_int,
color.2 as c_int,
)
})
}
/// Render an SVG string (recolour it first -- its fill must be an explicit
/// colour, not "currentColor") into a static-bitmap icon at `w`x`h` px
/// (round 11 #15).
pub fn svg_icon(parent: Widget, svg: &str, w: i32, h: i32) -> Widget {
let c = CString::new(svg).unwrap_or_default();
Widget(unsafe { notsafe::wxbr_svg_icon(parent.0, c.as_ptr(), w as c_int, h as c_int) })
}
/// Listen for OS light/dark theme changes on this window (emits `SysColour`).
pub fn bind_sys_colour(&self) {
unsafe { notsafe::wxbr_bind_sys_colour(self.0) }
}
/// Deferred destruction (safe from event handlers); used to rebuild
/// the table when its column set changes.
pub fn destroy(&self) {
unsafe { notsafe::wxbr_destroy(self.0) }
}
/// Destroy this window's children (to rebuild dynamic panel contents).
pub fn destroy_children(&self) {
unsafe { notsafe::wxbr_destroy_children(self.0) }
}
}
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"eceda61bfe623493964bda3f6164cdb376be0f1112102dd2895524728fca33de","src/backends/v2020/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2020/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"8cf8031c39f283bd8531de81b7811db48451aff92328a3676aaffdb3cc96fbad","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"55d5b722632c0a5cfcf1f8c8252a88c5a1ece887173bb513cca0b22b874d628f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6e42d50107b1a43fd7cf4a4c4f538468a337ed219ad8d6b23bd9abdabd123bd5","Cargo.lock":"7f984c7231c91f2def8f3e2e923a85c2e0b3239492f5ce23400881ea4de1aa16","Cargo.toml":"8a447efc18cd97d019a9771fb258b06f694499500561564eec75480e46bcc554","Cargo.toml.orig":"6c9e7b86804255debe03545c6358eb975d3d470810a19e6c40c680299a686b1f","src/backends/mod.rs":"65cdc60cdf38968f5a7e197338f4cf6173406ce69a4f0aaa96a9e29f4f581b6e","src/backends/v2020/firmware.rs":"5a41bfb8f42f17523e68f8702e87d75bcdb268bd4950bb66227f6966ef3576a9","src/backends/v2020/mod.rs":"efcaa6b186c8b6e79e9799a647291b895c5ff59f058722e98455ef68bc97c548","src/backends/v2020/rpc.rs":"b517f88b9125fe1d8a20d5167f5d0d105b1339fce3d1a9fad5592e00470f46fb","src/backends/v2020/web.rs":"a6a3ad3eb77551b098b0092553b02cee43d165476d8c92164e12a1e765753b0d","src/backends/v2023_07/firmware.rs":"c07668e351d48dab3e24511b1aa9ab5e408bbcb5a438fdb0542a1377f94b9bbb","src/backends/v2023_07/mod.rs":"278e4dd04a753858e12df96ead3522aef0616ebf6f27b3da4f1a12b064c19ee6","src/backends/v2023_07/rpc.rs":"2b24bbb432b302dd15f7a354054fc96c6a75cac2c8e75b8bcc11da37255a05a3","src/backends/v2023_07/web.rs":"d39b67ed83781b2c4fa84a445b9ffe785ae3001941f800ad9860e050c61c6506","src/firmware.rs":"e75c21d63218204b61bfab067599402e5c0b20452beaf0b16bfa79bf8afb6b35","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"a3ef4d6805bb4f8ea087e3a9b875e5a1664580e1ff3e3cd2015bb0c5c18ae7bb","src/test/json/v2020/devs.json":"df17cdfc9522e23450702b93f70ff701892db54c6ce6d986300453ad5e0d22db","src/test/json/v2020/mod.rs":"4c2512d36af834d400a865a94c2e8b1919f9d8dcbf54ab2530c73861c51af67d","src/test/json/v2020/pools.json":"4c4d19ad3ef0de84bfb18daaa48428b5f7917d23287c0196eacf3a6e389e7634","src/test/json/v2020/stats.json":"6d3cb463abb7539ae77aa44ef38e62a5dc0db54670aeacf3bbd01e83f49aa1fd","src/test/json/v2020/summary.json":"2f18c81f989b7c5f70dcb0ddac0520e56ec98b6da25c24e59354a6126c965dae","src/test/json/v2020/system_info.json":"51d1ce922e39a254518a24be56ca86ef1b5843582fb26c1ff0ec4ff6f8f91ccf","src/test/json/v2020/version.json":"ae898c4c9ea3462c3e79f9de755f1fccb4ef122b94a4a512e61aa74491c1a8e9","src/test/json/v2023_07/l11_stats.json":"2eab324f253ced9a0ea4e46466691e0e71fc6fde7558fec86bd5acf6bb9c717d","src/test/json/v2023_07/l11_summary.json":"1e0fdb61b968005d0ec5393d9dc889b09efb1398ffa427629bcc0a98d1b67c22","src/test/json/v2023_07/l11_version.json":"d116921a71731c6e492aed109731c39561e34a24c7df2a88d11ac52b80f6100a","src/test/json/v2023_07/l9_stats.json":"731ee545f16dafd356d22703248b91a37f74585ad73cc27441eb3461ce53dca0","src/test/json/v2023_07/l9_summary.json":"b32b5131ad46859b270d2dbb6bdba3c4e5d7301298daee4ce56332c98faaf81d","src/test/json/v2023_07/l9_version.json":"82f03ca6ea8873f12c4d9455f21b98c547801b58fbff1dcd83c837c0f337a129","src/test/json/v2023_07/mod.rs":"1360a8b155b120f2e755ede0736bcc0d76a9d1d693b984a1b51a16e6c0413791","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"0c06e3ecbf95ae3fe5e30aacae55cf6e7ad3d965f4a93b2f85c7b64f61fc75e2"}
+152 -26
View File
@@ -14,7 +14,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
device::DeviceInfo,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -201,10 +201,41 @@ fn miner_conf_with_fan_config(miner_conf: &Value, config: FanConfig) -> Value {
Value::Object(payload)
}
/// Infer an Antminer's hash algorithm from its model-family letter, for models
/// asic-rs' alias table doesn't recognise (round 13 #5). Only the families whose
/// entire product line shares one algorithm are inferred; anything ambiguous
/// (the K-series spans Kadena/KHeavyHash/Eaglesong, DR is Blake256 while D is
/// X11) is left Unknown rather than guessed wrong.
fn infer_antminer_algo(model: &str) -> HashAlgorithm {
let upper = model.to_ascii_uppercase();
let name = upper
.strip_prefix("ANTMINER ")
.unwrap_or(&upper)
.trim_start();
match name.chars().next() {
// Z9 / Z11 / Z15 / Z15 Pro / Z15J -- the whole Z line is Equihash.
Some('Z') => HashAlgorithm::Equihash,
// L3+ / L7 / L9 / L11 -- the whole L line is Scrypt.
Some('L') => HashAlgorithm::Scrypt,
// S9..S21 and T9..T21 (and future revisions) are all SHA-256.
Some('S') | Some('T') => HashAlgorithm::SHA256,
_ => HashAlgorithm::Unknown,
}
}
impl AntMinerV2020 {
pub fn new(ip: IpAddr, model: impl MinerModel) -> Self {
let auth = Self::default_auth();
let algo = model.hash_algorithm();
// asic-rs maps a model string to its algorithm through a fixed alias
// table; a model that is not in the table (a Z15J, a not-yet-added
// S-series, ...) resolves to HashAlgorithm::Unknown, which then leaves the
// miner's hashrate un-bucketed ("unknown hashrate", round 13 #5). When the
// table can't place the model, infer the algorithm from its Antminer
// family letter for the lines that are single-algorithm end to end.
let algo = match model.hash_algorithm() {
HashAlgorithm::Unknown => infer_antminer_algo(&model.to_string()),
known => known,
};
AntMinerV2020 {
ip,
rpc: AntMinerRPCAPI::new(ip),
@@ -434,14 +465,29 @@ impl GetDataLocations for AntMinerV2020 {
tag: None,
},
)],
DataField::ControlBoardVersion => vec![(
WEB_MINER_TYPE,
DataExtractor {
func: get_by_pointer,
key: Some("/subtype"),
tag: None,
},
)],
// Prefer the explicit control-board subtype from miner_type.cgi, but
// carry the kernel build string from get_system_info.cgi too: older
// models (e.g. Z15/Z15J) have no miner_type.cgi, and their kernel
// string ("...-xilinx-...") names the control board we can actually
// read instead of guessing from the model (round 12 #10).
DataField::ControlBoardVersion => vec![
(
WEB_MINER_TYPE,
DataExtractor {
func: get_by_pointer,
key: Some("/subtype"),
tag: Some("subtype"),
},
),
(
WEB_SYSTEM_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/system_kernel_version"),
tag: Some("kernel"),
},
),
],
// cgminer names its summary keys after the unit they are in —
// `GHS 5s` on SHA-256 models, `MHS 5s` on Scrypt ones — so keep
// the whole entry and let the parse pick the key that is present.
@@ -722,6 +768,15 @@ impl GetHashrate for AntMinerV2020 {
})
})?;
// Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
// "GHS" key, so the key's GigaHash label is wrong -- the value is the
// raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
// is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
// and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|| self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
let unit = if is_equihash { HashRateUnit::Hash } else { unit };
Some(
HashRate {
value,
@@ -739,16 +794,33 @@ impl GetExpectedHashrate for AntMinerV2020 {
let value = field?
.pointer("/hashrate")
.and_then(Self::parse_f64_field)?;
// Equihash miners (Z15/Z15J) report `total_rateideal` as a Sol/s count in
// the same (mislabelled) scale as the realtime "GHS" rate, so reinterpret
// it as the base Hash unit -- matching parse_hashrate. Without this,
// expected reads ~1e6x larger than realtime and the realtime figure looks
// absent next to it (round 12 #10).
let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|| self
.device_info
.model
.to_string()
.to_ascii_uppercase()
.contains("Z15");
let unit = if is_equihash {
HashRateUnit::Hash
} else {
// `total_rateideal` does not name its own scale, so take it from
// STATS' `rate_unit` (`"GH"` / `"MH"`).
field
.and_then(|v| v.pointer("/unit"))
.and_then(|v| v.as_str())
.and_then(|s| HashRateUnit::from_str(s).ok())
.unwrap_or(HashRateUnit::GigaHash)
};
Some(
HashRate {
value,
// `total_rateideal` does not name its own scale, so take it
// from STATS' `rate_unit` (`"GH"` / `"MH"`).
unit: field
.and_then(|v| v.pointer("/unit"))
.and_then(|v| v.as_str())
.and_then(|s| HashRateUnit::from_str(s).ok())
.unwrap_or(HashRateUnit::GigaHash),
unit,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default()),
@@ -761,15 +833,23 @@ impl GetFans for AntMinerV2020 {
let mut fans: Vec<FanData> = Vec::new();
if let Some(stats_data) = data.get(&DataField::Fans) {
for i in 1..=self.device_info.hardware.fans.unwrap_or(4) {
// Some models report their fans in higher fan slots and leave the low
// ones at 0 -- the Z15, for example, has fan_num=2 but reports its two
// fans in fan3/fan4 with fan1/fan2 = 0. So scan a generous range of
// slots and collect the non-zero readings rather than only reading
// fan1..hardware.fans (which missed the Z15 entirely). The collected
// fans are renumbered 0.. in the order found (round 14 #12).
let mut pos: i16 = 0;
for i in 1..=16 {
if let Some(fan_speed) =
stats_data.get(format!("fan{}", i)).and_then(|v| v.as_f64())
&& fan_speed > 0.0
{
fans.push(FanData {
position: (i - 1) as i16,
position: pos,
rpm: Some(AngularVelocity::from_rpm(fan_speed)),
});
pos += 1;
}
}
}
@@ -879,11 +959,34 @@ impl GetControlBoardVersion for AntMinerV2020 {
&self,
data: &HashMap<DataField, Value>,
) -> Option<MinerControlBoard> {
let cb_type = data.extract::<String>(DataField::ControlBoardVersion)?;
match cb_type.as_str() {
s if s.to_uppercase().contains("AML") => Some(AntMinerControlBoard::AMLogic.into()),
_ => AntMinerControlBoard::parse(cb_type.split("_").collect::<Vec<&str>>()[0])
.map(|cb| cb.into()),
let field = data.get(&DataField::ControlBoardVersion)?;
// Explicit control-board subtype (miner_type.cgi) wins when present.
let subtype = field
.pointer("/subtype")
.and_then(|v| v.as_str())
.unwrap_or("");
if !subtype.is_empty() {
return match subtype {
s if s.to_uppercase().contains("AML") => Some(AntMinerControlBoard::AMLogic.into()),
_ => AntMinerControlBoard::parse(subtype.split('_').next().unwrap_or(subtype))
.map(|cb| cb.into()),
};
}
// No subtype (older models): read the control board from the kernel build
// string instead of guessing from the model (round 12 #10). Bitmain names
// the SoC in the kernel version, e.g. "Linux 4.6.0-xilinx-..." (Z15) or an
// AMLogic/Meson kernel on newer AMLogic boards.
let kernel = field
.pointer("/kernel")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_ascii_lowercase();
if kernel.contains("xilinx") || kernel.contains("zynq") {
Some(AntMinerControlBoard::Xilinx.into())
} else if kernel.contains("aml") || kernel.contains("meson") {
Some(AntMinerControlBoard::AMLogic.into())
} else {
None
}
}
}
@@ -1008,9 +1111,17 @@ impl SetFaultLight for AntMinerV2020 {
true
}
#[allow(unused_variables)]
async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
Ok(self.web.blink(fault).await.is_ok())
// `blink()` fires the toggle then reads the state back as `{"isBlinking":
// bool}` (the legacy CGI's own HTTP status is unreliable). Report success
// only when the observed locate-LED state matches what was requested.
let observed = self
.web
.blink(fault)
.await?
.get("isBlinking")
.and_then(serde_json::Value::as_bool);
Ok(observed == Some(fault))
}
}
@@ -1366,6 +1477,21 @@ mod tests {
AM_DEVS, AM_POOLS, AM_STATS, AM_SUMMARY, AM_SYSTEM_INFO, AM_VERSION,
};
#[test]
fn unknown_models_infer_algo_from_family_letter() {
// Round 13 #5: a model outside asic-rs' alias table must still resolve a
// sensible algorithm from its Antminer family letter instead of Unknown.
assert_eq!(infer_antminer_algo("ANTMINER Z15J"), HashAlgorithm::Equihash);
assert_eq!(infer_antminer_algo("Z9"), HashAlgorithm::Equihash);
assert_eq!(infer_antminer_algo("ANTMINER L15"), HashAlgorithm::Scrypt);
assert_eq!(infer_antminer_algo("ANTMINER S23"), HashAlgorithm::SHA256);
assert_eq!(infer_antminer_algo("ANTMINER T23"), HashAlgorithm::SHA256);
// Ambiguous / unrelated families stay Unknown (K-series spans three
// algorithms; a bare unknown string has no family).
assert_eq!(infer_antminer_algo("ANTMINER KS7"), HashAlgorithm::Unknown);
assert_eq!(infer_antminer_algo("WHATSMINER M30"), HashAlgorithm::Unknown);
}
#[test]
fn set_miner_conf_payload_matches_cgi_contract_for_pause_resume() {
let pre = json!({
+11 -1
View File
@@ -71,7 +71,17 @@ impl AntMinerRPCAPI {
read_stream_response(&mut stream, DEFAULT_RPC_TIMEOUT).await
};
let response = response?;
self.parse_rpc_result(&response)
self.parse_rpc_result(&Self::sanitize_cgminer(&response))
}
/// Antminer's cgminer `stats` sometimes emits an array whose objects are not
/// comma-separated (`...}{"STATS":0,...` on the Z15/Z15J), which is invalid
/// JSON that serde rejects -- dropping the whole stats command and with it
/// every stats-derived field (expected hashrate, wattage, fans, hashboards,
/// uptime). Insert the missing separators. Well-formed JSON never contains an
/// unseparated `}{`, so this is a no-op on valid responses (round 12 #10).
fn sanitize_cgminer(response: &str) -> String {
response.replace("}{", "},{")
}
fn parse_rpc_result(&self, response: &str) -> anyhow::Result<Value> {
+81 -13
View File
@@ -240,6 +240,45 @@ impl AntMinerWebAPI {
Ok(response)
}
/// POST a form-encoded (`application/x-www-form-urlencoded`) body to a CGI
/// endpoint and parse the JSON reply. The legacy LuCI web UI endpoints (e.g.
/// `blink.cgi`) expect `action=...` form fields, not a JSON body. An empty
/// reply parses to `{}`; a non-2xx status bails.
async fn send_web_form_command(&self, command: &str, form: &[(&str, &str)]) -> Result<Value> {
let url = format!("http://{}:{}/cgi-bin/{}.cgi", self.ip, self.port, command);
// Build an application/x-www-form-urlencoded body by hand (this reqwest
// build has no `.form()` helper). The only fields used are `action` with
// fixed ASCII values, so percent-encoding is unnecessary.
let body = form
.iter()
.map(|(k, v)| format!("{k}={v}"))
.collect::<Vec<_>>()
.join("&");
let response = self
.client()?
.post(&url)
.header(
reqwest::header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.body(body)
.timeout(self.timeout)
.send_digest_auth((self.auth.username(), self.auth.password()))
.await
.map_err(|e| anyhow!(e.to_string()))?;
let status = response.status();
if !status.is_success() {
bail!("HTTP request failed with status code {}", status);
}
let text = response.text().await.map_err(|e| anyhow!(e.to_string()))?;
if text.trim().is_empty() {
Ok(json!({}))
} else {
serde_json::from_str(&text).map_err(|e| anyhow!(e.to_string()))
}
}
pub async fn get_miner_conf(&self) -> Result<Value> {
self.send_web_command("get_miner_conf", false, None, Method::GET)
.await
@@ -257,17 +296,31 @@ impl AntMinerWebAPI {
}
pub async fn blink(&self, blink: bool) -> Result<Value> {
let param = if blink {
json!({"blink": "true"})
} else {
json!({"blink": "false"})
};
self.send_web_command("blink", false, Some(param), Method::POST)
// Legacy LuCI web UI: the locate LED is toggled by POSTing an `action`
// form field to blink.cgi (`startBlink`/`stopBlink`) -- NOT a JSON body
// like the newer (>= 2023.07) firmware expects. The handler performs the
// action but frequently answers 401/500 even on success, so its HTTP
// status is not a reliable signal: fire it, ignore the response, then read
// the real state back via `onPageLoaded`.
let action = if blink { "startBlink" } else { "stopBlink" };
let _ = self
.send_web_form_command("blink", &[("action", action)])
.await;
self.blink_status().await
}
/// Query the locate-LED state via the legacy blink.cgi `onPageLoaded` action,
/// which reliably answers `200 {"isBlinking": bool}`.
pub async fn blink_status(&self) -> Result<Value> {
self.send_web_form_command("blink", &[("action", "onPageLoaded")])
.await
}
pub async fn reboot(&self) -> Result<Value> {
self.send_web_command("reboot", false, None, Method::POST)
// The legacy LuCI web UI reboots via GET /cgi-bin/reboot.cgi (its own
// reboot.html does `type: 'GET'`); a POST is not what this firmware
// generation expects.
self.send_web_command("reboot", false, None, Method::GET)
.await
}
@@ -350,8 +403,17 @@ impl AntMinerWebAPI {
}
pub async fn get_blink_status(&self) -> Result<Value> {
self.send_web_command("get_blink_status", false, None, Method::GET)
.await
// The old firmware has no `get_blink_status.cgi` (it answers 404); the
// locate state lives behind blink.cgi's `onPageLoaded` action as
// `{"isBlinking": bool}`. Remap it to `{"blink": bool}` so the shared
// LightFlashing extractor (key `/blink`) keeps working.
let flashing = self
.blink_status()
.await?
.get("isBlinking")
.and_then(Value::as_bool)
.unwrap_or(false);
Ok(json!({ "blink": flashing }))
}
pub async fn set_network_conf(
@@ -383,10 +445,16 @@ impl APIClient for AntMinerWebAPI {
MinerCommand::WebAPI {
command,
parameters,
} => self
.send_web_command(command, false, parameters.clone(), Method::GET)
.await
.map_err(|e| anyhow!(e.to_string())),
} => {
// The legacy blink status lives behind a POST form action, not a
// GET .cgi (which 404s), so route it through the dedicated helper.
if *command == "get_blink_status" {
return self.get_blink_status().await;
}
self.send_web_command(command, false, parameters.clone(), Method::GET)
.await
.map_err(|e| anyhow!(e.to_string()))
}
_ => Err(anyhow!("Unsupported command type for Web client")),
}
}
@@ -16,7 +16,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
device::DeviceInfo,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -698,6 +698,15 @@ impl GetHashrate for AntMinerV202307 {
})
})?;
// Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
// "GHS" key, so the key's GigaHash label is wrong -- the value is the
// raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
// is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
// and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|| self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
let unit = if is_equihash { HashRateUnit::Hash } else { unit };
Some(
HashRate {
value,
+31 -14
View File
@@ -142,18 +142,9 @@ async fn get_model_with_auth(
}
}
/// Fetch the firmware version from a miner using digest auth.
async fn get_version_with_auth(ip: IpAddr, auth: &MinerAuth) -> Option<semver::Version> {
let client = build_discovery_client().ok()?;
let data: Response = client
.get(format!("http://{ip}/cgi-bin/summary.cgi"))
.send_digest_auth((auth.username(), auth.password()))
.await
.ok()?;
let json_data = data.json::<serde_json::Value>().await.ok()?;
let fw_version = json_data["INFO"]["CompileTime"].as_str().unwrap_or("");
/// Parse an Antminer cgminer `CompileTime` string ("Mon Dec 14 18:01:42 CST
/// 2020") into a date-based semver (year.month.day) used to pick the backend.
fn parse_antminer_compile_time(fw_version: &str) -> Option<semver::Version> {
let cleaned: String = {
let mut parts: Vec<&str> = fw_version.split_whitespace().collect();
if parts.len() > 4 {
@@ -161,9 +152,7 @@ async fn get_version_with_auth(ip: IpAddr, auth: &MinerAuth) -> Option<semver::V
}
parts.join(" ")
};
let dt = NaiveDateTime::parse_from_str(&cleaned, "%a %b %e %H:%M:%S %Y").ok()?;
Some(semver::Version::new(
dt.year() as u64,
dt.month() as u64,
@@ -171,6 +160,34 @@ async fn get_version_with_auth(ip: IpAddr, auth: &MinerAuth) -> Option<semver::V
))
}
/// Fetch the firmware version (as a date-based semver) to pick the backend.
async fn get_version_with_auth(ip: IpAddr, auth: &MinerAuth) -> Option<semver::Version> {
// Newer Antminers expose the firmware CompileTime via summary.cgi.
if let Ok(client) = build_discovery_client()
&& let Ok(data) = client
.get(format!("http://{ip}/cgi-bin/summary.cgi"))
.send_digest_auth((auth.username(), auth.password()))
.await
&& let Ok(json_data) = data.json::<serde_json::Value>().await
&& let Some(v) =
parse_antminer_compile_time(json_data["INFO"]["CompileTime"].as_str().unwrap_or(""))
{
return Some(v);
}
// Older models (e.g. Z15/Z15J) have no summary.cgi, so summary-based version
// detection returns nothing and the miner would default to the newest
// backend and be mis-parsed. Fall back to the cgminer :4028 `version` RPC,
// which still reports the CompileTime, so the right (older) backend is picked
// (round 12 #10).
let rpc = asic_rs_core::util::send_rpc_command(&ip, "version").await?;
parse_antminer_compile_time(
rpc.pointer("/VERSION/0/CompileTime")
.and_then(|v| v.as_str())
.unwrap_or(""),
)
}
#[async_trait]
impl MinerFirmware for AntMinerStockFirmware {
/// Uses default credentials. For custom credentials, use `build_miner`
File diff suppressed because one or more lines are too long
+15 -1
View File
@@ -286,6 +286,14 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
DataField::BestShare => vec![(
WEB_MINER_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/miner_stats/best_share"),
tag: None,
},
)],
DataField::TuningTarget => vec![
(
WEB_MINER_CONFIGURATION,
@@ -548,7 +556,13 @@ impl GetUptime for BraiinsV2604 {
}
}
impl GetBestShare for BraiinsV2604 {}
impl GetBestShare for BraiinsV2604 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// Braiins OS reports the all-time best share at miner/stats -> miner_stats.best_share
// (round 16 / G9). Large diffs may exceed f64 exactness but are fine for display.
data.extract::<f64>(DataField::BestShare)
}
}
impl GetSessionBestShare for BraiinsV2604 {}
impl GetOperatingState for BraiinsV2604 {
+29 -5
View File
@@ -57,11 +57,20 @@ impl WebAPIClient for BraiinsWebAPI {
let status = response.status();
if status.is_success() {
let json_data = response
.json()
// Some setters (e.g. PUT auth/password) answer 2xx with an empty or
// non-JSON body. An empty body is success, not a parse error -- treat
// it as Null so callers using `.is_ok()` don't read a real success as
// failure. A non-empty body must still parse.
let body = response
.text()
.await
.map_err(|e| BraiinsError::ParseError(e.to_string()))?;
Ok(json_data)
if body.trim().is_empty() {
Ok(Value::Null)
} else {
Ok(serde_json::from_str(&body)
.map_err(|e| BraiinsError::ParseError(e.to_string()))?)
}
} else {
// The API reports why it rejected a request in the body.
let status = status.as_u16();
@@ -78,7 +87,13 @@ impl BraiinsWebAPI {
client: OnceCell::new(),
ip,
port: 80,
timeout: Duration::from_secs(5),
// Braiins get_data fans out to ~12 authenticated REST calls that run
// concurrently. A healthy miner answers well under a second; the extra
// headroom over the old 5 s is defensive so a call that queues behind a
// scan burst still completes instead of dropping miner/stats
// (hashrate/watts/best-share). The real fix for the fleet-scan dropout
// is the app-side scan concurrency cap (see scan::SCAN_CONCURRENCY_LIMIT).
timeout: Duration::from_secs(15),
bearer_token: RwLock::new(None),
auth,
}
@@ -113,13 +128,22 @@ impl BraiinsWebAPI {
return Ok(());
}
// Single-flight the login: get_data fires ~12 commands concurrently, and
// without this they would ALL see no token and each POST /auth/login (a
// thundering herd that doubles the connection load and races under a
// high-concurrency fleet scan, dropping most values). Hold the write lock
// across the login so exactly one call authenticates and the rest reuse it.
let mut guard = self.bearer_token.write().await;
if guard.is_some() {
return Ok(());
}
let token = match &self.auth {
MinerAuth::TokenAuth(token) => token.expose_secret().to_string(),
MinerAuth::UserAndPass(creds) => {
self.authenticate(creds.password.expose_secret()).await?
}
};
*self.bearer_token.write().await = Some(token);
*guard = Some(token);
Ok(())
}
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"4c9489c1f9b5f16e3fd8ab777da35bb120ccd0ca05f780cf94853c89fb5c8946","Cargo.lock":"69db8793725d6071e21b4353fb89537912096d7eccebd6ee597367330141f613","Cargo.toml":"df82261a9c3187bee15a7d6092d54ad2e9c7e4d1f127cd577c457d913f6881cf","Cargo.toml.orig":"e7c4ef90bc86763dad35d1a4da1c17c7e2f59eaac79e2f011647ae31c43d5e2b","src/backends/mod.rs":"1362c4d3805dccb7a78ef6b45d6a81b8f63b2be75fcf80329b6c2b0dd9e2d5c5","src/backends/v1/mod.rs":"360f173deb62c38bceb907774be6caaea5814b4f543d8d7f3c72828db31640b9","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"4c9489c1f9b5f16e3fd8ab777da35bb120ccd0ca05f780cf94853c89fb5c8946","Cargo.lock":"69db8793725d6071e21b4353fb89537912096d7eccebd6ee597367330141f613","Cargo.toml":"df82261a9c3187bee15a7d6092d54ad2e9c7e4d1f127cd577c457d913f6881cf","Cargo.toml.orig":"e7c4ef90bc86763dad35d1a4da1c17c7e2f59eaac79e2f011647ae31c43d5e2b","src/backends/mod.rs":"1362c4d3805dccb7a78ef6b45d6a81b8f63b2be75fcf80329b6c2b0dd9e2d5c5","src/backends/v1/mod.rs":"fff17902f8fa033d5b67c6131ea2ff01b80f9a9c8e02dd0511e1e87521d23e47","src/backends/v1/web.rs":"3a567a4f581baa5d9d2d4e59d8acc754eec51d49b0a4f5434d87614b037a4a55","src/firmware.rs":"fb88124a51089756cc3271f3d4a234d73add61ab919c4710ef26a52dc8b5ef80","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/capabilities.json":"d2b3dae7aa2a1e2977e0ddf62cf2d730de64cf12bf62388c12fd23dc5278bbcb","src/test/json/v1/chip_clocks.json":"d1f46d3aad6ad55ec1c02d0b26aa4c5034c1ccaefb130d7b0e46efe48bb122a0","src/test/json/v1/chip_hashrates.json":"9601a1289f93fe4e27c722d51b3a31daa71aec71f2c29e71f6d1eefe01edf7f2","src/test/json/v1/chip_temps.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/chip_voltages.json":"cb7390e424af57f55f0c974ddfe0c98c4d5b4dbcd85887e38ff8caf7b19f62fe","src/test/json/v1/mod.rs":"5671105221b84b0b6edb2df34b25bfc9e33459da285d4316be0db23ddb630e8d","src/test/json/v1/network.json":"3374b419fa2f0bc19544c670e08118bbc45bd4d121a577c5a6403c8c8100f628","src/test/json/v1/summary.json":"ac8ac018da9d619b5884f283b730bad2bf0a7e8f2032a7119193c9e5d87d6a7c","src/test/json/v1/temps.json":"794edf870985ed4398ead96670b8f5d01deb4d825fb14a8325087a29cd939fa8","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"268dc7c8b3289fccd3230ff87f7bfc727a3e7e2f6f72ae56ab9d27c63eabc5cf"}
+8
View File
@@ -1369,6 +1369,14 @@ impl SetFaultLight for PowerPlayV1 {
#[async_trait]
impl SetPowerLimit for PowerPlayV1 {
fn supports_set_power_limit(&self) -> bool {
// ePIC PowerPlay's only true power-limit mechanism is the PowerTune
// perpetual-tune algorithm, which the firmware gates on the PSU: on a
// fixed-voltage Bitmain PSU (e.g. the APW12 on an S19j Pro) the
// perpetualtune/algo endpoint rejects it with "Power optimization is not
// supported by this PSU". Since that support is a per-PSU runtime property
// that this synchronous, no-I/O capability check cannot observe, report
// false rather than over-advertise a control that fails on most reflashed
// Antminers. (Hashrate tuning is exposed separately via set_tuning_config.)
false
}
}
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"fc109beb7fa4713b5f7a6d717e225ff91baa6f8ef497bc770a435f92981c2879","src/backends/v1/rpc.rs":"9dea9c65629e1e9b833b96a4ae88014f7195a26036104f92daa264fbdf13feba","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"fe8effe2bfdda5d4c390656c016729f531a2b1c60033228557659c0befdde9f2","Cargo.lock":"a2b2cb45bb8b574e4f29ffdcdb5ebafd1dd87a0e6e11b47383973a99be367784","Cargo.toml":"503efa00123f8567f5fe40bf6a93e9e453d13094df0e0e1b7e98bdacdfbd2595","Cargo.toml.orig":"1c4ba0315fb491c086fc22a5c9bafaf7288c6b1fd48679c3d03dbd9df156a8b5","src/backends/mod.rs":"548d988b877410e330a55e275f64b2adad95ca5f1a0f085fe144957c96b8906f","src/backends/v1/mod.rs":"3e57d2c72d1d48c0b86f5438202633fcd9c1ebf375bd87ffe53ea5298ae936ad","src/backends/v1/rpc.rs":"25b0b9d56fbf113d5b8c3d3bc8eb7a0d67967b1f90f6d855da0b9f6ff24ae335","src/firmware.rs":"d95345295ae5043dfc357e69ae56c564b261fdb3b19b5c0ad1765267ff05ab3f","src/lib.rs":"53f7acddeff8f7d82f80d09e0a9f91962011f9ccf2e441c4ca05cd7fc4eb292e","src/test/json/mod.rs":"24191681066d5cf6a3022ad59c1baa92b57e3ce7717bb78d6a682af9e19a38c4","src/test/json/v1/config.json":"6ca9e6217d853d4bf1e75d69159630e9c9184ede96751706b88dfb699b5d59ad","src/test/json/v1/devs.json":"8f746dc6a02953eee5ee96dcf53be8dc7880a8ffc2c6e303f0284bcf6a97f42d","src/test/json/v1/events.json":"913683ff97af3333018807e1cc6e43467ea8a55925e5964dc402616615e2a5e3","src/test/json/v1/fans.json":"f8a9a1234d651055c80f4ebb1380bbb4e6d19eb33012902c55fff1385e592447","src/test/json/v1/healthchipget_0.json":"10619460049333ca016b2beec59ecc514ed9077fb19bdf7d0ed697201f8cb96c","src/test/json/v1/healthchipget_1.json":"80927fb1480c95be7f3a4e155d63f68f97720530ff7cf5d5ade06f2a3e810bf0","src/test/json/v1/healthchipget_2.json":"1e93ee2ab472ee7af58add08b4251e3ce0ad4f986d4325abbf43fd4c9b3dd28f","src/test/json/v1/mod.rs":"5a050f07455e622e35ad79ab1c8a6daf2ea38c4198472e49c6bbfe80538a9e48","src/test/json/v1/pools.json":"0068745327e31853fec051172abb7337f18a4cf9972c51967113d63f4f31f504","src/test/json/v1/power.json":"80534bb4581de7c8b747bf33b5d629b909c6e16a531d18ecb4afd7ffad3f014f","src/test/json/v1/profiles.json":"1f00429036e270daa08f12cd2d7357135070c57acd7a899a3c0af6167fe82abb","src/test/json/v1/stats.json":"2b105f0eb927046c9d2389bde978a43e3d54d12a420dfbe400786bb2f0ae31ca","src/test/json/v1/summary.json":"aaea3378eb7040952037e2f1ef7bd5f20a1b242bf93d4ba0501c46104b0b31a0","src/test/json/v1/temps.json":"1ee781cd2be3ed6a6a07e23be930248735fb51348c160453ba10f6ef71fcb7f1","src/test/json/v1/version.json":"4beb6ca5c0ebf359cee0434fdcc4d0a1a0607436634e46be3fd951e2256595df","src/test/json/v1/voltageget_0.json":"c445fa8674c2542b2d296fbafdd3166c53008dfbd9da8095327217989d37f1da","src/test/json/v1/voltageget_1.json":"96b91c3447dd66e7f1f575ed3b99611062e8b1d516d31422b74e425c46b2f49c","src/test/json/v1/voltageget_2.json":"7d40544021b2e32401135ae333067b770d2d736ada9e60deaca8fd8f5a79a1e3","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"513792d93a2a21d5258d9e6ac0e6dc9e0a6365118934514b4e656792add78066"}
+125 -3
View File
@@ -445,6 +445,22 @@ impl GetDataLocations for LuxMinerV1 {
tag: None,
},
)],
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
DataField::SessionBestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Session Share"),
tag: None,
},
)],
DataField::Uptime => vec![(
RPC_STATS,
DataExtractor {
@@ -888,8 +904,18 @@ impl GetUptime for LuxMinerV1 {
}
}
impl GetBestShare for LuxMinerV1 {}
impl GetSessionBestShare for LuxMinerV1 {}
impl GetBestShare for LuxMinerV1 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// LuxOS summary -> "Best Share" (all-time), round 16 / G9.
data.extract::<f64>(DataField::BestShare)
}
}
impl GetSessionBestShare for LuxMinerV1 {
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// LuxOS summary -> "Best Session Share" (since boot), round 16 / G9.
data.extract::<f64>(DataField::SessionBestShare)
}
}
impl GetOperatingState for LuxMinerV1 {}
@@ -1052,10 +1078,66 @@ impl SetFaultLight for LuxMinerV1 {
}
}
/// Parse a LuxOS `profiles` RPC reply into (step name, watts) pairs, keeping only
/// profiles that report both a `Step` and a `Watts` value.
fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
profiles
.get("PROFILES")
.and_then(Value::as_array)
.map(|arr| {
arr.iter()
.filter_map(|p| {
let step = p.get("Step").and_then(Value::as_str)?.to_string();
let watts = p.get("Watts").and_then(Value::as_f64)?;
Some((step, watts))
})
.collect()
})
.unwrap_or_default()
}
/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
/// profile that does not exceed `target_w`, or -- when the target is below every
/// profile -- the lowest-watt profile. Returns None only when there are no
/// profiles to choose from.
fn select_profile_at_or_below(steps: &[(String, f64)], target_w: f64) -> Option<String> {
if steps.is_empty() {
return None;
}
let mut sorted: Vec<&(String, f64)> = steps.iter().collect();
sorted.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
sorted
.iter()
.rev()
.find(|(_, w)| *w <= target_w)
.or_else(|| sorted.first())
.map(|(s, _)| s.clone())
}
#[async_trait]
impl SetPowerLimit for LuxMinerV1 {
fn supports_set_power_limit(&self) -> bool {
false
true
}
async fn set_power_limit(&self, power: Power) -> anyhow::Result<bool> {
// LuxOS tunes by discrete named profiles (each carries a Watts rating),
// not a raw watts setpoint. Map the requested limit to the highest profile
// whose Watts does not exceed it (or the lowest profile when the target is
// below every profile), then apply it with profileset.
let profiles = self.rpc.profiles().await?;
let steps = parse_profile_watts(&profiles);
let Some(chosen) = select_profile_at_or_below(&steps, power.as_watts()) else {
anyhow::bail!("LuxOS reported no tunable profiles with a Step/Watts pair");
};
let resp = self.rpc.profileset(&chosen).await?;
// LuxOS answers with a STATUS array; "S"/"I" is success. A missing status
// after a non-error reply is treated as applied.
Ok(resp
.pointer("/STATUS/0/STATUS")
.and_then(Value::as_str)
.map(|s| matches!(s, "S" | "I"))
.unwrap_or(true))
}
}
@@ -1231,6 +1313,46 @@ mod tests {
POWER, PROFILES, STATS, SUMMARY, TEMPS, VERSION, VOLTAGEGET_0, VOLTAGEGET_1, VOLTAGEGET_2,
};
#[test]
fn power_limit_profile_selection() {
// LuxOS reports a ladder of profiles, each with a Step name and Watts.
let steps = vec![
("-16".to_string(), 865.0),
("-4".to_string(), 2385.0),
("-2".to_string(), 2790.0),
("0".to_string(), 3100.0),
];
// The highest profile at or below the requested watts limit.
assert_eq!(
select_profile_at_or_below(&steps, 2500.0).as_deref(),
Some("-4")
);
assert_eq!(
select_profile_at_or_below(&steps, 2790.0).as_deref(),
Some("-2")
);
// Above every profile -> the maximum profile (a limit can't exceed the
// hardware's top profile).
assert_eq!(
select_profile_at_or_below(&steps, 9000.0).as_deref(),
Some("0")
);
// Below every profile -> the minimum profile.
assert_eq!(
select_profile_at_or_below(&steps, 100.0).as_deref(),
Some("-16")
);
// No profiles -> nothing to choose.
assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
// parse_profile_watts against the captured LuxOS `profiles` reply: it
// yields tunable profiles and selection finds a real step among them.
let profiles: Value = serde_json::from_str(PROFILES).unwrap();
let parsed = parse_profile_watts(&profiles);
assert!(!parsed.is_empty(), "fixture should carry tunable profiles");
assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
}
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {
+16 -7
View File
@@ -239,7 +239,7 @@ impl LUXMinerRPCAPI {
pub async fn addgroup(&self, name: &str, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"addgroup",
false,
true,
Some(Value::String(format!("{name},{quota}"))),
)
.await
@@ -248,7 +248,7 @@ impl LUXMinerRPCAPI {
pub async fn groupquota(&self, group_id: u32, quota: u32) -> anyhow::Result<Value> {
self.send_command(
"groupquota",
false,
true,
Some(Value::String(format!("{group_id},{quota}"))),
)
.await
@@ -257,7 +257,7 @@ impl LUXMinerRPCAPI {
pub async fn removegroup(&self, group_id: u32) -> anyhow::Result<Value> {
self.send_command(
"removegroup",
false,
true,
Some(Value::String(group_id.to_string())),
)
.await
@@ -275,14 +275,14 @@ impl LUXMinerRPCAPI {
params.push(group_id);
}
self.send_command("addpool", false, Some(Value::String(params.join(","))))
self.send_command("addpool", true, Some(Value::String(params.join(","))))
.await
}
pub async fn switchpool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"switchpool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -291,7 +291,7 @@ impl LUXMinerRPCAPI {
pub async fn enablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"enablepool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
@@ -300,7 +300,16 @@ impl LUXMinerRPCAPI {
pub async fn disablepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"disablepool",
false,
true,
Some(Value::String(pool_id.to_string())),
)
.await
}
pub async fn removepool(&self, pool_id: i32) -> anyhow::Result<Value> {
self.send_command(
"removepool",
true,
Some(Value::String(pool_id.to_string())),
)
.await
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"de321c89f62a60690ba07d6bb145ac688c6141c458638e68b3ed36b50b8de1f1","Cargo.lock":"5942ec7c9cf5c201bd32442d65020dc3ae72e33cb5aaf374b2a26501571a1487","Cargo.toml":"cb9ee00cbb415fa66a71a7d4822839bb3552336ec9ab975ae7b1137c711449cb","Cargo.toml.orig":"08409c395e4d502015da62e97efdc9c5bc6e3076031144f3f5aa35c900c7c735","src/backends/mod.rs":"26591e67688f8d015242295dde5050c4b34986e9980018a855346291a0472206","src/backends/v1_2_0/mod.rs":"c87949458cf3c73ef957b319abc1a39c4755d709d7e3cf5ea9b9b326eb054605","src/backends/v1_2_0/web.rs":"ac89f16bf623f7d85590d34b45c99b0e522d9d434b4c22af7fa8a8a653e09d2e","src/backends/v1_3_0/mod.rs":"722301b45abe8177269cc008a528ae5c5b122f4d0ced28aaa5bee6b5b9f0c062","src/backends/v1_3_0/web.rs":"1ec4cbe6bdc26f165d9e54e9bf2aac4c3706357ce4677dc21113710d4a26c3c1","src/firmware.rs":"168eeffaef90cb1525bb2e126e73905b5205d49215437263813e30323f6b7a05","src/lib.rs":"16ea1c0007fa6d6c86c1f83d3ac9cdf065cd9936cd52f35ef89c227397bbc54a","src/timezone.rs":"309bf23de1bdc9126bde5db8dabff0d2c0fea797dbf2630a772a18539838a05e"},"package":"1cb662e56f104c0fe45c8ccdac13f60cbcaad45ac228f939c6ac46ff40335052"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"de321c89f62a60690ba07d6bb145ac688c6141c458638e68b3ed36b50b8de1f1","Cargo.lock":"5942ec7c9cf5c201bd32442d65020dc3ae72e33cb5aaf374b2a26501571a1487","Cargo.toml":"cb9ee00cbb415fa66a71a7d4822839bb3552336ec9ab975ae7b1137c711449cb","Cargo.toml.orig":"08409c395e4d502015da62e97efdc9c5bc6e3076031144f3f5aa35c900c7c735","src/backends/mod.rs":"26591e67688f8d015242295dde5050c4b34986e9980018a855346291a0472206","src/backends/v1_2_0/mod.rs":"fc68a12769890e18231255c6a53cb2c68e4706a887d91f49113c6192684340d2","src/backends/v1_2_0/web.rs":"ac89f16bf623f7d85590d34b45c99b0e522d9d434b4c22af7fa8a8a653e09d2e","src/backends/v1_3_0/mod.rs":"0bba1bf94e7a86d763dbedda3bb5d68cf760e17f744204b0bbc0de4e3754f795","src/backends/v1_3_0/web.rs":"1ec4cbe6bdc26f165d9e54e9bf2aac4c3706357ce4677dc21113710d4a26c3c1","src/firmware.rs":"168eeffaef90cb1525bb2e126e73905b5205d49215437263813e30323f6b7a05","src/lib.rs":"16ea1c0007fa6d6c86c1f83d3ac9cdf065cd9936cd52f35ef89c227397bbc54a","src/timezone.rs":"309bf23de1bdc9126bde5db8dabff0d2c0fea797dbf2630a772a18539838a05e"},"package":"1cb662e56f104c0fe45c8ccdac13f60cbcaad45ac228f939c6ac46ff40335052"}
+19 -2
View File
@@ -179,11 +179,15 @@ impl GetDataLocations for VnishV120 {
tag: None,
},
)],
// The partner/reseller build name ("WildRose", "vnishreturn", ...) --
// combined with the version number in parse_firmware_version so the FW
// Version column shows e.g. "WildRose 1.3.5". ApiVersion still carries
// the bare /fw_version.
DataField::FirmwareVersion => vec![(
WEB_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/fw_version"),
key: Some("/build_name"),
tag: None,
},
)],
@@ -415,7 +419,20 @@ impl GetApiVersion for VnishV120 {
impl GetFirmwareVersion for VnishV120 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
data.extract::<String>(DataField::FirmwareVersion)
// FirmwareVersion carries /build_name (the partner build), ApiVersion the
// /fw_version number; show "<build> <version>" when both are present, else
// whichever is available.
let build = data
.extract::<String>(DataField::FirmwareVersion)
.filter(|b| !b.is_empty());
let version = data
.extract::<String>(DataField::ApiVersion)
.filter(|v| !v.is_empty());
match (build, version) {
(Some(b), Some(v)) => Some(format!("{b} {v}")),
(Some(b), None) => Some(b),
(None, v) => v,
}
}
}
+16 -2
View File
@@ -179,11 +179,13 @@ impl GetDataLocations for VnishV130 {
tag: None,
},
)],
// Partner/reseller build name; combined with the version number in
// parse_firmware_version (FW Version shows e.g. "WildRose 1.3.5").
DataField::FirmwareVersion => vec![(
WEB_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/fw_version"),
key: Some("/build_name"),
tag: None,
},
)],
@@ -423,7 +425,19 @@ impl GetApiVersion for VnishV130 {
impl GetFirmwareVersion for VnishV130 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
data.extract::<String>(DataField::FirmwareVersion)
// FirmwareVersion carries /build_name (partner build), ApiVersion the
// /fw_version number; show "<build> <version>" when both are present.
let build = data
.extract::<String>(DataField::FirmwareVersion)
.filter(|b| !b.is_empty());
let version = data
.extract::<String>(DataField::ApiVersion)
.filter(|v| !v.is_empty());
match (build, version) {
(Some(b), Some(v)) => Some(format!("{b} {v}")),
(Some(b), None) => Some(b),
(None, v) => v,
}
}
}
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"80f3915f1e87c6f7483e9bd0e5b1fb5552f8d017634c82eea6150fe5134b171f","src/backends/v1/rpc.rs":"4cee9caeb9bc291c4efec04f4b7fc2b8eaead904a1f2d0f30e13236476d9aac5","src/backends/v2/mod.rs":"a1a054eda0b1466b8ae1693f47d6f2d79cc0ac067eb82320c4d659c9e1eaef0f","src/backends/v2/rpc.rs":"b7afc5357d24de42350d4ec15a6b5a37698e4fd77b2c2cc8071f303ee62e957c","src/backends/v3/mod.rs":"fd232f2df64b148f0998726fc41c089d08080ba25b3ca37bcb1c7f43b08b1c17","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"de85845f52b1d4e1a0bff73462cef00962b60fad8a3ed71c7bb083c02df3a413","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"3a8bdecd1eb271de474b2aca85b5f8e598ba64fe5defc9c8dd9b8c66444a2ed4","src/backends/v1/rpc.rs":"72f9b67c2389ab6e9968e0eb340bd2b6aad9aaf059f4429eb31398863bb87f42","src/backends/v2/mod.rs":"68fd8c1762b424a7785174fdb3ae4fede1d599632657808d4b7c76bcfbfb202c","src/backends/v2/rpc.rs":"52f8d504c236009b020bf33b5550236e36d07b2c73a15bdcfcafa5188e4e1cb6","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"b2af610880fb400a9e6297662371a6b3b55077b72cf11115b77fd4d2df44e6a1","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
+165 -38
View File
@@ -26,8 +26,9 @@ use async_trait::async_trait;
use macaddr::MacAddr;
use measurements::{AngularVelocity, Frequency, Power, Temperature};
use rpc::WhatsMinerRPCAPI;
use asic_rs_core::util::is_expected_write_error;
use semver::Version;
use serde_json::Value;
use serde_json::{Value, json};
use crate::firmware::WhatsMinerFirmware;
@@ -37,6 +38,12 @@ mod rpc;
pub struct WhatsMinerV1 {
pub ip: IpAddr,
pub rpc: WhatsMinerRPCAPI,
// Privileged (token-authenticated) writes reuse the V2 btminer RPC client:
// pre-2022-07-29 miners speak the same classic get_token + AES-ECB write API
// as V2 (proven live via the access-probe token handshake), so the control
// commands share V2's implementation instead of the read-only V1 rpc above
// (round 12 #8b part 2).
pub write_rpc: crate::backends::v2::rpc::WhatsMinerRPCAPI,
pub device_info: DeviceInfo,
}
@@ -45,6 +52,11 @@ impl WhatsMinerV1 {
WhatsMinerV1 {
ip,
rpc: WhatsMinerRPCAPI::new(ip, None),
write_rpc: crate::backends::v2::rpc::WhatsMinerRPCAPI::new(
ip,
None,
MinerAuth::new("admin", "admin"),
),
device_info: DeviceInfo::new(
model,
WhatsMinerFirmware::default(),
@@ -105,6 +117,10 @@ impl GetDataLocations for WhatsMinerV1 {
command: "get_psu",
parameters: None,
};
const RPC_GET_ERROR_CODE: MinerCommand = MinerCommand::RPC {
command: "get_error_code",
parameters: None,
};
match data_field {
DataField::Mac => vec![(
@@ -131,14 +147,28 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
DataField::ControlBoardVersion => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/CB Platform"),
tag: None,
},
)],
DataField::ControlBoardVersion => vec![
(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/CB Platform"),
tag: None,
},
),
// Older M30S firmware (< 2022.7.29, so this v1 backend) often omits
// "CB Platform" from summary but still reports the board under
// get_version /Msg/platform (the source v2 uses). Fall back to it so
// those units don't show a blank control board.
(
RPC_GET_VERSION,
DataExtractor {
func: get_by_pointer,
key: Some("/Msg/platform"),
tag: None,
},
),
],
DataField::TuningTarget => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -228,10 +258,10 @@ impl GetDataLocations for WhatsMinerV1 {
},
)],
DataField::Messages => vec![(
RPC_SUMMARY,
RPC_GET_ERROR_CODE,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
key: Some("/Msg/error_code"),
tag: None,
},
)],
@@ -285,8 +315,12 @@ impl GetControlBoardVersion for WhatsMinerV1 {
) -> Option<MinerControlBoard> {
data.extract::<String>(DataField::ControlBoardVersion)
.and_then(|s| {
WhatsMinerControlBoard::parse(s.to_uppercase().strip_prefix("ALLWINNER_")?)
.map(|cb| cb.into())
// The "ALLWINNER_" prefix is optional: summary's CB Platform carries
// it (e.g. "ALLWINNER_H6"), but the get_version /Msg/platform fallback
// does not (e.g. "H6OS"). Strip it only when present.
let up = s.to_uppercase();
let board = up.strip_prefix("ALLWINNER_").unwrap_or(&up);
WhatsMinerControlBoard::parse(board).map(|cb| cb.into())
})
}
}
@@ -441,32 +475,43 @@ impl GetTuningCapabilities for WhatsMinerV1 {}
impl GetLightFlashing for WhatsMinerV1 {}
impl GetMessages for WhatsMinerV1 {
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
// WhatsMiner V1 (H6OS) reports faults via get_error_code -> Msg.error_code,
// an array of {code: timestamp} objects (the same shape as V2/V3; the RPC
// layer repairs the occasional invalid bare-pair array first). The older
// summary "Error Code N" fields are frequently empty on these units.
let mut messages = Vec::new();
let error_count = data
.get(&DataField::Messages)
.and_then(|val| {
val.pointer("/Error Code Count")
.and_then(|val| val.as_u64())
})
.unwrap_or(0u64) as usize;
for idx in 0..error_count {
let e_code = data
.get(&DataField::Messages)
.and_then(|val| val.pointer(&format!("/Error Code {}", idx)))
.and_then(|val| val.as_u64());
if let Some(code) = e_code {
let info = crate::error_codes::error_info(code);
let Some(errors) = data.get(&DataField::Messages) else {
return messages;
};
for obj in errors.as_array().unwrap_or(&Vec::new()).iter() {
let Some(obj) = obj.as_object() else {
continue;
};
for (code, time) in obj.iter() {
let Some(time_str) = time.as_str() else {
continue;
};
let timestamp =
chrono::NaiveDateTime::parse_from_str(time_str, "%Y-%m-%d %H:%M:%S")
.map(|t| {
chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
t,
chrono::Utc,
)
})
.map(|dt| dt.timestamp() as u32)
.unwrap_or(0);
let parsed_code = code.parse::<u64>().unwrap_or(0);
let info = crate::error_codes::error_info(parsed_code);
messages.push(MinerMessage::with_component(
0,
code,
timestamp,
parsed_code,
info.message,
MessageSeverity::Error,
info.component,
));
}
}
messages
}
}
@@ -542,17 +587,45 @@ impl GetPools for WhatsMinerV1 {
}
}
#[async_trait]
// Control commands (round 12 #8b part 2): the classic btminer token write API is
// the same on V1-era firmware as on V2, so these mirror the V2 backend but go
// through `write_rpc`. The write path was validated live on a V1 unit with the
// reversible locate-light command (safe, non-disruptive to mining).
#[async_trait]
impl SetFaultLight for WhatsMinerV1 {
async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
let parameters = match fault {
false => Some(json!({"param": "auto"})),
true => Some(json!({"color": "red", "period": 200, "duration": 100, "start": 0})),
};
let data = self.write_rpc.send_command("set_led", true, parameters).await;
Ok(data.is_ok())
}
fn supports_set_fault_light(&self) -> bool {
false
true
}
}
#[async_trait]
impl SetPowerLimit for WhatsMinerV1 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
match self
.write_rpc
.send_command("adjust_power_limit", true, parameters)
.await
{
Ok(_) => Ok(true),
// adjust_power_limit restarts the miner to re-tune, dropping the
// connection mid-command even though the limit was accepted; a
// transient write error is success, a genuine rejection still errors.
Err(e) if is_expected_write_error(&e) => Ok(true),
Err(e) => Err(e),
}
}
fn supports_set_power_limit(&self) -> bool {
false
true
}
}
@@ -567,29 +640,77 @@ impl SupportsPoolsConfig for WhatsMinerV1 {
.collect())
}
async fn set_pools_config(&self, config: Vec<PoolGroupConfig>) -> anyhow::Result<bool> {
let group = config
.into_iter()
.next()
.ok_or_else(|| anyhow::anyhow!("No pool groups provided"))?;
let mut params = serde_json::Map::new();
for n in 1..=3 {
let pool = group.pools.get(n - 1);
params.insert(
format!("pool{n}"),
json!(pool.map(|p| p.url.to_string()).unwrap_or_default()),
);
params.insert(
format!("worker{n}"),
json!(pool.map(|p| p.username.as_str()).unwrap_or_default()),
);
params.insert(
format!("passwd{n}"),
json!(pool.map(|p| p.password.as_str()).unwrap_or_default()),
);
}
Ok(self
.write_rpc
.send_command("update_pools", true, Some(json!(params)))
.await
.is_ok())
}
fn supports_pools_config(&self) -> bool {
false
true
}
}
#[async_trait]
impl Restart for WhatsMinerV1 {
async fn restart(&self) -> anyhow::Result<bool> {
// The miner often reboots before replying, so any error is treated as
// "rebooting".
let _ = self.write_rpc.send_command("reboot", true, None).await;
Ok(true)
}
fn supports_restart(&self) -> bool {
false
true
}
}
#[async_trait]
impl Pause for WhatsMinerV1 {
#[allow(unused_variables)]
async fn pause(&self, at_time: Option<Duration>) -> anyhow::Result<bool> {
// Fire-and-forget: the miner may power off before responding.
let _ = self
.write_rpc
.send_command("power_off", true, Some(json!({"respbefore": "true"})))
.await;
Ok(true)
}
fn supports_pause(&self) -> bool {
false
true
}
}
#[async_trait]
impl Resume for WhatsMinerV1 {
#[allow(unused_variables)]
async fn resume(&self, at_time: Option<Duration>) -> anyhow::Result<bool> {
let data = self.write_rpc.send_command("power_on", true, None).await;
Ok(data.is_ok())
}
fn supports_resume(&self) -> bool {
false
true
}
}
@@ -625,7 +746,13 @@ impl UpgradeFirmware for WhatsMinerV1 {
}
}
impl HasAuth for WhatsMinerV1 {}
impl HasAuth for WhatsMinerV1 {
fn set_auth(&mut self, auth: MinerAuth) {
// WhatsMiner's token account is always "admin"; only the password varies.
// Route it to the privileged write RPC (round 12 #8b part 2).
self.write_rpc.set_auth(MinerAuth::new("admin", auth.password()));
}
}
impl HasDefaultAuth for WhatsMinerV1 {}
impl Validate for WhatsMinerV1 {
@@ -106,6 +106,9 @@ impl RPCAPIClient for WhatsMinerRPCAPI {
let response = response
.replace('\n', "") // Fix for WM V1, can have newlines in version which breaks the json parser
.replace(",}", "}"); // Fix for WM V1, can have trailing commas which breaks the json parser
// Fix for WM V1 get_error_code, which can emit an invalid array of bare
// "code":"timestamp" pairs (`["540":".."]`) that fails the whole parse.
let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
+13 -3
View File
@@ -637,11 +637,21 @@ impl SetFaultLight for WhatsMinerV2 {
impl SetPowerLimit for WhatsMinerV2 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
let data = self
match self
.rpc
.send_command("adjust_power_limit", true, parameters)
.await;
Ok(data.is_ok())
.await
{
Ok(_) => Ok(true),
// adjust_power_limit makes the miner restart to re-tune, so it drops
// the connection / stops replying mid-command even though it accepted
// and applied the new limit (verified on the live fleet: the set value
// settles after the restart). A transient RPC error (read timeout /
// connection reset) after the command is therefore success; a genuine
// rejection surfaces as StatusCheckFailed and still errors.
Err(e) if is_expected_write_error(&e) => Ok(true),
Err(e) => Err(e),
}
}
fn supports_set_power_limit(&self) -> bool {
true
@@ -202,6 +202,9 @@ impl WhatsMinerRPCAPI {
read_stream_response(&mut stream, DEFAULT_RPC_TIMEOUT).await
};
let response = response?;
// Repair the occasional invalid get_error_code array (bare
// "code":"timestamp" pairs) before parsing; a no-op on valid responses.
let response = crate::error_codes::repair_error_code_array(&response);
self.parse_rpc_result(&response)
}
+23 -7
View File
@@ -669,12 +669,21 @@ impl SetFaultLight for WhatsMinerV3 {
#[async_trait]
impl SetPowerLimit for WhatsMinerV3 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let data = self
// WhatsMinerOS wants a BARE INTEGER watt value; a float ("3000.0")
// trips the firmware's "invalid json" parser (round-9 #4).
let watts = limit.as_watts().round() as u64;
match self
.rpc
.send_command("set.miner.power_limit", true, Some(json!(limit.as_watts())))
.await;
Ok(data.is_ok())
.send_command("set.miner.power_limit", true, Some(json!(watts)))
.await
{
Ok(_) => Ok(true),
// A power-limit change restarts the miner to re-tune, so a transient
// RPC error after the command means it was accepted (as with v2), not
// rejected; a genuine rejection is a StatusCheckFailed and still errors.
Err(e) if is_expected_write_error(&e) => Ok(true),
Err(e) => Err(e),
}
}
fn supports_set_power_limit(&self) -> bool {
true
@@ -806,8 +815,15 @@ impl HasDefaultAuth for WhatsMinerV3 {
impl HasAuth for WhatsMinerV3 {
fn set_auth(&mut self, auth: MinerAuth) {
// WhatsMiner V3 username is always "super", V2 is always "admin"
self.rpc.set_auth(MinerAuth::new("super", auth.password()));
// WhatsMiner V3 username is always "super", V2 is always "admin".
// The V3 privileged token authenticates against the "super" ACCOUNT,
// whose password is a separate v3 credential (factory default "super")
// -- NOT the web/admin password carried by `auth`. Pairing account
// "super" with the web password made every v3 privileged write fail with
// "invalid json or password is wrong" (round-9 #4, confirmed on the live
// fleet). Keep the super-account default password here; the web password
// still drives the v2 (admin) path below.
self.rpc.set_auth(MinerAuth::new("super", "super"));
self.v2_rpc
.set_auth(MinerAuth::new("admin", auth.password()));
}
+71
View File
@@ -2,6 +2,56 @@ use asic_rs_core::data::message::MinerComponent;
const UNKNOWN: &str = "Unknown error type.";
/// Repair an invalid `error_code` array emitted by some WhatsMiner firmware.
///
/// Certain (older, H6OS) firmwares report the fault list as bare
/// `"code":"timestamp"` pairs directly inside a JSON array
/// (`"error_code":["540":"..","541":".."]`) rather than an array of single-key
/// objects (`[{"540":".."},{"541":".."}]`). The bare form is not valid JSON and
/// fails the whole response parse, so no messages are surfaced at all. Rewrite the
/// bare pairs into objects; already-valid (object-wrapped or empty) arrays and
/// responses without an `error_code` array are returned unchanged.
pub fn repair_error_code_array(raw: &str) -> String {
const KEY: &str = "\"error_code\":[";
let Some(pos) = raw.find(KEY) else {
return raw.to_string();
};
let open = pos + KEY.len() - 1; // index of the '['
let bytes = raw.as_bytes();
let mut depth = 0i32;
let mut close = None;
for (i, &b) in bytes.iter().enumerate().skip(open) {
match b {
b'[' => depth += 1,
b']' => {
depth -= 1;
if depth == 0 {
close = Some(i);
break;
}
}
_ => {}
}
}
let Some(close) = close else {
return raw.to_string();
};
let inner = &raw[open + 1..close];
// Already valid (each entry object-wrapped) or empty -> leave untouched.
if inner.trim().is_empty() || inner.contains('{') {
return raw.to_string();
}
// Timestamps carry no commas, so a top-level comma split isolates each pair.
let wrapped = inner
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(|pair| format!("{{{pair}}}"))
.collect::<Vec<_>>()
.join(",");
format!("{}{}{}", &raw[..=open], wrapped, &raw[close..])
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ErrorInfo {
pub message: String,
@@ -514,6 +564,27 @@ fn serial_info_error(sub: u64, val: u64) -> String {
mod tests {
use super::*;
#[test]
fn repair_malformed_error_code_array() {
// Bare "code":"timestamp" pairs inside the array (invalid JSON) -> objects.
let bad = r#"{"STATUS":"S","Msg":{"error_code":["540":"2026-09-22 07:08:14","561":"2026-09-21 22:26:36"]},"Description":""}"#;
let fixed = repair_error_code_array(bad);
let v: serde_json::Value = serde_json::from_str(&fixed).expect("repaired JSON must parse");
let arr = v["Msg"]["error_code"].as_array().unwrap();
assert_eq!(arr.len(), 2);
assert_eq!(arr[0]["540"], "2026-09-22 07:08:14");
assert_eq!(arr[1]["561"], "2026-09-21 22:26:36");
// Already-valid (object-wrapped) arrays are returned unchanged.
let good = r#"{"Msg":{"error_code":[{"205":"2026-09-20 03:35:44"}]}}"#;
assert_eq!(repair_error_code_array(good), good);
// Empty array and no-array responses are untouched.
let empty = r#"{"Msg":{"error_code":[]}}"#;
assert_eq!(repair_error_code_array(empty), empty);
let none = r#"{"STATUS":"S"}"#;
assert_eq!(repair_error_code_array(none), none);
}
#[test]
fn short_code_returns_unknown() {
// Act
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"aaaa0f14e3aff2543d3d09a4515efa5ab439f0651a36b582e87b9843d0475752","Cargo.lock":"58da2f3399ff680bf7d619204897b4edf5c03d336a8c3cceb54c9aba280bfed1","Cargo.toml":"57f92bf3808fa6f468dbabf43763a808d9ead128eef83b748f940ef3b219a80e","Cargo.toml.orig":"cbfb99fc843dd61ad2025dcfc16bd435afd2b6d43c2c983867af08af415916f1","src/hardware.rs":"77612b4f39e9c15355172b0582693d86b2fe44a305f5b01eef592e5a34b37188","src/lib.rs":"b2f55767a7f3fdacb1e898c5cb961c2dec8481823f94386ee67628960e91bf7d","src/make.rs":"e968e4dbd745d485fc9ad4c5a4c081d679eddce11f66e572f81f2dbe37ede3f0","src/models.rs":"da72a570d8cbb2c843c04047c3d879ca9709455f9bd6a02c3f2ab739e1b5be60"},"package":"67cca6e6bf4ac14562084ce7534521ffa7cd313fa39e2392f98ff98a047a4353"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"aaaa0f14e3aff2543d3d09a4515efa5ab439f0651a36b582e87b9843d0475752","Cargo.lock":"58da2f3399ff680bf7d619204897b4edf5c03d336a8c3cceb54c9aba280bfed1","Cargo.toml":"57f92bf3808fa6f468dbabf43763a808d9ead128eef83b748f940ef3b219a80e","Cargo.toml.orig":"cbfb99fc843dd61ad2025dcfc16bd435afd2b6d43c2c983867af08af415916f1","src/hardware.rs":"6a52c19b38be83fe47ccf8f6c6fe3b7d9597575b79366fbc678ea3586953dd52","src/lib.rs":"b2f55767a7f3fdacb1e898c5cb961c2dec8481823f94386ee67628960e91bf7d","src/make.rs":"e968e4dbd745d485fc9ad4c5a4c081d679eddce11f66e572f81f2dbe37ede3f0","src/models.rs":"b4ea44fc627ff6c8b41bf8758d6ce6074aa690fe9f6c95a9cb3d1cdbd00e51d6"},"package":"67cca6e6bf4ac14562084ce7534521ffa7cd313fa39e2392f98ff98a047a4353"}
+8 -2
View File
@@ -98,6 +98,10 @@ impl From<AntMinerModel> for MinerHardware {
fans: Some(2),
boards: Some(vec![Some(6), Some(6), Some(6)]),
},
AntMinerModel::Z15J => Self {
fans: Some(2),
boards: Some(vec![Some(3), Some(3), Some(3)]),
},
AntMinerModel::S17 => Self {
fans: Some(4),
boards: Some(vec![Some(48), Some(48), Some(48)]),
@@ -268,11 +272,13 @@ impl AntMinerControlBoard {
.collect::<String>();
match compact.as_str() {
"XILINX" => Some(Self::Xilinx),
// "XIL" is VNish's short platform form for a Xilinx control board.
"XILINX" | "XIL" => Some(Self::Xilinx),
"BBB" | "BBCTRL" | "BB" | "BEAGLEBONE" | "BEAGLEBONEBLACK" => {
Some(Self::BeagleBoneBlack)
}
"CVITEK" | "CVCTRL" => Some(Self::CVITek),
// "CV" is VNish's short platform form for a CVITek control board.
"CVITEK" | "CVCTRL" | "CV" => Some(Self::CVITek),
"AMLOGIC" | "AML" => Some(Self::AMLogic),
"AMCB07" => Some(Self::Xilinx), // Mara FW
"ZYNQ7007" => Some(Self::Xilinx),
+13
View File
@@ -78,6 +78,9 @@ pub enum AntMinerModel {
#[serde(alias = "ANTMINER Z15 PRO")]
#[algorithm(HashAlgorithm::Equihash)]
Z15Pro,
#[serde(alias = "ANTMINER Z15J")]
#[algorithm(HashAlgorithm::Equihash)]
Z15J,
#[serde(alias = "ANTMINER S17")]
#[algorithm(HashAlgorithm::SHA256)]
S17,
@@ -281,11 +284,21 @@ mod tests {
(AntMinerModel::E9Pro, HashAlgorithm::EtHash),
(AntMinerModel::Z15, HashAlgorithm::Equihash),
(AntMinerModel::Z15Pro, HashAlgorithm::Equihash),
(AntMinerModel::Z15J, HashAlgorithm::Equihash),
] {
assert_eq!(model.hash_algorithm(), expected, "{model}");
}
}
#[test]
fn z15j_parses_as_equihash() {
// The Z15J reports "ANTMINER Z15J"; before it had an alias it fell back to
// Unknown, which left its Sol/s hashrate un-bucketed (round 13 #5).
let model = AntMinerModel::from_str("ANTMINER Z15J").unwrap();
assert_eq!(model, AntMinerModel::Z15J);
assert_eq!(model.hash_algorithm(), HashAlgorithm::Equihash);
}
#[test]
fn unknown_model_uses_unknown_algorithm() {
let model = AntMinerModel::from_str("ANTMINER S99").unwrap();