Compare commits

...
98 Commits
Author SHA1 Message Date
noahandClaude Opus 4.8 a6e22581d7 asic-rs telemetry T1b: WhatsMiner V3 PSU serial + ePIC chip/HB type
Round 19 #10 telemetry extension, tier 1 sub-batch B. Both ride existing
DataFields (Psu/Hashboards) on already-fetched commands (no extra round-trips)
and reuse the PsuInfo.serial / BoardData.chip_type+hashboard_model fields added
in T1a, so no core or GUI change -- the existing columns just populate for more
firmwares. Patch 0024; fixture tests pass.

- WhatsMiner V3: add a DataField::Psu location (get.device.info /msg/power) and a
  parse_psu that reads model/type, sw/hwversion, and the serial (sn). V3 had no
  PSU parse at all (default None) despite the data being fetched for PsuFans.
- ePIC: parse_hashboards now reads capabilities "Chip Type" (e.g. "BM1366") and
  "Model Subtype" (e.g. "BHB56801"), applied to every board (capabilities reports
  them miner-wide). The capabilities command is already fetched for Hashboards.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 14:31:36 -06:00
alkane-ci b15de7f747 ci: refresh README badges [skip release] 2026-09-23 20:18:33 +00:00
noahandClaude Opus 4.8 f887affd6d asic-rs telemetry T1a: PSU serial + chip/HB type + best-share
Extend vendored asic-rs to scan more per-firmware telemetry (round 19 #10
follow-up, tier 1 sub-batch A). All new values ride on existing DataFields
(Psu/Hashboards/BestShare) and commands already fetched, so no new core
DataField plumbing and no extra network round-trips. Patch 0023.

Vendored (asic-rs):
- PsuInfo gains `serial`. Braiins v26_04 parse_psu corrected to read model_name
  + fw_version (it used the numeric type code as the model and dropped the fw
  version) and to capture serial_number. ePIC / WhatsMiner v1/v2 report no serial.
- BoardData gains `chip_type` (e.g. "BM1370") + `hashboard_model` (e.g.
  "A3HB70601"); Braiins miner/hw/hashboards populates both.
- best_share (all-time) wired for Antminer v2020 and WhatsMiner v1/v2 from the
  already-fetched summary "Best Share" (those backends had the empty default).
- refresh-checksums --all; existing braiins/antminer/whatsminer fixture tests pass.

GUI:
- MinerRow gains chip_type, hashboard_model, psu_serial; populated in to_row.
- New columns: Chip, HB model, PSU serial. Best share now populates for Antminer
  and WhatsMiner (column already existed).

Feasibility analysis (5-agent, all firmwares) recorded in memory; further tiers
(fan %, rolling hashrate averages, difficulty/shares, temp thresholds, WhatsMiner
V3 / VNish PSU serial) follow. Confirmed genuinely-unavailable: fan max RPM,
WhatsMiner/LuxOS real logs, chip type on Antminer/LuxOS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 14:01:33 -06:00
alkane-ci e5e6b0f1e1 ci: refresh README badges [skip release] 2026-09-23 18:40:11 +00:00
noahandClaude Opus 4.8 ad28dab542 round 19 review fixes + Health-column alignment + badge-push fix
Health column (operator-reported): give every component-health icon a UNIFORM
fixed-width slot in the SegmentRenderer (GetSize + DrawShape), so power/control/
fan/board icons line up in fixed columns across rows regardless of glyph aspect,
and left-align the icon columns (Health/Access/Light) so the block anchors at a
consistent left edge. The per-icon tooltip hit-test uses the same uniform slot.

Code-review-harness fixes:
- High: isolate per-miner telemetry with catch_unwind so one miner's get_data
  panic can't abort the whole scan (and strand the fast-path partial rows).
- Medium: fill the zebra stripe across the full cell for right-aligned colored
  columns (was anchored at the content's left edge, leaving the left unstriped).
- Medium: lower the scan-concurrency ceiling 512 -> 256 (128 is fully reliable,
  192 already dropped responders on the live fleet).
- Medium: board voltage/frequency sort key skips placeholder-zero boards
  (avg_positive), matching how the cell renders them as "-".
- Low: saturating_add for accepted/rejected share sums; moved an orphaned doc
  comment; corrected a stale comment.

CI: fix the README-badge push-back -- `git push -c http.extraheader` is invalid
(`-c` must precede the subcommand), so the badge/coverage/bench-baseline commit
never actually reached main; now `git -c http.extraheader=... push`. This also
lets the bench-delta baseline persist so the delta can compute.

Demo: the offline-demo paused miner now has detected (idle) hashboards so the
paused-blue Health icons (round 19 #19) are exercised.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 12:21:03 -06:00
noahandClaude Opus 4.8 42e3bf8f5b round 19: columns, scan speed, per-firmware logs, more scanned fields
Table/columns:
- Fix the "columns shrink to tiny" bug on language change / add / hide (#3, #24):
  the rebuild-time capped autosize read column widths before GTK's measurement
  landed. Columns keep their default widths; autosize is on-demand only.
- Right-align every column except IP (#21): new alignment param on the bridge
  append calls; the SegmentRenderer and the tooltip hit-test honour it.
- "Auto-size all columns" header menu item; Ctrl+A selects all rows (#4).
- Remove the Boards (dots) column (#7).
- Split the slash-joined Fan column into per-fan columns Fan 1-4 (#8).
- Efficiency: unit moved into the value and made algorithm-aware (J/TH for
  SHA256 families, J/kSol for Equihash), fixing the blank/garbage figure on
  non-SHA256 miners (#9, #23).
- Pool account column before Worker by default (#22).

Scan:
- Fast scan (#18): emit a lightweight identity row the instant a miner is
  identified, then upsert the full telemetry row when get_data completes.
- User-adjustable scan concurrency with a bounded max (#25).
- Surface more scanned values as columns (#10): current tuning target, accepted
  / rejected shares + reject %, and per-hashboard hashrate / voltage / frequency.

Logs (#11-16): fetch the miner log through asic-rs's per-backend read_logs()
instead of the narrow curl paths, fixing Braiins / LuxOS / Z15 / BixBit / stock
Antminer; WhatsMiner keeps the fault-code fallback (no API log). Removed the
summary tidbits from the log viewer (#13).

Misc: fix per-icon health tooltips (advance math matched to the renderer) (#2);
paused miners show blue hashboard icons, healthy stays green (#19); state-aware
Pause/Resume in the right-click menu (#20); export opens a column-picker dialog
(#6) and the default filename carries a UTC timestamp (#5); the scan status bar
says "Scan Paused" / "Scan Stopped" and no longer overwrites Stop with paused
(#17); the bench badge shows the weighted-average microbench delta vs the
previous release (#1).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 11:40:21 -06:00
noahandClaude Opus 4.8 4154a50ed0 ci: measure coverage in the release job and auto-update the badge
Add a best-effort Coverage step to release.yml: it adds the llvm-tools-preview
rustup component, fetches cargo-llvm-cov as a prebuilt binary (the vendored
.cargo/config blocks `cargo install` from crates.io), runs ci/coverage.sh to
merge unit-test and headless self-test line coverage, and feeds the TOTAL
line-coverage percent to the badge refresh so badges/coverage.svg tracks the
real number on every release. The step is gated on a release and marked
continue-on-error, so coverage tooling can never block a release.

coverage.sh now runs its instrumented builds --offline by default (the
dependency tree is fully vendored), overridable via CARGO_LLVM_COV_FLAGS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 09:32:41 -06:00
noahandClaude Opus 4.8 0ab822940e coverage: count the headless self-test, reporting ~46% (was ~35%)
The self-test builds the real wxWidgets table and renders every fixture through
the real widgets, exercising ~27% of ui.rs (up from ~4%) -- but it runs as a
separate binary, so a plain `cargo llvm-cov` (which only runs the #[test]s) never
counted it, understating coverage. New ci/coverage.sh runs both the unit tests and
the self-test under one instrumentation pass and merges them, excluding the
vendored asic-rs / patched wx-rs from the report.

Our-source line coverage is now ~46% (model 81%, naming 95%, fixtures 100%,
credentials 92%); the remainder is click-driven dialogs and live-miner network
I/O, which unit tests can't reach without hardware or heavy mocks. Badge, report,
and README dev section updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 08:09:02 -06:00
noahandClaude Opus 4.8 c1aa6db834 license: unify under MIT
Collapse the dual MIT OR Apache-2.0 licensing to MIT only (operator's choice):
set the workspace `license` field to "MIT" (all crates inherit it), replace
LICENSE-MIT + LICENSE-APACHE with a single LICENSE file, and update the README
license section and the license badge. deny.toml keeps its permissive allow-list
(that governs dependency licenses, which remain a mix of MIT/Apache-2.0/BSD/etc.);
only its project-license comment changed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 08:05:11 -06:00
noahandClaude Opus 4.8 7feab6117b item 12 finale: shrink the release binary + code-review report
[profile.release] opt-level="s" + fat LTO + one codegen unit + strip cuts the
Linux binary from ~38M to ~19M (50%). panic stays "unwind" deliberately: the scan
runs many miners on tokio tasks and the wx dispatch relies on unwinding, so one
miner's panic must never abort the whole app. Verified: stripped binary, SELFTEST
PASS, 99 tests, clippy clean.

Adds code-review-report.md: the ship verdict and a full accounting of the five
recursive review rounds (all confirmed critical/high fixed; remaining items are
documented perf/dev-CLI tradeoffs). Badges refreshed (tests 99, coverage ~35%).

This completes the round-18 marathon: all 12 queued items plus Round C G3 (LuxOS
named presets) and G7 (per-board V/F read side), CI hardening (verify/release
split, clippy gate, audit, badges), README + docs, and the recursive multi-agent
code review.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 21:02:09 -06:00
noahandClaude Opus 4.8 808fd4de1d review wave 7: fifth-round findings (creds, scan race, refill throttle)
Fifth (final) review round; this clears its functional findings:

- HIGH config actions / pool writes could run concurrently with a live scan
  (start_action / apply_pools guarded flash + restore but not scanning); added
  the self.scanning guard, and begin_scan now defers while an action/restore runs,
  closing the race symmetrically.
- HIGH blanking a per-firmware credential row saved a live ("","") override that
  then broke that firmware's auth fleet-wide; a fully-blank row now clears the
  override (use the shipped default).
- HIGH a ChangePassword action never updated the toolkit's own saved credentials,
  so after a fleet-wide change it locked itself out; on full success it now updates
  the saved global password (and on a partial change logs a reconcile note rather
  than guessing).
- HIGH/perf fill_rows re-rated: a scan's streaming rows triggered a whole-table
  refill on every fast tick. New rows_dirty latch flushes the refill at most once
  per second during a scan (immediately once it ends).
- MED an indeterminate access-probe result no longer blanks a miner's already-known
  locked/unlocked state.
- LOW compute-version.sh header doc corrected to match the broadened rule;
  release.yml sets WX_RS_WXCONFIG once at job level instead of per step.

Accepted (documented) perf items that remain: per-render health recompute and
per-column cell-string allocation (small, fleet-scale), the linear upsert scan,
and synchronous scan-range parsing (bounded by the range caps).

99 tests + clippy-clean + selftest green. This was review round 5 (the harness's
iteration cap); every confirmed critical/high across all five rounds is fixed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 20:59:03 -06:00
noahandClaude Opus 4.8 63ada5bb99 review wave 6: fourth-round findings (masked prompt, board grey, timeouts)
Fourth review round found further issues, two being gaps in earlier fixes; this
clears the actionable ones:

- HIGH board_healths() painted a genuinely-undetected board RED when a fault text
  also named it (e.g. "chain 2 not found" -> Board(2)); an undetected board now
  stays grey, matching the documented grey-vs-red invariant. Regression-tested.
- HIGH the Change-password prompt used an unmasked field (the Credentials dialog
  was masked in wave 1 but this prompt was missed) -> masked for PromptKind::Password.
- MED the WhatsMiner access probe aborted all remaining password candidates on one
  transient error -> transient errors now skip to the next candidate and never
  report a confident "locked" when the answer was really indeterminate.
- MED config actions / refresh / pools / flash ignored the operator's configured
  scan timeout (used asic-rs's 10s default) -> configured_factory now applies it,
  so a slow-link action reaches the same miners a longer-timeout scan found.
- MED the auto-rescan loop set a bogus "scanning..." status even when the scan was
  deferred (mid-flash) -> begin_scan reports whether it started.
- LOW is_aml_140mm matched every S21, not just the S21 Pro its doc names -> fixed.
- Offline fixtures now reuse scan::infer_pic instead of a diverging copy.

Accepted (documented) from this round: miner_probe's argv secrets (diagnostic CLI),
the rebuild_table/update_headers sort-marker duplication, the LuxOS substring
success check (command-specific reply), restore/flash target snapshot (dialogs are
modal), non-cancellable restore/probe batches, Braiins host-key (LAN reflash), and
the perf items (per-tick refill, health recompute, linear upsert, cell formatting).

99 tests + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 20:29:52 -06:00
noahandClaude Opus 4.8 52b7c3f2a1 review wave 5: third-round findings (unreachable column, races, panics, DoS)
Third review round (over the wave 3/4 fixes) surfaced further findings, mostly in
new code paths; this clears them:

- HIGH the fully-built "Boards" column (Column::Hashboards: renderer, sort/filter
  logic, tests, a self-test check) was missing from ALL_COLUMNS, so it was
  unreachable in the UI and its self-test check was dead. Added to ALL_COLUMNS
  (opt-in; Health still shows composite board health by default) and the self-test
  now makes it visible -- the dot-sentinel check is live again.
- HIGH apply_pools() could start a pool write during a restore-to-stock (it sets
  self.action directly, bypassing start_action's guard) -> same restore guard.
- HIGH superseding an in-flight action/pools job left the old miners' Health cells
  frozen on the "…ing" label forever (the replaced handle's drain never runs) ->
  clear the superseded action's op-status.
- HIGH clean_antminer() byte-sliced a miner-supplied model string without a
  char-boundary check (panic DoS) -> use get(..9).
- MED access-probe errors were silently discarded -> surfaced in the indicator.
- MED the pool-password file was briefly world-readable before chmod -> created
  0600 from the start (OpenOptions mode).
- MED a miner-controlled log response was buffered unbounded (OOM DoS) -> capped.
- MED the language-menu id range was hardcoded (and 790-794 collided with the
  pool-preset / fw-preset dialog ids!) -> derived from Lang::all() and moved the
  dialog ids to a clear block.
- LOW restore_vnish now sends the unlock body via stdin (password off argv), and
  the LuxOS restore treats a reboot-dropped/empty reply as success.

Remaining round-3 findings are the previously-accepted perf tradeoffs (bulk-serial
writes, per-tick refill, per-render health recompute, linear upsert), documented
in code and in code-review-report.md.

99 tests + clippy-clean + selftest green (Boards-column check now live).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:53:56 -06:00
noahandClaude Opus 4.8 571c2305aa review wave 4: remaining round-2 findings (filters, creds, restore, panics)
Clears the rest of the second review round's confirmed findings:

- HIGH the Boards numeric filter compared the composite sort score (online*100+
  total) instead of the board count, so a filter like "Boards <= 3" matched
  nothing on healthy 3-board miners. num_value now returns the detected count;
  regression-tested with per-board health present (the path the old test missed).
- HIGH the WhatsMiner access probe ignored the operator's saved scan password
  (tried only admin/super), mis-reporting writable miners as locked. It now tries
  the caller's password first.
- HIGH firmware flash and config actions were not blocked during a restore-to-
  stock; start_action and both flash guards now refuse while a restore runs.
- MED log tail() could panic slicing at a non-UTF8 char boundary -> nudge to a
  boundary first (regression-tested).
- MED board_index_from_text grabbed an unrelated number far past the keyword
  (e.g. a temperature) -> only accept a number immediately after the keyword.
- MED a restore worker-thread spawn failure wedged the restore subsystem forever
  -> emit Done on spawn failure and treat a disconnected channel as done.
- MED LuxOS restore reported failure when the miner rebooted mid-reply -> an empty
  reply or dropped connection after a successful logon is the expected reboot.
- MED two tests raced on the process-global $HOME -> a shared serialization lock.
- LOW CSV export now neutralizes spreadsheet formula-injection prefixes on
  miner-supplied fields.
- Made miner_probe's global-only credential resolution explicit (it can't share
  the GUI's per-firmware configured_factory across the bin boundary).

99 tests (+3 regression tests) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:30:29 -06:00
noahandClaude Opus 4.8 79ecc100d3 review wave 3: log-fetch credential leak + JSON escaping + column-scan cost
Second review round (over the wave 1/2 fixes) surfaced further, mostly new-path
findings; this clears the substantive ones:

- HIGH log_scan.rs passed miner admin credentials on the curl command line (same
  class as the access-probe leak fixed in wave 1). Its curl() now takes optional
  stdin: the Antminer digest login goes through a curl config on stdin (-K -),
  the VNish unlock password through the POST body on stdin (-d @-), and the
  timeout path reaps the child so it no longer leaks a zombie.
- MEDIUM JSON injection/breakage: the VNish unlock body and the LuxOS
  uninstall command spliced a password / miner-supplied SessionID into JSON with
  format!. Both now build the JSON with serde_json, which escapes correctly.
- MEDIUM column scan cost: fill_rows computed table_columns() twice (my wave-2
  built_columns check added one), and with auto-hide-empty on that scans every
  cell of every row each time. It is now computed once and reused.

Accepted, documented tradeoffs from this round: miner_probe's setpools takes the
pool password as a CLI arg (inherent to a diagnostic CLI; it is the low-sensitivity
mining worker password), MinerRow::upsert_into's linear scan is fine at the tool's
fleet scale (hundreds), and bulk config-action writes stay serial deliberately.

96 tests + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:18:27 -06:00
noahandClaude Opus 4.8 51b4eb2556 review wave 2: scan concurrency, table-column lockstep, background log fetch
Continuing the recursive review's confirmed findings:

- HIGH scan telemetry was serial: the consumer awaited each responder's to_row
  (get_data + presets, several REST calls) inline in the identification stream
  loop, so telemetry ran one miner at a time. Now buffer_unordered runs it
  concurrently up to SCAN_CONCURRENCY_LIMIT; identification (which buffers
  internally) is unaffected, and telemetry only hits live responders.
- HIGH table columns diverged from the built widget with auto-hide-empty on:
  (1) drag-reorder was silently rejected because column_reordered fed
  table_columns() (empty-filtered) to apply_visible_reorder, which compared it to
  display_columns() (unfiltered) -- apply_visible_reorder now reorders the shown
  subset in place; (2) a column flipping non-empty mid-scan left the widget stale,
  so fill_rows now rebuilds when the shown set no longer matches built_columns.
  Both covered by a new unit test.
- HIGH viewing a miner's log blocked the wx UI thread for up to ~20s. The fetch
  now runs on a background thread; the viewer opens from the tick drain when the
  result lands (tick returns the dialog for dispatch to show modally).
- LOW start_pools_action's fake branch now honours the cancel flag like its
  siblings.
- Documented the intentional tradeoffs the review flagged: scan-restart uses
  cooperative cancellation (a hard join would freeze the UI), and the aftermarket
  re-probe stays per-scan for freshness (firmware can change between scans).

96 tests (+subset-reorder) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:02:39 -06:00
noahandClaude Opus 4.8 3b18219e4e review wave 1: fix the critical restore false-success + security/correctness findings
From the recursive multi-agent review (18 confirmed findings). This wave clears
the critical, four highs, and several mediums/lows:

- CRITICAL restore.rs: a Braiins SSH restore reported SUCCESS on a wrong password
  or unreachable miner. run_with_timeout now captures the exit code and drains
  stderr on its own thread (also fixing the medium stderr-pipe stall), and a new
  testable classify_braiins() treats an ssh auth/connection failure (stderr
  diagnostic, empty stdout, non-zero exit) as failure while still reading a
  dropped connection / timeout as the expected reboot. Unit-tested.
- HIGH restore exclusivity: apply_restore_confirm now refuses when a scan/refresh/
  action/flash or another restore is in flight, so this destructive action never
  overlaps or orphans a running restore handle.
- HIGH secrets off the command line: Braiins SSH uses `sshpass -e` (env, not -p),
  and the access-probe curl passes credentials through a config on stdin (-K -)
  instead of `-u user:pass`; both were visible in the process list. New masked
  password field (wxTE_PASSWORD bridge) so the Credentials dialog no longer
  renders saved passwords in the clear.
- MEDIUM correctness: per-board Chip-temp readings are now index-aligned with the
  boards (a missing middle board shows "-" instead of shifting later boards left).
- MEDIUM: saved pool lists (which can hold a pool password) are chmod 0600.
- LOW: access-probe curl timeout now reaps the child (no zombie).

95 tests (+classify_braiins) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:45:56 -06:00
noahandClaude Opus 4.8 bcc0ba38b6 ci: install clippy component before the gate; classify all GUI src as backend
Run 82 failed because the alkane-ci image ships no clippy component
("cargo-clippy is not installed for the toolchain"). Both workflows now
`rustup component add clippy` before the gate.

Also broadened compute-version.sh: any crates/alkane-gui/src/* file is backend
logic (previously only scan.rs/model.rs/main.rs were, so a fix confined to
naming.rs / pool_prefs.rs / restore.rs / access_probe.rs / credentials.rs would
never cut a release). ui.rs/fixtures.rs/bin still match the UI arm first. All 9
compute-version tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:22:32 -06:00
noahandClaude Opus 4.8 749cdc4eed item 12: CI verify/release split, dependency audit, README + badges
CI is now two workflows: verify.yml (pull requests + non-main pushes) runs the
clippy gate, build, unit tests, microbenchmarks, the headless self-test, and a
best-effort dependency audit; release.yml (main) repeats the clippy gate + audit
before its existing build/test/selftest/package/release, then refreshes the
committed README badges and pushes any change back (best-effort, and a badges-
only push does not bump the version, so it does not loop).

Security: cargo audit found a build-time-only advisory (h2 0.3 in the wx-rs
build script's reqwest 0.11 subtree, never linked into the runtime binary and
never executed on Linux). The vendored/offline tree can't upgrade it without
re-vendoring, so it is documented and accepted in .cargo/audit.toml (mirrored in
deny.toml with the project's permissive-license policy).

Badges: ci/gen-badges.py emits self-contained shields-style SVGs into badges/
(tests, coverage 36%, bench, LOC 12.5k, clippy clean, dependencies, license) --
committed and referenced by relative path so a self-hosted Gitea renders them
with no external service. README rewritten around what the toolkit actually does
today (discover / monitor / operate / install), with build, CLI, dev, and
architecture sections and the dual-license note.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:17:31 -06:00
noahandClaude Opus 4.8 19e469ebc4 item 12: clippy-clean our crate + add LICENSE files
Cleared all clippy findings in alkane-gui (cargo clippy --no-deps): mechanical
fixes via clippy --fix (redundant imports, useless format!, manual_contains,
manual_is_multiple_of, unnecessary_map_or, unused parens) plus manual fixes:

- type_complexity: factored the segment tuple into model::{Rgb, Segment} aliases.
- large_enum_variant: #[allow] on ScanMsg/RefreshMsg with a note -- Row is the
  common variant, so boxing it to shrink the rare Started/Done would add an
  allocation per miner on the hot path.
- dead code: removed unused SHAPE_PULSE_DOT, ColorKind::Accent, clear_op_status,
  and RestoreMsg's unread `total`; kept the restore/access-probe cancel handles
  (workers honour cancellation; UI stop control pending) under #[allow].
- question_mark, needless_range_loop, drop_non_drop, doc_lazy_continuation fixes.

Only vendored wx-rs warnings remain (out of scope). Added LICENSE-MIT and
LICENSE-APACHE (Cargo.toml already declares MIT OR Apache-2.0). 94 tests +
selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:01:49 -06:00
noahandClaude Opus 4.8 6cd732dec5 Round C G7 (read side): per-board voltage/frequency in the board tooltip
Surfaces the per-hashboard configured voltage (V) and frequency (MHz) that
asic-rs already reads into BoardData but the toolkit dropped. Added
MinerRow.board_voltages / board_frequencies (index-aligned with the boards,
0.0 where unreported), populated at scan time, and appended to the per-board
Health tooltip as extra middot segments after actual/expected hashrate.

Verified live on LuxOS S19j Pro (10.4.1.60): boards report 12.73 V (frequency
is None in LuxOS's live stats path -- a pre-existing backend gap; the tooltip
omits absent values). miner_probe `msgs` now prints board freq/volt too.

The G7 WRITE path (per-board V/F override) stays deferred: no firmware accepts
Manual targets today and a bad voltage can damage a board, so per the parity
roadmap it is bench-only and not shipped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:40:32 -06:00
noahandClaude Opus 4.8 95b8428c12 Round C G3: named firmware presets (LuxOS) end to end
The flagship structured-tuning parity item: list and select a firmware's named
profiles/presets, not just map a watts number onto one.

Backend (vendored asic-rs, patch 0022): LuxOS now implements SupportsPresets
(get_presets reads the live `profiles` RPC) and a real SupportsTuningConfig
(set_tuning_config routes Preset(name) -> profileset, Power -> set_power_limit).
Unit-tested (parse_profiles_to_presets); verified live-read on two production
LuxOS S19j Pro (10.4.1.60/.67). VNish already exposed presets.

GUI: MinerCaps.supports_presets + MinerRow.presets (read live at scan time for
preset-capable miners; ~1 RPC per such miner per 300 s rescan). New "Set
profile..." right-click item opens a selector populated from the profiles
common to the whole selection (so the chosen name is valid on every target),
applied via the new ConfigAction::Preset. Offline fixtures seed demo presets.

CLI: `miner_probe presets <ip>` (list) and `setpreset <ip> <name>` (select).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:34:26 -06:00
noahandClaude Opus 4.8 a7ed34b8e4 gui: pool "+" "Add new..." opens a preset manager window (round 18 #8b)
The pool-field "+" menu previously offered a one-shot "Add new" (append
the current box value) plus a "Remove saved value" submenu. Both are now
replaced by "Add new...", which opens a small manager window: a multiline
editable list of all saved values for that field, seeded with the current
box value as the last line. Save rewrites the whole saved list at once.

- pool_prefs: new save_all() rewrites a field's saved list; the trim /
  drop-empties / drop-presets / de-dup step is factored into a pure
  dedupe_saved() with unit tests. Removed the now-unused add_saved /
  remove_saved.
- ui: build_pool_presets_dialog + apply_pool_presets, wired to
  ID_POOL_PRESETS_SAVE/CANCEL; "+" menu shows "Add new..." and no longer
  builds the remove submenu; ID_POOL_MENU_REMOVE_BASE dropped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:10:45 -06:00
noahandClaude Opus 4.8 b839e9012d gui: default column widths fit contents, capped (round 18 #10)
Columns previously always opened at generous fixed defaults, wasting
horizontal space. Now, the first time the table is populated after a
(re)build, each column is sized to the smaller of its content-fit width
(wxCOL_WIDTH_AUTOSIZE, floored at 24px) and its configured default (the
cap). Done once per rebuild via a new columns_autosized latch, so a
user's later manual resize is preserved -- scan-update refills skip it.

New bridge: wxbr_dvlc_autosize_col_capped (SetWidth AUTOSIZE, read back,
floor, clamp to cap, SetWidth) + Widget::dvlc_autosize_col_capped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:01:25 -06:00
noahandClaude Opus 4.8 d378a484d6 ui: attribute hashboard faults + pools dialog + widths (round 18 #5/#8a/#8c)
- #5 Antminer-hardware firmwares (stock/VNish/Braiins/LuxOS) report faults with no
  component, so a real per-board fault landed on the control-board tooltip instead
  of the board it names. messages_to_faults now recovers the board index from the
  self-describing message text ("Chain 2 ...", "hashboard 0 ...", "Slot 1 ...") so
  the issue shows on the right hashboard's tooltip. WhatsMiner (which does attribute
  HashBoard{idx}) is unchanged.
- #8a The pools dialog is widened so the rightmost "+" preset buttons (Password
  column) are no longer clipped off a too-narrow dialog.
- #8c The pool column headers now span field-width + the 34px "+" button, so the
  "Address/Account/Worker/Password" titles line up with the boxes below them.

board_index unit test + SELFTEST pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:52:24 -06:00
noahandClaude Opus 4.8 64e084ddee ui: per-icon tooltip repositioning + Zcash units/expected (round 18 #4a/#6/#7)
- #4a Health-column tooltips now reposition per icon: the query-tooltip handler
  scopes GTK's tip area to the hovered icon's slot, so moving across icons hides
  the old tooltip and shows a fresh one at the new position (was stuck in place).
- #6 Plain Antminer Z15 firmware omits the expected hashrate (the Z15j reports it),
  so it's filled from the model nameplate (420 KSol/s) -- the actual/expected
  column + colour now work for Z15 like every other miner.
- #7 Equihash hashrate now shows correct units: Sol/s (not TH/s). The stored value
  is Sol/s/1e12, so ths*1e12 recovers the Sol/s count; the per-board tooltip and
  the hashrate KPI card now label Equihash as Sol/s with an SI prefix.

Unit tests (equihash_hashrate_units) + health tests pass; SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:45:45 -06:00
noahandClaude Opus 4.8 93bd528430 health: PSU-fault colour rules + per-board actual/expected tooltip (round 18 #2/#3/#4b)
- #2 A PSU fault while the miner is mining is now a warning (yellow) not a failure
  (red); a fault on a non-mining miner stays red. Fixes WhatsMiners flagged red
  while running fine.
- #4b A PSU fault no longer greys the hashboards. Board colour reflects the board's
  own state: running -> green, faulted (e.g. WhatsMiner 540/560) -> red, and grey
  ONLY when the board is genuinely not detected. Stall-reddened boards the fault
  codes don't name are still exonerated to green; undetected boards stay grey.
- #3 The per-board tooltip shows actual / expected hashrate (e.g. "2  .  33.5 / 35.0
  TH/s"); a not-detected board shows "not detected". Adds MinerRow.board_expected_
  hashrates (from BoardData.expected_hashrate) + an algorithm-aware hashrate unit
  (Equihash -> Sol/s, groundwork for #7).

Health tests updated + pass; SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:36:00 -06:00
noahandClaude Opus 4.8 e45e6eaf91 ui: shrink brain icon, light toggle, blank all unknown-PIC (round 18 #1/#9/#11)
- #1 The control-board (brain) Health icon is drawn at 82% in its full slot, like
  the fan, so it no longer reads oversized (slot advance + tooltip hit-test unchanged).
- #9 The right-click menu now shows a single state-based light toggle: "Stop
  flashing lights" when any selected miner's locate light is on, else "Flash lights".
- #11 The PIC column is blank for every unknown case (non-Antminer makes and
  unclassifiable Antminer models) -- no more "?".

SELFTEST PASS; pic test updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:28:26 -06:00
noahandClaude Opus 4.8 e5a6cc2b5e psu: extend PSU-info scan to Braiins + WhatsMiner (R5/G15)
Round 17 R5/G15. The PSU version/Vmin/Vmax columns + tooltip now populate for
Braiins and WhatsMiner, not just ePIC.

- Braiins (patch 0020): miner/details -> psu_info gives the PSU type (117, the
  same APW12 ePIC reports) + rated voltage min/max. Verified live on 10.4.1.83/.27:
  model 117, Vmin 11.96 V, Vmax 15.2 V.
- WhatsMiner v1/v2 (patch 0021): get_psu -> model + hw/sw version (no DC output or
  rated envelope exposed). Verified live on 10.8.1.214 (v2): model P221C, version
  H20201205. v3 uses a different response shape and no v3 unit was available, so
  it's left as a follow-up.
- Also fixes a pre-existing broken test (test_whatsminer_v1_parse_messages never
  mocked get_error_code -> always returned 0 messages; CI runs only the GUI
  selftest so it was never caught). whatsminer backend tests now 41/41.

SELFTEST PASS; braiins + whatsminer backend suites green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:07:53 -06:00
noahandClaude Opus 4.8 6fb73c9746 firmware: detect + label Bixbit and Hiveon (own colours)
Bixbit and Hiveon keep the stock Antminer web API, so asic-rs identifies them as
"AntMiner Stock". Distinguish them at scan time from the cgminer `version` reply:
Bixbit tags it with BixFirmware/BixMiner/BixAPIVersion (definitive; verified live on
a Bixbit S19j Pro at 10.4.1.70); Hiveon carries a "hiveon" marker (best-effort --
no live Hiveon unit to confirm the exact signature yet). A real stock miner (no
marker) stays "Stock".

Firmware column colours: Bixbit -> pinkish-red (223,62,102, their logo); Hiveon ->
darker logo orange (228,112,24), with "hiveon" added to the existing hive/hiveos
alias. The probe is a short, timeout-bounded cgminer query run only for Antminer
miners that first identified as stock.

SELFTEST PASS. Hiveon detection to be re-verified once a Hiveon miner is available.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 14:15:43 -06:00
noahandClaude Opus 4.8 49985631d4 antminer: read best-share fleet-wide + Bixbit "Power Estimated" wattage (R7)
Round 17 R7. Flashing Bixbit onto fleet units surfaced two Antminer scan gaps
(patch 0019): the stock v2023_07 backend never fetched best-share at all
(DataField::BestShare had no source), so it was blank for every stock/Bixbit
Antminer; and it read wattage only from the cgminer stats, which Bixbit-based
firmware leaves at 0 (real draw is in the summary as "Power Estimated").

Now maps BestShare/SessionBestShare to the cgminer summary and adds a
"Power Estimated" wattage fallback (stock power still wins when present).

Verified live: Bixbit S19j Pro (10.4.1.70) now reads 2615 W + best-share
178930671; stock S21 Pro (10.4.1.90) now reads best-share 299464394 -- both were
blank before. 36 antminer backend tests + SELFTEST pass, no wattage regression.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 13:34:01 -06:00
noahandClaude Opus 4.8 8fe61ec427 psu: PSU info scan + version/Vmin/Vmax columns + tooltip V/A (R5/G15)
Round 17 R5/G15. asic-rs had no PSU telemetry. Adds an optional PsuInfo to
MinerData (model, version, rated voltage min/max, live output voltage/current),
a DataField::Psu, and a default parse_psu backends override (patch 0018). ePIC
populates it by merging the summary "Power Supply Stats" with the capabilities
"Psu Info".

GUI: three new columns -- "PSU version", "PSU Vmin", "PSU Vmax" (Hardware group in
the picker) -- and the R2 power tooltip now shows the PSU output voltage (and
amperage when the firmware reports a non-zero current; ePIC leaves current 0, so
it shows just the voltage).

Verified live on ePIC S19j Pro (10.4.1.6/.10): model 117, fw 22, Vmin 11.877 V,
Vmax 15.182 V, output ~13.2 V. 8 model tests + 18 ePIC backend tests + SELFTEST
pass. Non-ePIC firmware leave the PSU fields blank until they add parse_psu.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 12:24:26 -06:00
noahandClaude Opus 4.8 34a1a1f3b1 tuning: structured power + hashrate target dialogs (Round C)
Round 17 C, first GUI increment. Adds "Set power target..." and "Set hashrate
target..." to the right-click config menu, each a value prompt that shows the
miner's current target and the firmware-advertised valid range, and validates the
entry against it.

- Power target routes through the existing set_power_limit path (LuxOS/Braiins/
  WhatsMiner; VNish stays masked per operator guidance). Where the firmware
  advertises an envelope (Braiins: 944-6435 W) the prompt shows and enforces it.
- Hashrate target routes through set_tuning_config for firmware that tunes by
  hashrate (ePIC). The apply path preserves the firmware's current tuning
  algorithm and scaling config (ePIC's set_tuning_config requires both), reading
  them back before writing the new target.

Model gains: MinerRow.tuning_target_label + power/hashrate target min/max
(from data.tuning_capabilities), and MinerCaps.hashrate_target (set when the miner
actively tunes by hashrate via set_tuning_config). miner_probe's settune verb now
mirrors the same algorithm+scaling-preserving apply path.

Verified live (reversibly, restored after): ePIC S19j Pro (10.4.1.6) hashrate
94->92->94 TH via set_tuning_config Ok(true); LuxOS/Braiins power targets via
set_power_limit (see the luxminer profile-name fix). Model tests + SELFTEST pass.

Presets (G3) and per-board manual V/F (G7) are deferred: no firmware enumerates
its presets through the standard tuning_capabilities API.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:33:43 -06:00
noahandClaude Opus 4.8 0db89d6c55 miner_probe: add tune (read) + settune (write) verbs for structured tuning
Round 17 C groundwork. `tune <ip>` dumps a miner's structured-tuning surface --
what it supports (power_limit / tuning_percent / tuning_config), its current
target, and the capability envelope (power/hashrate min-max or preset list) the
firmware advertises. `settune <ip> <power|hashrate> <v>` applies a target via
set_tuning_config where supported (ePIC/VNish/WM), falling back to the plain
power-limit setter for a power target on firmware that tunes by power
(LuxOS/Braiins).

Used to map the live fleet before wiring the GUI: ePIC tunes by hashrate via
set_tuning_config (needs an algorithm + scaling config); LuxOS/Braiins tune by
power via set_power_limit; VNish/WM accept set_tuning_config; only Braiins
advertises a min/max envelope; preset lists are not exposed by any firmware's
tuning_capabilities.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:21:07 -06:00
noahandClaude Opus 4.8 08b3d56864 luxminer: set power-limit profile by name so the default profile is reachable
Round 17 C, found via live tuning verification. LuxOS set_power_limit mapped
watts to a profile but applied it by the profile's Step. The factory "default"
profile has Step "0", which LuxOS profileset reads as an empty parameter
("Missing profile parameter"), so the setter could never select the default and
a miner nudged off it by a watts limit could not be returned to its factory
point. Key on the profile Name instead (patch 0017).

Verified live on a LuxOS S19j Pro (10.4.1.60): set_power_limit(2700)->480MHz/2632W,
set_power_limit(2900)->default/2794W (previously errored). Unit test updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:20:51 -06:00
noahandClaude Opus 4.8 4e825f3ee5 health: bare-data per-component tooltips (R2)
Round 17 R2. The Health column's per-icon tooltips were prose ("Hashboard 3:
faulted", "Power supply: OK (drawing power)"). Replace them with just the data an
operator wants:

- Hashboards: an operating board shows its number counting DOWN (n-1..0, left to
  right) and its hashrate ("2  ·  33.5 TH/s"); a faulted board shows its error
  message with the firmware code; a board the failed PSU left untested shows
  "unpowered". No "Hashboard N:" prose.
- Fans: just the RPM ("4700 rpm"), unless the fan has a fault (then the error+code).
- Control board: its own and un-attributed faults with codes, else a short OK.
- Power: a healthy PSU's output voltage + amperage when reported, else a short OK;
  a faulted PSU shows the error and code.

Adds per-board hashrate (BoardData.hashrate) and the firmware error code
(MinerMessage.code) to the model, and forward-compatible PSU output V/A fields.
asic-rs does not yet expose PSU output V/A (roadmap G15), so the healthy-PSU
tooltip shows "PSU OK" until that lands, at which point it auto-upgrades to "V / A".

Unit tests (faults_attribute, health_tooltips_are_bare_data_round17_r2) pass;
SELFTEST PASS. Live data confirmed available (per-board hashrate + fan RPM on the
Braiins corpus miners).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 10:45:15 -06:00
noahandClaude Opus 4.8 8e67c50fe0 health/pic: shrink fan icon (R1), blank PIC for non-Antminers (R6), add build cleanup
Round 17 queue.

R1 -- the cooling-fan icon in the Health column read as oversized next to the
brain/chip/bolt icons. All four use a square 512x512 viewBox at the same slot
size, so the fan only *looked* bigger because the Font Awesome fan glyph fills
its box more. Draw the fan at 80% size, centred in its full-size slot, so the
slot advance and the per-icon tooltip hit-test (both keyed to the full width)
are unchanged and nothing else moves.

R6 -- WhatsMiner and other non-Antminer makes showed "?" in the PIC column. A
per-board PIC MCU is an Antminer hashboard property with no meaning elsewhere, so
the cell now shows nothing for non-Antminer brands; an unknown *Antminer* model
still shows "?".

Build hygiene (user ask) -- add scripts/clean-old-builds.sh to reclaim the local
cargo target dir. The app/CLI ship as release and tests run under --release, so
the debug tree, cross-compile trees, and coverage tree are disposable; a stray
cargo check had grown the debug tree to 38G and filled the disk. The script drops
those, keeps the warm release build, and is meant to run after each release push.

SELFTEST PASS; model tests (pic_locked, faults_attribute, health) pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 10:31:51 -06:00
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
121 changed files with 20168 additions and 695 deletions
+20
View File
@@ -0,0 +1,20 @@
# cargo-audit configuration (read by `cargo audit` from the project root).
#
# The two entries below are accepted, documented exceptions -- both live only in
# the wx-rs BUILD-dependency tree (reqwest 0.11, used by wx-rs's build.rs to
# download the wxWidgets source on Windows/macOS). On Linux download_dist()
# returns before ever constructing an HTTP client, and none of this is linked
# into the runtime binary, which talks to miners over asic-rs's reqwest 0.13
# (hyper 1.x / h2 0.4). The build tree is fully vendored and offline, so these
# cannot be upgraded without re-vendoring a newer reqwest.
#
# Re-review whenever the vendored dependency set is refreshed.
[advisories]
ignore = [
# h2 0.3 unbounded empty DATA frames (DoS). Build-time only; our build-time
# HTTP client only fetches a fixed HTTPS URL, and only on Windows/macOS.
"RUSTSEC-2026-0258",
# rustls-pemfile 1.0.4 unmaintained. Same build-only reqwest 0.11 subtree.
"RUSTSEC-2025-0134",
]
+96 -5
View File
@@ -11,6 +11,9 @@ jobs:
runs-on: alkane-ci
env:
WX_PREFIX: /root/.cache/wx-3.3.3-linux
# Set once for the whole job so build/clippy/test/bench steps don't each
# re-export it (round 18 #12).
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
steps:
- name: Checkout (full history for tags)
uses: actions/checkout@v4
@@ -49,6 +52,12 @@ jobs:
echo "wx prefix restored from cache"
fi
- name: Clippy (our crate, warnings are errors)
if: steps.ver.outputs.release == 'true'
run: |
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
- name: Set crate version to ${{ steps.ver.outputs.version }}
if: steps.ver.outputs.release == 'true'
run: |
@@ -58,30 +67,112 @@ jobs:
- name: Build release
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo build --release -p alkane-gui --offline
- name: Unit tests
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo test -p alkane-gui --offline
- name: Microbenchmarks
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_
# Capture the bench stdout for the weighted-average delta badge (round 19
# #1) while keeping the step a hard gate: pipefail preserves cargo's exit
# code (each bench asserts its own absolute ceiling) even through tee.
set -o pipefail
cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_ \
| tee bench-current.txt
- 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
BIN=target/release/alkane-toolkit
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
- name: Dependency audit (best-effort)
if: steps.ver.outputs.release == 'true'
continue-on-error: true
run: |
if command -v cargo-audit >/dev/null 2>&1; then
cargo audit || echo "cargo audit reported findings (accepted ones in .cargo/audit.toml)"
else
echo "cargo-audit not installed on this runner; skipping"
fi
# Merge coverage from the unit tests AND the headless self-test (ci/coverage.sh)
# so the committed badge reflects real coverage, not the tests-only number a
# plain `cargo llvm-cov` reports. Best-effort: cargo-llvm-cov is fetched as a
# prebuilt binary because the vendored .cargo/config blocks `cargo install`,
# and the instrumented rebuild is slow, so a failure here never blocks a
# release. Feeds steps.cov.outputs.pct to the badge refresh below. xvfb is
# already installed by the self-test step above.
- name: Coverage (best-effort)
id: cov
if: steps.ver.outputs.release == 'true'
continue-on-error: true
run: |
rustup component add llvm-tools-preview >/dev/null 2>&1 || true
if ! command -v cargo-llvm-cov >/dev/null 2>&1; then
V=0.8.7
URL="https://github.com/taiki-e/cargo-llvm-cov/releases/download/v${V}/cargo-llvm-cov-x86_64-unknown-linux-gnu.tar.gz"
DEST="${CARGO_HOME:-$HOME/.cargo}/bin"
mkdir -p "$DEST"
curl -fsSL "$URL" | tar -xz -C "$DEST" && export PATH="$DEST:$PATH" \
|| echo "cargo-llvm-cov download failed"
fi
if command -v cargo-llvm-cov >/dev/null 2>&1; then
PCT=$(bash ci/coverage.sh --summary-only 2>/dev/null \
| awk '/^TOTAL/{gsub(/%/,"",$10); print $10}')
if [ -n "$PCT" ]; then
echo "pct=${PCT}" >> "$GITHUB_OUTPUT"
echo "line coverage (tests + self-test): ${PCT}%"
else
echo "coverage report produced no TOTAL line; badge left as committed"
fi
else
echo "cargo-llvm-cov unavailable; coverage badge left as committed"
fi
# Refresh the committed README badges from live metrics and push any change
# back to main. Best-effort: a locked-down runner that can't push must not
# fail the release. A badges-only push does not bump the version (see
# compute-version.sh), so it does not loop back into another release.
- name: Refresh badges
if: steps.ver.outputs.release == 'true'
continue-on-error: true
env:
TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
PASS=$(cargo test -p alkane-gui --offline 2>&1 \
| grep -hoE '[0-9]+ passed' | grep -oE '[0-9]+' | awk '{s+=$1} END{print s+0}')
# Update the coverage badge only when the coverage step produced a number;
# otherwise leave the committed coverage.svg untouched.
COV="${{ steps.cov.outputs.pct }}"
COV_ARG=""
[ -n "$COV" ] && COV_ARG="--coverage $COV"
# Weighted-average microbench delta vs the previous release (round 19 #1).
# bench-badge.py also rewrites badges/bench-baseline.json, which is
# committed below with the SVGs (badges/* does not trip a release bump).
BENCH_DELTA=$(python3 ci/bench-badge.py --current bench-current.txt \
--baseline badges/bench-baseline.json 2>/dev/null || echo NEW)
python3 ci/gen-badges.py --tests "${PASS:-0}" $COV_ARG \
--bench-delta "${BENCH_DELTA:-NEW}" --bench "row-render + scan-parse"
if [ -n "$(git status --porcelain badges)" ]; then
git config user.name "alkane-ci"
git config user.email "ci@bluefla.re"
git add badges
git commit -m "ci: refresh README badges [skip release]"
API="${GITHUB_API_URL:-https://gitea.bluefla.re/api/v1}"
HOST="${API%/api/v1}"
git -c http.extraheader="Authorization: token ${TOKEN}" \
push "${HOST}/${GITHUB_REPOSITORY}.git" "HEAD:main" || echo "badge push skipped"
else
echo "badges unchanged"
fi
- name: Package artifact
if: steps.ver.outputs.release == 'true'
id: pkg
+74
View File
@@ -0,0 +1,74 @@
name: verify
# Pre-merge quality gate: clippy + build + tests + microbenchmarks + the headless
# UI self-test, plus a best-effort dependency audit. Runs on pull requests and on
# pushes to any branch EXCEPT main (main is gated by release.yml, which repeats
# these checks before it cuts a release -- so no work is duplicated on main).
on:
pull_request:
push:
branches-ignore: [main]
jobs:
verify:
runs-on: alkane-ci
env:
WX_PREFIX: /root/.cache/wx-3.3.3-linux
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install build dependencies
run: |
apt-get update -qq
apt-get install -y -qq --no-install-recommends \
libssl-dev pkg-config ca-certificates >/dev/null
- name: Cache vendored wxWidgets build
uses: actions/cache@v4
with:
path: /root/.cache/wx-3.3.3-linux
key: wx-3.3.3-${{ runner.os }}-${{ hashFiles('thirdparty/wx-rs/VERSION') }}
- name: Build wxWidgets (once, then cached)
run: |
if [ ! -x "$WX_PREFIX/bin/wx-config" ]; then
bash scripts/build-wx-linux.sh
else
echo "wx prefix restored from cache"
fi
- name: Clippy (our crate, warnings are errors)
run: |
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
- name: Build
run: cargo build --release -p alkane-gui --offline
- name: Unit tests
run: cargo test -p alkane-gui --offline
- name: Microbenchmarks
run: cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_
- name: Headless UI self-test
run: |
apt-get update -qq && apt-get install -y -qq --no-install-recommends \
xvfb xauth dbus-x11 fonts-dejavu-core >/dev/null
BIN=target/release/alkane-toolkit
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
# Advisory audit is best-effort: it needs the RustSec DB over the network,
# which the vendored/offline build otherwise never touches, so a locked-down
# runner must not fail the gate on it. Accepted advisories live in
# .cargo/audit.toml.
- name: Dependency audit (best-effort)
continue-on-error: true
run: |
if command -v cargo-audit >/dev/null 2>&1; then
cargo audit || echo "cargo audit reported findings (see .cargo/audit.toml for accepted ones)"
else
echo "cargo-audit not installed on this runner; skipping"
fi
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",
]
+13 -1
View File
@@ -13,9 +13,21 @@ members = [
[workspace.package]
version = "0.1.0"
edition = "2021"
license = "MIT OR Apache-2.0"
license = "MIT"
[workspace.dependencies]
thiserror = "2"
serde = { version = "1", features = ["derive"] }
sha2 = "0.10"
# Release binary: small, self-contained, and fast enough for a fleet GUI whose
# hot path is network I/O, not CPU (round 18 #12). opt-level "s" + fat LTO +
# one codegen unit + symbol stripping cut the binary substantially. panic stays
# "unwind" on purpose: the scan runs many miners on tokio tasks and the wx event
# dispatch relies on unwinding so one miner's panic never aborts the whole app.
[profile.release]
opt-level = "s"
lto = "fat"
codegen-units = 1
strip = true
+21
View File
@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2026 Blueflare
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+99 -21
View File
@@ -1,38 +1,116 @@
# alkane-toolkit
Cross-platform desktop toolkit (Rust core, native GUI) to install **stock** or
**alkaneOS** firmware on ASIC miner control boards, whatever they currently run
(stock, Vnish/AnthillOS, Braiins OS+, LuxOS, ePIC, BixBit, WardenOS).
[![CI](https://gitea.bluefla.re/blueflare/alkane-toolkit/actions/workflows/release.yml/badge.svg)](https://gitea.bluefla.re/blueflare/alkane-toolkit/actions)
![tests](badges/tests.svg)
![coverage](badges/coverage.svg)
![bench](badges/bench.svg)
![lines of code](badges/loc.svg)
![clippy](badges/quality.svg)
![dependencies](badges/dependencies.svg)
![license](badges/license.svg)
Sibling to [alkane-sdk](https://gitea.bluefla.re/blueflare/alkane-sdk): the SDK
owns board knowledge and build outputs; this toolkit is the orchestration
engine and operator UI that executes its install recipes safely.
A cross-platform desktop toolkit for discovering, monitoring, and re-flashing
ASIC miners. It scans a fleet over the network, shows live health and hashrate
in a sortable table, and installs **stock** or **alkaneOS** firmware onto a
control board whatever it currently runs (stock, VNish/AnthillOS, Braiins OS+,
LuxOS, ePIC, HiveOn, BixBit, WardenOS).
## Status
The core and UI are pure Rust; the native window is wxWidgets driven through a
vendored, patched [wx-rs](thirdparty/wx-rs) bridge, so there is no Electron,
no web view, and a single self-contained binary per platform.
M1 primary view ships: discovery (vendored asic-rs 0.8.1) + the UI-SPEC
table (6 KPIs, sortable/drag-reorderable columns, row checkboxes, scan-range
editor, Excel-style filter, columns panel). Pure-Rust GUI on wxWidgets via
vendored + patched wx-rs (docs/adr/0002, 0003).
## What it does
## Build + run (Debian)
- **Discover** a fleet by CIDR or IP range and identify each miner's make,
model, control board, and firmware (via a vendored [asic-rs](vendor/asic-rs)).
- **Monitor** hashrate vs. expected, per-board health, chip temperatures, fans,
PSU state, and pool workers, with an Excel-style filter and drag-reorderable
columns.
- **Operate** miners from a right-click menu: flash the locate light, pause /
resume, restart, set a power or hashrate target, select a firmware profile
(LuxOS/VNish presets), configure pools, set the timezone, and change the
password -- each action offered only when every selected miner supports it.
- **Install firmware**: push stock or aftermarket images, or revert an
aftermarket miner to stock, behind a typed confirmation.
Discovery and telemetry are read-only and safe to run against any fleet; every
mutating action is capability-gated and, where destructive, confirmed.
## Build and run (Debian/Ubuntu)
```sh
scripts/build-wx-linux.sh # once: builds vendored wx 3.3.3 to ~/.cache
scripts/build-wx-linux.sh # once: builds the vendored wxWidgets 3.3.3 into ~/.cache
scripts/build-gui-linux.sh # cargo build --release -p alkane-gui
~/.cache/alkane-tk-target/release/alkane-toolkit
```
Windows/macOS: `scripts/build-gui-windows.sh` (needs a Windows/msys2
toolchain) and `scripts/build-gui-macos.sh` (needs a Mac) - the GUI code is
shared; only the C++ bridge + wx differ per platform.
Runtime needs GTK 3: `sudo apt install libgtk-3-0`. To explore the UI with no
hardware, run the offline demo fleet:
See `docs/IMPLEMENTATION-PLAN.md` for the roadmap.
```sh
ALKANE_FAKE_SCAN=1 alkane-toolkit
```
## Hard rules (from alkane-sdk `docs/install-methods.md`, encoded in code)
Windows and macOS share all GUI code; only the C++ bridge and wx build differ
(`scripts/build-gui-windows.sh` needs an msys2 toolchain, `-macos.sh` needs a
Mac).
1. Never write the bootloader/secure region.
## Command-line probe
`miner_probe` is a headless companion for hardware checks that should not go
through the window event loop -- discovery, telemetry, and each write action:
```sh
miner_probe scan 10.0.0.0/24 # discover + telemetry (TSV)
miner_probe presets 10.0.0.5 # list a firmware's selectable profiles
miner_probe setpreset 10.0.0.5 540MHz
```
Run `miner_probe` with no arguments for the full verb list.
## Development
```sh
export WX_RS_WXCONFIG="$HOME/.cache/wx-3.3.3-linux/bin/wx-config"
export CARGO_TARGET_DIR="$HOME/.cache/alkane-tk-target" # keep the target tree off the source share
cargo test -p alkane-gui # unit tests
cargo test -p alkane-gui --release -- --ignored bench_ # microbenchmarks
cargo clippy -p alkane-gui --no-deps --bins -- -D warnings # lint gate
xvfb-run -a env ALKANE_SELFTEST=1 \
"$CARGO_TARGET_DIR/release/alkane-toolkit" # headless UI self-test
ci/coverage.sh --summary-only # coverage (tests + self-test)
```
CI mirrors these: `verify.yml` runs the lint, tests, benchmarks, self-test, and
a best-effort dependency audit on every pull request and branch push;
`release.yml` repeats them on `main` and cuts an `X.Y.Z` release with the built
binary attached when the change warrants it. Dependencies are vendored under
`vendor/`, so builds never touch the network.
## Architecture
- `crates/alkane-gui` -- the application: scan engine, data model, wxWidgets UI,
and the `miner_probe` CLI (the other `crates/alkane-*` are early scaffolding).
- `vendor/asic-rs` -- the miner-discovery and control library, vendored and
extended through numbered patches under `thirdparty/asic-rs/patches`.
- `thirdparty/wx-rs` -- the patched wxWidgets bridge (see `docs/adr/0002`,
`0003`).
See [`docs/IMPLEMENTATION-PLAN.md`](docs/IMPLEMENTATION-PLAN.md) for the roadmap
and [`docs/aftermarket-parity-roadmap.md`](docs/aftermarket-parity-roadmap.md)
for the firmware config/scan parity work.
## Firmware safety rules
Encoded in code, from alkane-sdk `docs/install-methods.md`:
1. Never write the bootloader or secure region.
2. Verify on a channel the installer does not control.
3. Reboot is root-only; a dropped SSH connection can be success.
4. A packer is per board; never reuse across boards.
3. Reboot is root-only; a dropped SSH connection can still be success.
4. A packer is per board; never reuse one across boards.
5. Boot-switch handling is an explicit, verified step.
## License
Licensed under the [MIT license](LICENSE).
+11
View File
@@ -0,0 +1,11 @@
{
"bench_parse_line_near_max_addrs": 4415673.0,
"bench_parse_targets_many_ranges_near_cap": 250538450.0,
"bench_render_cells": 23141151.0,
"bench_sort_by_each_column": 5352771.0,
"bench_targets_to_cidrs_large_range": 4542876.0,
"bench_upsert_cold_start_population": 62535996.0,
"bench_view_pipeline": 775512.0,
"bench_view_pipeline_default_sort": 1846612.0,
"bench_view_pipeline_with_filter": 1333066.0
}
+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="bench: -3.8% vs prev">
<title>bench: -3.8% vs prev</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="141.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="44.5" height="20" fill="#555"/>
<rect x="44.5" width="96.5" height="20" fill="#4c1"/>
<rect width="141.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">bench</text>
<text x="22.2" y="14">bench</text>
<text x="92.8" y="15" fill="#010101" fill-opacity=".3">-3.8% vs prev</text>
<text x="92.8" y="14">-3.8% vs prev</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 947 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="coverage: 44%">
<title>coverage: 44%</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="95.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="64.0" height="20" fill="#555"/>
<rect x="64.0" width="31.5" height="20" fill="#dfb317"/>
<rect width="95.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="32.0" y="15" fill="#010101" fill-opacity=".3">coverage</text>
<text x="32.0" y="14">coverage</text>
<text x="79.8" y="15" fill="#010101" fill-opacity=".3">44%</text>
<text x="79.8" y="14">44%</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 919 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="dependencies: 349">
<title>dependencies: 349</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="121.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="90.0" height="20" fill="#555"/>
<rect x="90.0" width="31.5" height="20" fill="#007ec6"/>
<rect width="121.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="45.0" y="15" fill="#010101" fill-opacity=".3">dependencies</text>
<text x="45.0" y="14">dependencies</text>
<text x="105.8" y="15" fill="#010101" fill-opacity=".3">349</text>
<text x="105.8" y="14">349</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 940 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="89.0" height="20" role="img" aria-label="license: MIT">
<title>license: MIT</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="89.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="57.5" height="20" fill="#555"/>
<rect x="57.5" width="31.5" height="20" fill="#007ec6"/>
<rect width="89.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="28.8" y="15" fill="#010101" fill-opacity=".3">license</text>
<text x="28.8" y="14">license</text>
<text x="73.2" y="15" fill="#010101" fill-opacity=".3">MIT</text>
<text x="73.2" y="14">MIT</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 915 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="lines of code: 13.3k">
<title>lines of code: 13.3k</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="141.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="96.5" height="20" fill="#555"/>
<rect x="96.5" width="44.5" height="20" fill="#007ec6"/>
<rect width="141.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="48.2" y="15" fill="#010101" fill-opacity=".3">lines of code</text>
<text x="48.2" y="14">lines of code</text>
<text x="118.8" y="15" fill="#010101" fill-opacity=".3">13.3k</text>
<text x="118.8" y="14">13.3k</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 952 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="clippy: clean">
<title>clippy: clean</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="95.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="51.0" height="20" fill="#555"/>
<rect x="51.0" width="44.5" height="20" fill="#4c1"/>
<rect width="95.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="25.5" y="15" fill="#010101" fill-opacity=".3">clippy</text>
<text x="25.5" y="14">clippy</text>
<text x="73.2" y="15" fill="#010101" fill-opacity=".3">clean</text>
<text x="73.2" y="14">clean</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 916 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="tests: 93 passing">
<title>tests: 93 passing</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="121.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="44.5" height="20" fill="#555"/>
<rect x="44.5" width="77.0" height="20" fill="#4c1"/>
<rect width="121.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">tests</text>
<text x="22.2" y="14">tests</text>
<text x="83.0" y="15" fill="#010101" fill-opacity=".3">93 passing</text>
<text x="83.0" y="14">93 passing</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 935 B

+98
View File
@@ -0,0 +1,98 @@
#!/usr/bin/env python3
"""Compute the weighted-average microbenchmark delta versus the previous release.
Reads the captured stdout of `cargo test ... --ignored --nocapture bench_` (whose
timings are Rust `Duration` Debug strings: "12.3ms", "512us"/"512µs", "840ns",
"1.2s"), compares each bench to a committed baseline of the previous release's
numbers, and prints the time-weighted average change as a signed percentage:
(sum(current) / sum(baseline) - 1) * 100 over benches present in both
Weighting by duration means the slow benches dominate, so the number tracks
overall wall-time change rather than giving a tiny bench equal say. Then the
baseline is rewritten with the current numbers, so the next release compares
against this one ("the previous commit").
Usage:
bench-badge.py --current bench-current.txt --baseline badges/bench-baseline.json
Prints the delta as a plain number (e.g. "-3.2", or "NEW" when there is no
usable baseline) to stdout. The baseline JSON lives under badges/ so committing
it back does not trip compute-version.sh's path-based release bump.
"""
import argparse
import json
import os
import re
import sys
# A Duration Debug token: a number immediately followed by a time unit, with the
# multi-char units listed before the bare "s" so alternation prefers them. The
# trailing (?![a-zA-Z]) stops "s" in words like "rows"/"cidrs" from matching.
_DUR = re.compile(r"([0-9]+(?:\.[0-9]+)?)\s*(ns|µs|us|ms|s)(?![a-zA-Z])")
_UNIT_NS = {"ns": 1.0, "us": 1e3, "µs": 1e3, "ms": 1e6, "s": 1e9}
_NAME = re.compile(r"^(bench_[A-Za-z0-9_]+)\s*:")
def parse_bench(text: str) -> dict:
"""Map each bench name to its timing in nanoseconds (the last Duration on the
line, since every bench prints its timing last)."""
out = {}
for line in text.splitlines():
m = _NAME.match(line.strip())
if not m:
continue
durs = _DUR.findall(line)
if not durs:
continue
val, unit = durs[-1]
out[m.group(1)] = float(val) * _UNIT_NS[unit]
return out
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--current", required=True, help="captured bench stdout")
ap.add_argument("--baseline", required=True, help="baseline JSON (read + rewrite)")
ap.add_argument("--no-write", action="store_true", help="do not update the baseline")
args = ap.parse_args()
try:
with open(args.current, encoding="utf-8") as fh:
current = parse_bench(fh.read())
except OSError as e:
print(f"bench-badge: cannot read current results: {e}", file=sys.stderr)
print("NEW")
return 0
if not current:
print("bench-badge: no bench lines parsed from current results", file=sys.stderr)
print("NEW")
return 0
baseline = {}
try:
with open(args.baseline, encoding="utf-8") as fh:
baseline = {k: float(v) for k, v in json.load(fh).items()}
except (OSError, ValueError):
baseline = {}
common = [k for k in current if k in baseline and baseline[k] > 0]
if common:
sum_new = sum(current[k] for k in common)
sum_old = sum(baseline[k] for k in common)
delta = (sum_new / sum_old - 1.0) * 100.0 if sum_old > 0 else 0.0
print(f"{delta:.1f}")
else:
print("NEW")
if not args.no_write:
os.makedirs(os.path.dirname(args.baseline) or ".", exist_ok=True)
with open(args.baseline, "w", encoding="utf-8") as fh:
json.dump({k: round(v, 1) for k, v in sorted(current.items())}, fh, indent=2)
fh.write("\n")
return 0
if __name__ == "__main__":
sys.exit(main())
+11 -6
View File
@@ -2,9 +2,10 @@
# Compute the next release version for alkane-toolkit from the latest release
# tag and the paths changed since it. Version scheme X.Y.Z:
# X - major, bumped manually (ci/version-x.txt); a bump resets Y.Z to 0.0
# Y - backend-logic changes (core/discovery/access/flash/artifacts/cli,
# scan+model+main in the GUI crate, build/CI config); resets Z to 0
# Z - UI changes (the GUI view + fixtures + the wx-rs widget bridge)
# Y - backend-logic changes (the alkane-* crates and any GUI crate source
# other than the view files below, plus vendored deps and build/CI config);
# resets Z to 0
# Z - UI changes (the GUI view: ui.rs + fixtures.rs + bin/ + the wx-rs bridge)
# When both backend and UI changed, backend wins (bump Y). Docs-only changes
# produce no release.
#
@@ -30,12 +31,16 @@ 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/*|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
vendor/*|thirdparty/asic-rs/*)
# Any other GUI source file (naming, scan, model, pool_prefs, restore,
# access_probe, credentials, ...) is backend logic. ui.rs/fixtures.rs/bin
# match the UI arm above first, so they still bump Z, not Y.
backend=true ;;
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
esac
+37
View File
@@ -0,0 +1,37 @@
#!/usr/bin/env bash
# Measure line coverage from BOTH the unit tests AND the headless UI self-test.
#
# The self-test (ALKANE_SELFTEST=1) builds the real wxWidgets table, renders every
# fixture through the real widgets, and checks each cell against the model -- it
# exercises most of ui.rs. Because it runs as a separate binary invocation, a plain
# `cargo llvm-cov` (which only runs the #[test]s) never counts it, so ui.rs shows
# ~4% even though it is integration-tested. This combines both runs' coverage.
#
# Usage: ci/coverage.sh [extra `cargo llvm-cov report` args, e.g. --summary-only]
set -euo pipefail
export WX_RS_WXCONFIG="${WX_RS_WXCONFIG:-$HOME/.cache/wx-3.3.3-linux/bin/wx-config}"
# The dependency tree is fully vendored, so the instrumented builds run offline by
# default; override with CARGO_LLVM_COV_FLAGS if you need something else.
read -ra CARGO_FLAGS <<<"${CARGO_LLVM_COV_FLAGS:---offline}"
# A display for the self-test's real widgets.
need_xvfb() { command -v xvfb-run >/dev/null 2>&1; }
cargo llvm-cov clean --workspace
# 1. Unit tests.
cargo llvm-cov --no-report "${CARGO_FLAGS[@]}" -p alkane-gui --bin alkane-toolkit
# 2. Headless UI self-test, under the same instrumentation, its coverage appended.
if need_xvfb; then
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 \
cargo llvm-cov run --no-report "${CARGO_FLAGS[@]}" --bin alkane-toolkit
else
echo "coverage.sh: xvfb-run not found; skipping the self-test run (unit tests only)" >&2
fi
# 3. Merged report, our source only (vendored asic-rs + the patched wx-rs bridge
# are out of scope).
cargo llvm-cov report --ignore-filename-regex '(thirdparty|vendor)/' "$@"
+195
View File
@@ -0,0 +1,195 @@
#!/usr/bin/env python3
"""Generate self-contained shields-style SVG badges into badges/.
Self-hosted Gitea renders a README's relative image links straight from the
repo, so committing the SVGs (rather than depending on an external badge
service that would have to reach a possibly-private Gitea) is the robust choice.
CI regenerates them from live metrics and commits any changes back.
Usage:
gen-badges.py --tests N --coverage PCT --bench "label" [--out badges]
Metrics not passed on the command line are computed here (LOC from the source
tree, dependency count from Cargo.lock, license from Cargo.toml).
"""
import argparse
import os
import re
import sys
# Approximate per-character width at 11px DejaVu Sans, in 1/10 px, matching the
# shields "flat" look closely enough for a fixed-width monospace-ish render.
CHAR_W = 6.5
PAD = 6.0
COLORS = {
"green": "#4c1",
"brightgreen": "#4c1",
"yellowgreen": "#a4a61d",
"yellow": "#dfb317",
"orange": "#fe7d37",
"red": "#e05d44",
"blue": "#007ec6",
"lightgrey": "#9f9f9f",
"grey": "#555",
}
def text_width(s: str) -> float:
return len(s) * CHAR_W + 2 * PAD
def badge_svg(label: str, message: str, color: str) -> str:
color = COLORS.get(color, color)
lw = round(text_width(label), 1)
mw = round(text_width(message), 1)
total = round(lw + mw, 1)
lx = round(lw / 2, 1)
mx = round(lw + mw / 2, 1)
# Text is drawn twice (a dark shadow then the light glyphs) for the shields look.
return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total}" height="20" role="img" aria-label="{label}: {message}">
<title>{label}: {message}</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="{total}" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="{lw}" height="20" fill="#555"/>
<rect x="{lw}" width="{mw}" height="20" fill="{color}"/>
<rect width="{total}" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="{lx}" y="15" fill="#010101" fill-opacity=".3">{label}</text>
<text x="{lx}" y="14">{label}</text>
<text x="{mx}" y="15" fill="#010101" fill-opacity=".3">{message}</text>
<text x="{mx}" y="14">{message}</text>
</g>
</svg>
'''
def count_loc(root: str) -> int:
total = 0
for base in ("crates",):
for dirpath, _dirs, files in os.walk(os.path.join(root, base)):
for f in files:
if f.endswith(".rs"):
try:
with open(os.path.join(dirpath, f), encoding="utf-8", errors="ignore") as fh:
total += sum(1 for _ in fh)
except OSError:
pass
return total
def count_deps(root: str) -> int:
lock = os.path.join(root, "Cargo.lock")
try:
with open(lock, encoding="utf-8") as fh:
return sum(1 for line in fh if line.startswith("name = "))
except OSError:
return 0
def read_license(root: str) -> str:
try:
with open(os.path.join(root, "Cargo.toml"), encoding="utf-8") as fh:
for line in fh:
m = re.match(r'\s*license\s*=\s*"([^"]+)"', line)
if m:
return m.group(1)
except OSError:
pass
return "unknown"
def loc_color(n: int) -> str:
return "blue"
def bench_color(delta_pct: float) -> str:
# Negative delta = faster than the previous release. A +/-2% dead band absorbs
# the run-to-run jitter of microbenchmarks on a shared CI runner.
if delta_pct <= -2.0:
return "brightgreen"
if delta_pct < 2.0:
return "blue"
if delta_pct < 10.0:
return "yellow"
return "orange"
def cov_color(pct: float) -> str:
if pct >= 80:
return "brightgreen"
if pct >= 60:
return "yellowgreen"
if pct >= 40:
return "yellow"
if pct >= 20:
return "orange"
return "red"
def human(n: int) -> str:
if n >= 1000:
return f"{n / 1000:.1f}k".replace(".0k", "k")
return str(n)
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--out", default="badges")
ap.add_argument("--root", default=".")
ap.add_argument("--tests", type=int, default=None)
ap.add_argument("--coverage", type=float, default=None)
ap.add_argument("--bench", default=None)
# Weighted-average microbench delta vs the previous release, as a signed
# percentage string (e.g. "-3.2"), or "NEW"/"" when there is no baseline yet
# (round 19 #1). Takes precedence over --bench for the bench badge.
ap.add_argument("--bench-delta", default=None)
ap.add_argument("--clippy", default="clean")
args = ap.parse_args()
os.makedirs(os.path.join(args.root, args.out), exist_ok=True)
def write(name, label, message, color):
path = os.path.join(args.root, args.out, name + ".svg")
with open(path, "w", encoding="utf-8") as fh:
fh.write(badge_svg(label, message, color))
print(f"wrote {path}: {label}={message}")
loc = count_loc(args.root)
deps = count_deps(args.root)
lic = read_license(args.root)
write("loc", "lines of code", human(loc), loc_color(loc))
write("license", "license", lic, "blue")
write("dependencies", "dependencies", str(deps), "blue")
write("quality", "clippy", args.clippy, "brightgreen" if args.clippy == "clean" else "orange")
if args.tests is not None:
write("tests", "tests", f"{args.tests} passing", "brightgreen")
if args.coverage is not None:
write("coverage", "coverage", f"{args.coverage:.0f}%", cov_color(args.coverage))
# Bench badge: prefer the weighted-average delta vs the previous release; fall
# back to the static label (first run, or when the delta could not be computed).
delta = None
if args.bench_delta not in (None, "", "NEW"):
try:
delta = float(args.bench_delta)
except ValueError:
delta = None
if delta is not None:
# Negative = faster than the previous release (good).
msg = f"{'+' if delta > 0 else ''}{delta:.1f}% vs prev"
write("bench", "bench", msg, bench_color(delta))
elif args.bench_delta == "NEW":
write("bench", "bench", "baseline set", "blue")
elif args.bench is not None:
write("bench", "bench", args.bench, "blue")
return 0
if __name__ == "__main__":
sys.exit(main())
+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

+335
View File
@@ -0,0 +1,335 @@
//! 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") {
// Try the caller's saved scan password first (round 18 #12: it was being
// ignored for WhatsMiner, so a miner opened with the operator's real
// password was mis-reported as locked), then the per-firmware override and
// factory defaults. All attempts are non-mutating.
let mut candidates = Vec::new();
if !pass.is_empty() {
candidates.push(pass.to_string());
}
for c in whatsminer_password_candidates() {
if !candidates.contains(&c) {
candidates.push(c);
}
}
return Ok(probe_whatsminer_access(ip, &candidates));
}
let url = format!("http://{ip}{}", endpoint(make));
let mut cmd = Command::new("curl");
cmd.args([
"-s",
"-o",
"/dev/null",
"-w",
"%{http_code}",
"--digest",
"--connect-timeout",
"5",
"--max-time",
"9",
"-K",
"-", // read the rest of the config (the credentials) from stdin
&url,
]);
// The user:pass goes through a curl config on stdin, never argv, so it can't
// be read from the process list (round 18 #12).
let config = format!("user = \"{}\"\n", curl_config_quote(&format!("{user}:{pass}")));
let out = wait_with_timeout(cmd, Duration::from_secs(12), Some(config.as_bytes()))?;
// 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). `stdin_data`, when set, is written to the child's stdin and
/// the pipe closed -- used to feed a curl config (with the credentials) instead
/// of putting them on the command line (round 18 #12).
fn wait_with_timeout(
mut cmd: Command,
timeout: Duration,
stdin_data: Option<&[u8]>,
) -> Result<std::process::Output, String> {
use std::io::{Read, Write};
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
if stdin_data.is_some() {
cmd.stdin(std::process::Stdio::piped());
}
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
if let Some(data) = stdin_data {
if let Some(mut si) = child.stdin.take() {
let _ = si.write_all(data);
} // dropping `si` closes the pipe so curl stops reading the config
}
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();
let _ = child.wait(); // reap so we never leave a zombie (round 18 #12)
return Err("curl timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
}
}
}
}
/// Escape a value for a curl `--config` file (double-quoted string).
fn curl_config_quote(s: &str) -> String {
s.replace('\\', "\\\\").replace('"', "\\\"")
}
/// 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;
// A transient error on one candidate must not abandon the others (round 18 #12):
// skip to the next candidate, but remember it happened so we never report a
// confident "locked" when the answer was really indeterminate.
let mut errored = 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(_) => {
errored = true;
continue;
}
};
let v: serde_json::Value = match serde_json::from_str(&tok_resp) {
Ok(v) => v,
Err(_) => {
errored = true;
continue;
}
};
let (Some(salt), Some(newsalt), Some(time)) = v
.get("Msg")
.map(|msg| {
(
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()),
)
})
.unwrap_or((None, None, None))
else {
errored = true;
continue;
};
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(_) => {
errored = true;
continue;
}
};
if resp.contains("\"enc\"") {
return Some(false); // accepted -> unlocked/writable
}
// rejected -> try the next candidate password
}
// Only report "locked" when we cleanly reached the miner and every candidate
// was rejected with no transient errors; otherwise the result is indeterminate.
if reachable && !errored { 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=")
);
}
}
+756
View File
@@ -0,0 +1,756 @@
//! 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
//! and 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 {
// This diagnostic CLI is a separate binary from the GUI, so it cannot share
// the GUI's credentials::configured_factory. It applies only the global scan
// credentials to every firmware; the GUI's per-firmware credential overrides
// are NOT read here (round 18 #12), which the message below makes explicit so a
// probe result is never mistaken for what the GUI (with overrides) would see.
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 the global scan credentials; per-firmware overrides are not applied)");
} 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={:?} freq={:?}MHz volt={:?}V",
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()),
b.frequency.as_ref().map(|f| f.as_megahertz()),
b.voltage.as_ref().map(|v| v.as_volts()),
);
}
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}"),
}
}
/// READ-ONLY: dump a miner's structured-tuning surface -- what it supports, its
/// current target, and the capability envelope (power/hashrate min-max, or the
/// preset/mode list) the firmware advertises. Drives the round-17 C tuning work:
/// it shows what each live firmware actually offers before any write is wired up.
async fn tune(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;
println!(
"{ip}: {} {} {}",
data.device_info.make, data.device_info.firmware, data.device_info.model
);
println!(
" supports: power_limit={} tuning_percent={} tuning_config={}",
m.supports_set_power_limit(),
m.supports_set_tuning_percent(),
m.supports_tuning_config(),
);
println!(" psu={:?}", data.psu);
println!(" tuning_percent={:?}", data.tuning_percent);
println!(" tuning_target={:?}", data.tuning_target);
match &data.tuning_capabilities {
Some(c) => {
println!(" caps.power={:?}", c.power);
println!(" caps.hashrate={:?}", c.hashrate);
match &c.presets {
Some(p) => {
println!(" caps.presets.default={:?}", p.default);
println!(" caps.presets[{}]:", p.presets.len());
for t in &p.presets {
println!(" - {t:?}");
}
}
None => println!(" caps.presets=None"),
}
}
None => println!(" tuning_capabilities=None"),
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// WRITE (reversible): apply a structured tuning target via set_tuning_config.
/// `settune <ip> power <watts>` or `settune <ip> hashrate <ths>`. Prints the
/// prior target so the caller can restore it. Used to verify the set_tuning_config
/// path on live corpus hardware (round 17 C) before wiring it into the GUI.
async fn settune(ip_s: &str, kind: &str, value: f64) {
use asic_rs::core::config::tuning::TuningConfig;
use asic_rs::core::data::hashrate::HashRateUnit;
use asic_rs::core::data::miner::TuningTarget;
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 before = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_tuning_config={}); prior target = {:?}",
before.device_info.make,
before.device_info.firmware,
before.device_info.model,
m.supports_tuning_config(),
before.tuning_target,
);
let target = match kind {
"power" => TuningTarget::Power(Power::from_watts(value)),
// Clone the miner's current HashRate to inherit its algorithm
// (HashAlgorithm is not publicly re-exported, so it cannot be named
// directly), overriding just the value and unit.
"hashrate" => match before.hashrate.clone() {
Some(mut hr) => {
hr.value = value;
hr.unit = HashRateUnit::TeraHash;
TuningTarget::HashRate(hr)
}
None => {
eprintln!("miner reports no current hashrate; cannot build a hashrate target");
return;
}
},
_ => {
eprintln!("kind must be 'power' or 'hashrate'");
return;
}
};
// Route by what the firmware actually supports: structured
// set_tuning_config where available (ePIC/VNish/WM), else the plain
// power-limit setter for a power target (LuxOS/Braiins tune by power
// and expose no set_tuning_config).
if m.supports_tuning_config() {
// Mirror the GUI apply path: preserve the firmware's current tuning
// algorithm + scaling (ePIC requires both for set_tuning_config).
let mut cfg = TuningConfig::new(target);
if let Some(algo) = m.get_tuning_config().await.ok().and_then(|c| c.algorithm) {
cfg = cfg.with_algorithm(algo);
}
let scaling = m.get_scaling_config().await.ok();
match m.set_tuning_config(cfg, scaling).await {
Ok(v) => println!("set_tuning_config({kind} {value}) -> Ok({v})"),
Err(e) => println!("set_tuning_config({kind} {value}) -> Err: {e:#}"),
}
} else if kind == "power" && m.supports_set_power_limit() {
match m.set_power_limit(Power::from_watts(value)).await {
Ok(v) => println!("set_power_limit({value} W) -> Ok({v}) [tuning_config unsupported]"),
Err(e) => println!("set_power_limit({value} W) -> Err: {e:#}"),
}
} else {
println!("no structured-tuning path for {kind} on this firmware");
}
let after = m.get_data().await;
println!(" target now = {:?}", after.tuning_target);
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// READ: list the firmware's selectable profiles/presets (roadmap G3).
async fn presets(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)) => {
if !m.supports_presets() {
println!("{ip}: firmware does not expose named presets");
return;
}
let list = m.get_presets().await;
if list.is_empty() {
println!("{ip}: no presets reported");
return;
}
for p in list {
match (p.pretty, p.status) {
(Some(pretty), Some(status)) => println!("{}\t{pretty}\t[{status}]", p.name),
(Some(pretty), None) => println!("{}\t{pretty}", p.name),
(None, _) => println!("{}", p.name),
}
}
}
Ok(None) => eprintln!("no miner at {ip}"),
Err(e) => eprintln!("scan_miner {ip}: {e}"),
}
}
/// WRITE (reversible): select a named firmware profile/preset (roadmap G3).
/// `setpreset <ip> <name>`. Prints the prior target so it can be restored.
async fn setpreset(ip_s: &str, name: &str) {
use asic_rs::core::config::tuning::TuningConfig;
use asic_rs::core::data::miner::TuningTarget;
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 before = m.get_data().await;
eprintln!(
"target {ip}: {} {} {} (supports_presets={}); prior target = {:?}",
before.device_info.make,
before.device_info.firmware,
before.device_info.model,
m.supports_presets(),
before.tuning_target,
);
let cfg = TuningConfig::new(TuningTarget::Preset(name.to_string()));
match m.set_tuning_config(cfg, None).await {
Ok(v) => println!("set_tuning_config(preset {name}) -> Ok({v})"),
Err(e) => println!("set_tuning_config(preset {name}) -> Err: {e:#}"),
}
let after = m.get_data().await;
println!(" target now = {:?}", after.tuning_target);
}
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("tune") if args.len() == 3 => rt.block_on(tune(&args[2])),
Some("presets") if args.len() == 3 => rt.block_on(presets(&args[2])),
Some("setpreset") if args.len() == 4 => rt.block_on(setpreset(&args[2], &args[3])),
Some("settune") if args.len() == 5 && matches!(args[3].as_str(), "power" | "hashrate") => {
let value: f64 = args[4].parse().unwrap_or(-1.0);
if value <= 0.0 {
eprintln!("value must be a positive number");
std::process::exit(2);
}
rt.block_on(settune(&args[2], &args[3], value));
}
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\
\x20 tune <ip> structured-tuning support + capability envelope\n\
\x20 presets <ip> list selectable firmware profiles/presets\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 settune <ip> <power|hashrate> <v> set a structured tuning target (prints prior)\n\
\x20 setpreset <ip> <name> select a named firmware profile/preset (prints prior)\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);
}
}
}
+300
View File
@@ -0,0 +1,300 @@
//! 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 {
// Apply the operator's configured identification timeout to every factory
// (round 18 #12: config actions / refresh / pools / flash previously used
// asic-rs's 10s default, so on a slow link they could fail to reach miners a
// longer-timeout scan had found). start_scan may still override it explicitly.
let mut factory =
MinerFactory::new().with_identification_timeout_secs(crate::scan::load_scan_timeout().max(1));
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 serialise against other HOME-mutating tests via the
// shared lock and restore HOME afterward (round 18 #12).
let _home = crate::model::HOME_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
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);
}
}
+246
View File
@@ -0,0 +1,246 @@
//! 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};
/// A compact UTC timestamp "YYYYMMDD-HHMMSS" for a default export filename
/// (round 19 #5). UTC keeps this dependency-free (no chrono) and unambiguous.
pub fn timestamp_utc() -> String {
let secs = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let sod = secs % 86_400;
let (h, mi, s) = (sod / 3600, (sod % 3600) / 60, sod % 60);
// Civil date from days since 1970-01-01 (Howard Hinnant's civil_from_days).
let z = (secs / 86_400) as i64 + 719_468;
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
let doe = z - era * 146_097; // [0, 146096]
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; // [0, 399]
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
let mp = (5 * doy + 2) / 153; // [0, 11]
let d = doy - (153 * mp + 2) / 5 + 1; // [1, 31]
let m = if mp < 10 { mp + 3 } else { mp - 9 }; // [1, 12]
let y = yoe + era * 400 + i64::from(m <= 2);
format!("{y:04}{m:02}{d:02}-{h:02}{mi:02}{s:02}")
}
/// Escape one CSV field: neutralise spreadsheet formula injection, then quote it
/// when it contains a comma, quote, CR or LF (doubling any embedded quotes).
///
/// Miner-supplied fields (hostname, worker, serial, ...) can start with a formula
/// trigger; prefixing a single quote makes Excel/Sheets treat the cell as text so
/// opening the export can't execute an injected formula (round 18 #12).
fn esc(s: &str) -> String {
let mut val = s.to_string();
if val.starts_with(['=', '+', '-', '@', '\t', '\r']) {
val.insert(0, '\'');
}
if val.contains([',', '"', '\n', '\r']) {
format!("\"{}\"", val.replace('"', "\"\""))
} else {
val
}
}
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("; ")),
]
}
// Group keys for the four variable-length field families (each expands to
// per-index columns). Shown as single checkboxes in the export picker (round 19 #6).
pub const GROUP_BOARD_TEMPS: &str = "board temps";
pub const GROUP_FANS: &str = "fan rpms";
pub const GROUP_BOARD_STATUS: &str = "board status";
pub const GROUP_POOLS: &str = "pools";
/// Every selectable export field, in output order: each scalar column header,
/// then the four variable-length group keys.
pub fn export_field_names() -> Vec<String> {
let mut v: Vec<String> = scalar_columns().iter().map(|(h, _)| (*h).to_string()).collect();
v.push(GROUP_BOARD_TEMPS.to_string());
v.push(GROUP_FANS.to_string());
v.push(GROUP_BOARD_STATUS.to_string());
v.push(GROUP_POOLS.to_string());
v
}
/// Build the CSV for `rows` including only the selected fields (scalar column
/// headers and/or the group keys above), in the fixed output order (round 19 #6).
/// Empty rows still emit a header line.
pub fn rows_to_csv_selected(
rows: &[MinerRow],
selected: &std::collections::HashSet<String>,
) -> String {
let cols: Vec<Col> =
scalar_columns().into_iter().filter(|(h, _)| selected.contains(*h)).collect();
// A group's columns appear only when it is selected; an unselected group's
// width stays 0, so the header/value loops below emit nothing for it.
let width = |want: bool, f: &dyn Fn(&MinerRow) -> usize| -> usize {
if want { rows.iter().map(f).max().unwrap_or(0) } else { 0 }
};
let max_board_temps = width(selected.contains(GROUP_BOARD_TEMPS), &|r| r.board_temps.len());
let max_fans = width(selected.contains(GROUP_FANS), &|r| r.fan_rpms.len());
let max_boards = width(selected.contains(GROUP_BOARD_STATUS), &|r| r.board_status.len());
let max_pools = width(selected.contains(GROUP_POOLS), &|r| r.pools.len());
// 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 all: std::collections::HashSet<String> = export_field_names().into_iter().collect();
let csv = rows_to_csv_selected(&rows, &all);
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");
}
}
+190 -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,119 @@ 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![]
};
// Per-board hashrate for the R2 Health tooltip demo: split the total three
// ways with a little variety (index-aligned with the 3 boards).
let board_hashrates = if self.mining && self.hashrate > 0.0 {
vec![self.hashrate * 0.34, self.hashrate * 0.35, self.hashrate * 0.31]
} else {
vec![]
};
// Per-board configured frequency/voltage for the G7 read-side tooltip demo.
let (board_frequencies, board_voltages) = if self.mining {
(vec![590.0, 590.0, 565.0], vec![13.50, 13.50, 13.35])
} else {
(vec![], 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 if self.paused {
// A paused miner's boards are physically present but idle (asic-rs
// reports active=false -> Fault), so the Health column shows them blue
// rather than red (round 19 #19); the offline demo mirrors that.
vec![Fault, Fault, Fault]
} 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);
// Computed before `model` is moved into the struct literal below.
let pic_present = crate::scan::infer_pic(&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,
board_hashrates,
board_voltages,
board_frequencies,
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 },
// PSU info demo (round 17 R5): mining units show a version + rated
// envelope + live output, so the columns and the R2 PSU tooltip render.
psu_version: if self.mining { "22 (117)".to_string() } else { String::new() },
psu_voltage_min_v: self.mining.then_some(11.88),
psu_voltage_max_v: self.mining.then_some(15.18),
psu_out_voltage_v: self.mining.then_some(13.2),
psu_out_current_a: self.mining.then_some(210.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 +170,108 @@ 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,
hashrate_target: self.mining,
supports_presets: 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,
// Use the same PIC inference the live scan uses (round 18 #12: the demo
// previously reimplemented a simplified version that disagreed with it).
pic_present,
// 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()
},
// Demo firmware presets (round 18 / G3) so the "Set profile..." dialog
// is exercisable offline on units that advertise preset support.
presets: if self.mining {
vec![
crate::model::MinerPreset { name: "default".into(), pretty: Some("2794 W ~ 121.8 TH @ 590 MHz".into()) },
crate::model::MinerPreset { name: "540MHz".into(), pretty: Some("2485 W ~ 111.5 TH @ 540 MHz".into()) },
crate::model::MinerPreset { name: "490MHz".into(), pretty: Some("2192 W ~ 101.1 TH @ 490 MHz".into()) },
]
} 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: "Hiveon", fw_version: "1.05",
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: "0.9.9.4",
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"]),
];
+83
View File
@@ -0,0 +1,83 @@
//! Fetch a miner's log for the "View log (API)" viewer (round 12 #12, reworked
//! round 19 #11-16).
//!
//! The log is fetched through asic-rs's per-backend `read_logs()` API, which
//! knows each firmware's real transport (Antminer/Z15 + BixBit stock web,
//! Braiins gRPC/journal, VNish and ePIC HTTP, ...). This replaced the GUI's
//! narrow three-way curl fetch, whose stock `/cgi-bin/log.cgi` `else` branch
//! failed on every firmware that does not serve that CGI (Braiins, LuxOS, Z15,
//! BixBit).
//!
//! WhatsMiner is the exception: its btminer log is not exposed over the API, and
//! asic-rs has no `read_logs` for it, so the viewer falls back to the active
//! fault codes (get_error_code on :4028, unauthenticated). LuxOS likewise has no
//! asic-rs log API and reports the log as unavailable.
/// Cap on the log text we keep for display (bytes); a miner's freshest lines are
/// at the tail, so we keep the tail.
const MAX_LOG_BYTES: usize = 256 * 1024;
/// A fetched log for the viewer.
pub struct LogScan {
/// The (possibly tail-trimmed) log text.
pub text: String,
}
/// Fetch one miner's log. `brand` is the make ("Antminer"/"Whatsminer"/...);
/// `timeout_secs` is the per-miner identification timeout. Returns `Err` only
/// when no log could be read.
pub fn scan_log(ip: &str, brand: &str, timeout_secs: u64) -> Result<LogScan, String> {
// WhatsMiner's real log is not exposed over its API and asic-rs has no
// read_logs for it, so show the active fault codes instead of failing.
if brand.eq_ignore_ascii_case("whatsminer") {
let resp = crate::access_probe::whatsminer_get_error_code(ip)
.ok_or_else(|| "WhatsMiner did not answer get_error_code on :4028".to_string())?;
return Ok(LogScan { text: tail(&resp, MAX_LOG_BYTES) });
}
let text = crate::scan::fetch_log(ip, timeout_secs)?;
if text.trim().is_empty() {
return Err("the miner returned an empty log".to_string());
}
Ok(LogScan { text: tail(&text, MAX_LOG_BYTES) })
}
/// 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();
}
// Nudge the cut forward to a UTF-8 char boundary first: a raw byte offset can
// land inside a multi-byte character and slicing there would panic (round 18
// #12; miner logs are not guaranteed pure ASCII).
let mut start = s.len() - max;
while start < s.len() && !s.is_char_boundary(start) {
start += 1;
}
// then 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..])
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tail_does_not_panic_mid_multibyte_char() {
// A byte-offset cut can land inside a multi-byte character; tail must nudge
// to a char boundary rather than panic (round 18 #12).
let s = "\u{00e9}".repeat(200); // 400 bytes of 2-byte chars, no newlines
let out = tail(&s, 101); // cut at an odd offset -> inside a char
assert!(out.starts_with("[... earlier log trimmed ...]"));
assert!(out.len() < s.len());
}
#[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();
}
}
+46 -1
View File
@@ -1,12 +1,21 @@
//! 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;
use wx_rs;
fn main() {
// Headless workflow self-test: render the bench-fleet fixtures through the
@@ -16,6 +25,42 @@ 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>"` fetches the miner's
// log through asic-rs's per-backend read_logs() (round 19 #11-16), so the log
// paths can be verified without the GUI. WhatsMiner falls back to fault codes.
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("");
match log_scan::scan_log(ip, brand, scan::load_scan_timeout()) {
Ok(s) => println!("LOGSCAN {ip} ({brand}): {} log bytes", s.text.len()),
Err(e) => println!("LOGSCAN {ip} ({brand}): 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
+435
View File
@@ -0,0 +1,435 @@
//! 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.
// `get(..9)` returns None (rather than panicking) when byte 9 is not a UTF-8
// char boundary, so a multibyte miner-supplied model string can't crash here
// (round 18 #12). The prefix is 9 ASCII bytes, so a real match implies a
// boundary at 9 and the following `id[9..]` is safe.
let id = match id.get(..9) {
Some(p) if p.eq_ignore_ascii_case("ANTMINER ") => id[9..].trim_start(),
_ => 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 {
// Per the doc above: XP-class, the S19k Pro, and the S21 Pro -- NOT every S21
// (plain S21 / S21+ / S21e are the 120mm C76 board) (round 18 #12).
let m = clean_model.trim_start();
m.contains("XP") || m.starts_with("S19k") || m.contains("S21 Pro")
}
/// Nameplate expected hashrate in Sol/s for an Equihash (Zcash) miner model, when
/// the firmware itself does not report an expected hashrate (round 18 #6). Plain
/// Antminer Z15 firmware omits the cgminer `total_rateideal` field (the Z15j does
/// report it), so its actual-vs-expected column and colour would otherwise be
/// blank. The Z15 nameplate is 420 KSol/s. Returns `None` for models with no known
/// nameplate (the caller then leaves expected unknown).
pub fn equihash_expected_sols(clean_model: &str) -> Option<f64> {
let m = clean_model.to_ascii_lowercase();
// Match the Z15 family (z15, z15j); both share the 420 KSol/s nameplate.
if m.contains("z15") {
Some(420_000.0)
} else {
None
}
}
#[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++"));
}
}
+169
View File
@@ -0,0 +1,169 @@
//! 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. "Add new..." opens a manager window that edits the whole saved
//! list at once (round 18 #8b). 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()
}
/// Replace `field`'s entire saved list with `values` (round 18 #8b: the preset
/// manager edits the whole list at once). Each value is trimmed; empties, exact
/// duplicates, and any value that is already a built-in preset are dropped.
/// Returns the number of values actually written.
pub fn save_all(field: PoolField, values: &[String]) -> std::io::Result<usize> {
let out = dedupe_saved(&field.presets(), values);
let p = config_path(field.saved_file());
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
// The password list can hold a pool password, so write it owner-only from the
// moment it is created -- never briefly world-readable (round 18 #12).
write_private(&p, out.join("\n").as_bytes())?;
Ok(out.len())
}
/// Write `data` to `path` with owner-only (0600) permissions from creation on
/// Unix, so a secret is never momentarily world-readable between write and chmod.
/// `mode()` only takes effect when the file is created, so an already-existing
/// file is also re-tightened; elsewhere this is a plain write.
fn write_private(path: &std::path::Path, data: &[u8]) -> std::io::Result<()> {
#[cfg(unix)]
{
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(path)?;
let _ = std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600));
f.write_all(data)
}
#[cfg(not(unix))]
{
std::fs::write(path, data)
}
}
/// Trim every value, then drop empties, values equal to a built-in preset, and
/// later exact duplicates (first occurrence wins). Order is otherwise preserved.
fn dedupe_saved(presets: &[&str], values: &[String]) -> Vec<String> {
let mut out: Vec<String> = Vec::new();
for v in values {
let v = v.trim();
if v.is_empty() || presets.contains(&v) || out.iter().any(|s| s == v) {
continue;
}
out.push(v.to_string());
}
out
}
/// 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
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dedupe_saved_trims_drops_empties_presets_and_dupes() {
let presets = ["x", "{ip1}"];
let vals: Vec<String> = [" ", "myworker", "myworker", "x", " keep ", "{ip1}", "keep"]
.iter()
.map(|s| s.to_string())
.collect();
// " " (empty), the second "myworker", "x"/"{ip1}" (presets) and the second
// "keep" all drop; " keep " is trimmed and kept.
assert_eq!(dedupe_saved(&presets, &vals), vec!["myworker".to_string(), "keep".to_string()]);
}
#[test]
fn dedupe_saved_empty_input_is_empty() {
assert!(dedupe_saved(&[], &[]).is_empty());
}
}
+155
View File
@@ -0,0 +1,155 @@
//! 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));
// 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::Fan1), "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());
}
}
+425
View File
@@ -0,0 +1,425 @@
//! 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,
Result { ip: String, ok: bool, detail: String },
Done,
}
pub struct RestoreHandle {
pub rx: Receiver<RestoreMsg>,
// The worker honours cancellation between miners (see `tc` below); a UI stop
// control is not wired yet, so the handle-side trigger is kept for when it is.
#[allow(dead_code)]
cancel: Arc<AtomicBool>,
}
impl RestoreHandle {
#[allow(dead_code)]
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));
if fake_scan_enabled() {
// Offline demo: report each target as restored without touching anything.
let _ = tx.send(RestoreMsg::Started);
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);
return RestoreHandle { rx, cancel };
}
let tc = cancel.clone();
let err_tx = tx.clone();
let spawned = std::thread::Builder::new()
.name("restore-stock".into())
.spawn(move || {
let _ = tx.send(RestoreMsg::Started);
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);
});
if spawned.is_err() {
// Never leave the restore subsystem wedged (round 18 #12): if the worker
// thread can't start, emit a failure + Done so the drain clears the handle.
let _ = err_tx.send(RestoreMsg::Result {
ip: String::new(),
ok: false,
detail: "could not start the restore worker thread".into(),
});
let _ = err_tx.send(RestoreMsg::Done);
}
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) {
// serde-encode the body so a password with a quote/backslash can't break the
// JSON, and send it via stdin (-d @-) so the password never appears on curl's
// argv / the process list (round 18 #12).
let body = serde_json::json!({ "pw": pass }).to_string();
let unlock = match curl(
&[
"-s", "--connect-timeout", "5", "--max-time", "9",
"-X", "POST", "-H", "Content-Type: application/json",
"-d", "@-",
&format!("http://{ip}/api/v1/unlock"),
],
Some(body.as_bytes()),
) {
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"),
],
None,
) {
// 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()));
};
// serde-encode so the miner-supplied SessionID can't break or inject into the
// JSON-RPC command (round 18 #12).
let cmd = serde_json::json!({ "command": "uninstallluxos", "parameter": session }).to_string();
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())
}
// The miner reboots as it reverts, so the reply is often dropped/empty
// after the command is accepted. The logon above already proved the miner
// was reachable, so an empty reply or a dropped connection here is the
// expected reboot, not a failure (round 18 #12).
Ok(resp) if resp.trim().is_empty() => {
(true, "uninstall accepted (miner rebooting to stock)".into())
}
Ok(resp) => (false, format!("uninstallluxos returned: {}", resp.trim())),
Err(e)
if ["closed", "reset", "timed out", "broken pipe", "eof"]
.iter()
.any(|m| e.to_lowercase().contains(m)) =>
{
(true, "RPC dropped (miner rebooting to stock)".into())
}
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}");
// sshpass reads the password from $SSHPASS (-e) rather than argv (-p), so it
// never shows up in the process list (round 18 #12). Host-key checking is
// deliberately disabled: these are LAN miners whose SSH host key changes on
// every reflash, so pinning it would break the very revert this performs.
// BatchMode stops any interactive prompt from hanging out the 60 s cap.
let mut cmd = Command::new("sshpass");
cmd.env("SSHPASS", pass);
cmd.arg("-e").arg("ssh");
cmd.args([
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "BatchMode=yes",
"-o", "ConnectTimeout=8",
&target,
"uninstall.sh || /sbin/uninstall.sh",
]);
match run_with_timeout(cmd, Duration::from_secs(60), None) {
Ok(out) => classify_braiins(
&String::from_utf8_lossy(&out.stdout),
&String::from_utf8_lossy(&out.stderr),
out.code,
out.timed_out,
),
Err(e) => {
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}"))
}
}
}
}
/// Decide a Braiins `uninstall.sh` outcome from its captured output. The critical
/// rule (round 18 #12): an SSH auth/connection failure -- which writes its
/// diagnostic to stderr, leaves stdout empty, and exits non-zero -- must be
/// reported as a FAILURE, never a false success. A dropped connection or a
/// timeout after the command started is the expected signature of the reboot.
fn classify_braiins(stdout: &str, stderr: &str, code: Option<i32>, timed_out: bool) -> (bool, String) {
let err = stderr.to_lowercase();
// ssh's own connection/auth failures (exit 255) never reach the remote command.
let conn_fail = [
"permission denied",
"connection refused",
"could not resolve",
"no route to host",
"connection timed out",
"operation timed out",
"host key verification failed",
"before authentication",
]
.iter()
.any(|m| err.contains(m));
if conn_fail {
let why = stderr.lines().map(str::trim).rfind(|l| !l.is_empty());
return (false, format!("SSH failed: {}", why.unwrap_or("connection/auth error")));
}
let out = stdout.to_lowercase();
if out.contains("not found") || out.contains("no such") || err.contains("not found") {
return (false, "uninstall.sh not found on the miner".into());
}
match code {
Some(0) => (true, "ran uninstall.sh (reverts to stock + reboots)".into()),
None => (true, "SSH dropped (miner likely rebooting to stock)".into()),
_ if timed_out => (true, "SSH timed out (miner likely rebooting to stock)".into()),
Some(c) => (false, format!("uninstall.sh exited {c}: {}", stderr.trim())),
}
}
/// 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())
}
/// The captured result of a timed subprocess run.
struct CmdOutput {
/// The process exit code, or `None` if it was killed / dropped / timed out.
code: Option<i32>,
stdout: Vec<u8>,
stderr: Vec<u8>,
timed_out: bool,
}
/// curl with a wall-clock cap. Errors only when the run produced no output and
/// timed out (a black-holed host); otherwise returns stdout even on a non-zero
/// exit (curl prints useful bodies/status on failures).
fn curl(args: &[&str], stdin_data: Option<&[u8]>) -> Result<String, String> {
let mut cmd = Command::new("curl");
cmd.args(args);
let out = run_with_timeout(cmd, Duration::from_secs(15), stdin_data)?;
if out.timed_out && out.stdout.is_empty() {
return Err("timed out".into());
}
Ok(String::from_utf8_lossy(&out.stdout).into_owned())
}
/// Run a command with a hard wall-clock timeout, capturing stdout, stderr, and
/// the exit code. Both pipes are drained on their own threads so a child that
/// writes a lot to stderr can never deadlock against a full pipe (round 18 #12).
/// `stdin_data`, when set, is written to the child's stdin and the pipe closed
/// (used to feed a request body without putting a secret on argv).
fn run_with_timeout(
mut cmd: Command,
timeout: Duration,
stdin_data: Option<&[u8]>,
) -> Result<CmdOutput, String> {
cmd.stdout(std::process::Stdio::piped());
cmd.stderr(std::process::Stdio::piped());
if stdin_data.is_some() {
cmd.stdin(std::process::Stdio::piped());
}
let mut child = cmd.spawn().map_err(|e| format!("spawn: {e}"))?;
if let Some(data) = stdin_data {
if let Some(mut si) = child.stdin.take() {
let _ = si.write_all(data);
} // dropping `si` closes the pipe
}
let mut stdout = child.stdout.take().ok_or("no stdout")?;
let mut stderr = child.stderr.take().ok_or("no stderr")?;
let out_reader = std::thread::spawn(move || {
let mut b = Vec::new();
let _ = stdout.read_to_end(&mut b);
b
});
let err_reader = std::thread::spawn(move || {
let mut b = Vec::new();
let _ = stderr.read_to_end(&mut b);
b
});
let start = std::time::Instant::now();
let mut timed_out = false;
let status = loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(s) => break Some(s),
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
let _ = child.wait(); // reap so we never leave a zombie
timed_out = true;
break None;
}
std::thread::sleep(Duration::from_millis(50));
}
}
};
Ok(CmdOutput {
code: status.and_then(|s| s.code()),
stdout: out_reader.join().unwrap_or_default(),
stderr: err_reader.join().unwrap_or_default(),
timed_out,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn braiins_auth_or_connection_failure_is_not_a_false_success() {
// The critical regression guard (round 18 #12): a wrong password or an
// unreachable miner writes to stderr, leaves stdout empty, and exits
// non-zero -- it must report failure, never "restored".
let (ok, msg) = classify_braiins("", "Permission denied, please try again.", Some(255), false);
assert!(!ok, "wrong password must not report success");
assert!(msg.to_lowercase().contains("ssh failed"), "{msg}");
let (ok, _) = classify_braiins("", "ssh: connect to host 10.0.0.9 port 22: Connection refused", Some(255), false);
assert!(!ok, "unreachable miner must not report success");
let (ok, _) = classify_braiins("", "ssh: Could not resolve hostname miner: Name or service not known", Some(255), false);
assert!(!ok, "unresolvable host must not report success");
// Genuine outcomes.
let (ok, _) = classify_braiins("uninstalling...\n", "", Some(0), false);
assert!(ok, "clean exit 0 is success");
let (ok, _) = classify_braiins("", "Connection to 10.0.0.5 closed by remote host.", None, false);
assert!(ok, "connection dropped mid-command (reboot) is success");
let (ok, _) = classify_braiins("", "", None, true);
assert!(ok, "timeout after the command started (reboot) is success");
let (ok, _) = classify_braiins("bash: uninstall.sh: command not found\n", "", Some(127), false);
assert!(!ok, "missing uninstall.sh is a failure");
}
#[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
+3985 -189
View File
File diff suppressed because it is too large Load Diff
+43
View File
@@ -0,0 +1,43 @@
# cargo-deny configuration (https://embarkstudios.github.io/cargo-deny/).
#
# Run locally with `cargo deny check`. CI's security gate is cargo-audit (lighter,
# already wired); this file documents the dependency policy and lets anyone run a
# fuller license/advisory/source check. The whole dependency set is vendored under
# ./vendor and resolved offline (see .cargo/config.toml).
[advisories]
version = 2
# Accepted, documented advisories (build-time-only reqwest 0.11 subtree of the
# wx-rs build script -- never linked into the runtime binary). Mirrors
# .cargo/audit.toml; re-review when the vendored dependency set is refreshed.
ignore = [
"RUSTSEC-2026-0258", # h2 0.3 DATA-frame DoS (build-time HTTP client only)
"RUSTSEC-2025-0134", # rustls-pemfile 1.0.4 unmaintained (same subtree)
]
[licenses]
version = 2
# The project is MIT; only permissive licenses are allowed in the
# dependency tree.
allow = [
"MIT",
"Apache-2.0",
"Apache-2.0 WITH LLVM-exception",
"BSD-2-Clause",
"BSD-3-Clause",
"ISC",
"Zlib",
"Unicode-3.0",
"Unicode-DFS-2016",
"MPL-2.0",
"CC0-1.0",
]
confidence-threshold = 0.9
[bans]
multiple-versions = "warn"
wildcards = "allow"
[sources]
unknown-registry = "warn"
unknown-git = "warn"
+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."
+51
View File
@@ -0,0 +1,51 @@
#!/usr/bin/env bash
#
# Reclaim disk from the local cargo build directory.
#
# The app and the miner_probe CLI ship as release builds, and the unit tests run
# under --release too (see the build notes), so the dev/debug profile tree, any
# cross-compile target trees, and the coverage tree are all disposable: they only
# ever reappear if something explicitly rebuilds them, and left alone they grow
# without bound (a stray `cargo check`/`cargo test` can push the debug tree past
# 30 GiB on its own). The release tree is kept warm so the next iteration is still
# incremental; only its throwaway bits are pruned.
#
# Run it right after a release push -- the pushed commit is what CI builds and
# ships, so the local intermediates are spare from that point. Safe to run any
# time; it never deletes the release build itself.
#
# Honours CARGO_TARGET_DIR (the build sets it to ~/.cache/alkane-tk-target).
set -uo pipefail
TARGET="${CARGO_TARGET_DIR:-$HOME/.cache/alkane-tk-target}"
if [ ! -d "$TARGET" ]; then
echo "clean-old-builds: no target dir at $TARGET (nothing to do)"
exit 0
fi
human() { du -sh "$1" 2>/dev/null | cut -f1; }
before=$(human "$TARGET")
# Disposable profile/aux trees -- regenerated on demand, never shipped.
rm -rf "$TARGET"/debug "$TARGET"/llvm-cov-target "$TARGET"/doc 2>/dev/null
# Cross-compile target trees (e.g. armv7-unknown-linux-musleabihf). Rust target
# triples all carry "-unknown-"; the host release/debug trees do not, so this
# never touches the warm release build.
for d in "$TARGET"/*-unknown-*; do
[ -d "$d" ] && rm -rf "$d"
done
# The incremental caches are rebuild accelerators, not build output -- dropping
# them costs one slightly-slower rebuild and can free a few GiB.
rm -rf "$TARGET"/release/incremental 2>/dev/null
# If cargo-sweep is installed, additionally drop release artifacts not touched in
# the last few days (old dependency versions left by past rebuilds), keeping the
# current build. Optional: install with `cargo install cargo-sweep`.
if command -v cargo-sweep >/dev/null 2>&1; then
cargo sweep --time 3 "$TARGET" >/dev/null 2>&1 || true
fi
after=$(human "$TARGET")
echo "clean-old-builds: $TARGET $before -> $after"
+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(())
}
@@ -0,0 +1,103 @@
Subject: [PATCH 0017] luxminer v1: select power-limit profile by name, not step
Round 17 C (found via live tuning verification). set_power_limit mapped a watts
target to a LuxOS profile and applied it with `profileset`, but keyed on the
profile's `Step` field. The top/factory profile is named "default" and its Step
is "0"; LuxOS's profileset reads the parameter "0" as empty and answers
"Missing profile parameter" (Code 400). So the setter could never select the
default profile -- and a miner nudged off default by a watts limit could not be
returned to it via the power-limit control, stranding it below its factory point.
parse_profile_watts now keys on `Profile Name` (e.g. "480MHz", "default"), which
profileset accepts for every profile including the default. Verified live on a
LuxOS S19j Pro (10.4.1.60): set_power_limit(2700) -> 480MHz/2632W, and
set_power_limit(2900) -> default/2794W (previously errored), restoring the miner
to its factory profile. Unit test updated to key on names and to cover the
top-profile-is-"default" case.
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 2d1331bf..a4db1e03 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -1078,8 +1078,14 @@ 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.
+/// Parse a LuxOS `profiles` RPC reply into (profile name, watts) pairs, keeping
+/// only profiles that report both a `Profile Name` and a `Watts` value.
+///
+/// The identifier is the `Profile Name` (e.g. "480MHz", "default"), NOT the
+/// `Step`: `profileset` takes the name, and the default profile's step is "0",
+/// which LuxOS reads as an empty parameter ("Missing profile parameter"), so a
+/// step-keyed setter can never select the default profile and could strand a
+/// miner off its factory point.
fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
profiles
.get("PROFILES")
@@ -1087,16 +1093,16 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
.map(|arr| {
arr.iter()
.filter_map(|p| {
- let step = p.get("Step").and_then(Value::as_str)?.to_string();
+ let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
let watts = p.get("Watts").and_then(Value::as_f64)?;
- Some((step, watts))
+ Some((name, watts))
})
.collect()
})
.unwrap_or_default()
}
-/// Choose the LuxOS profile step to satisfy a watts power limit: the highest-watt
+/// Choose the LuxOS profile name 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.
@@ -1315,32 +1321,34 @@ mod tests {
#[test]
fn power_limit_profile_selection() {
- // LuxOS reports a ladder of profiles, each with a Step name and Watts.
+ // LuxOS reports a ladder of profiles, each with a Profile Name and Watts.
+ // The top profile is named "default" (its Step is "0", which profileset
+ // rejects -- so selection must key on the name, not the step).
let steps = vec![
- ("-16".to_string(), 865.0),
- ("-4".to_string(), 2385.0),
- ("-2".to_string(), 2790.0),
- ("0".to_string(), 3100.0),
+ ("190MHz".to_string(), 865.0),
+ ("405MHz".to_string(), 2385.0),
+ ("455MHz".to_string(), 2790.0),
+ ("default".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")
+ Some("405MHz")
);
assert_eq!(
select_profile_at_or_below(&steps, 2790.0).as_deref(),
- Some("-2")
+ Some("455MHz")
);
- // Above every profile -> the maximum profile (a limit can't exceed the
- // hardware's top profile).
+ // Above every profile -> the maximum profile, selected by NAME ("default")
+ // rather than its step "0" (which profileset would reject).
assert_eq!(
select_profile_at_or_below(&steps, 9000.0).as_deref(),
- Some("0")
+ Some("default")
);
// Below every profile -> the minimum profile.
assert_eq!(
select_profile_at_or_below(&steps, 100.0).as_deref(),
- Some("-16")
+ Some("190MHz")
);
// No profiles -> nothing to choose.
assert_eq!(select_profile_at_or_below(&[], 2500.0), None);
+202
View File
@@ -0,0 +1,202 @@
Subject: [PATCH 0018] core + epic: PSU info scan (identity, rated envelope, output V/A)
Round 17 R5/G15. asic-rs had no PSU telemetry. Adds a PsuInfo type (model,
version, rated voltage min/max, live output voltage/current) as an optional
MinerData.psu field, a DataField::Psu, and a default parse_psu(&data) -> None
that backends override.
ePIC (PowerPlay v1) populates it: DataField::Psu merges the summary "Power Supply
Stats" (tag "stats") and the capabilities "Psu Info" (tag "info"); parse_psu reads
model/FW + Min/Max Vout (millivolts -> volts) + live Output Voltage/Current.
Verified live on ePIC S19j Pro (10.4.1.6/.10): model 117, fw 22, Vmin 11.877 V,
Vmax 15.182 V, output ~13.2-13.4 V. Feeds the new PSU version/Vmin/Vmax columns
and the R2 power tooltip (output V/A). Other backends leave psu None until they
add their own parse_psu.
diff --git a/vendor/asic-rs-core/src/data/collector.rs b/vendor/asic-rs-core/src/data/collector.rs
index 93a0111a..d1456548 100644
--- a/vendor/asic-rs-core/src/data/collector.rs
+++ b/vendor/asic-rs-core/src/data/collector.rs
@@ -74,6 +74,9 @@ pub enum DataField {
/// Current power consumption in watts.
#[cfg_attr(feature = "python", pydantic(value = "Wattage"))]
Wattage,
+ /// Power-supply info (identity, rated voltage envelope, live output V/A).
+ #[cfg_attr(feature = "python", pydantic(value = "Psu"))]
+ Psu,
/// manual tuning percent of full power (100 = unthrottled).
#[cfg_attr(feature = "python", pydantic(value = "TuningPercent"))]
TuningPercent,
diff --git a/vendor/asic-rs-core/src/data/miner.rs b/vendor/asic-rs-core/src/data/miner.rs
index be6f4c8f..b2b8a578 100644
--- a/vendor/asic-rs-core/src/data/miner.rs
+++ b/vendor/asic-rs-core/src/data/miner.rs
@@ -16,6 +16,7 @@ use super::{
message::MinerMessage,
operating_state::OperatingState,
pool::PoolGroupData,
+ psu::PsuInfo,
};
use crate::data::{
deserialize::deserialize_macaddr,
@@ -192,6 +193,9 @@ pub struct MinerData {
#[serde(serialize_with = "serialize_power")]
#[ts(type = "number | null")]
pub wattage: Option<Power>,
+ /// Power-supply info (identity, rated voltage envelope, live output V/A),
+ /// when the firmware reports it.
+ pub psu: Option<PsuInfo>,
/// The current manual tuning percent of full power (100 = unthrottled), where supported
pub tuning_percent: Option<u8>,
/// The current tuning target of the miner, such as power target or hashrate target
diff --git a/vendor/asic-rs-core/src/data/mod.rs b/vendor/asic-rs-core/src/data/mod.rs
index c69c43eb..3b7f98c0 100644
--- a/vendor/asic-rs-core/src/data/mod.rs
+++ b/vendor/asic-rs-core/src/data/mod.rs
@@ -15,5 +15,6 @@ pub mod message;
pub mod miner;
pub mod operating_state;
pub mod pool;
+pub mod psu;
pub(crate) mod serialize;
pub mod share;
diff --git a/vendor/asic-rs-core/src/data/psu.rs b/vendor/asic-rs-core/src/data/psu.rs
new file mode 100644
index 00000000..810ba47c
--- /dev/null
+++ b/vendor/asic-rs-core/src/data/psu.rs
@@ -0,0 +1,30 @@
+//! Power-supply (PSU) information reported by a miner's firmware.
+//!
+//! A backend fills in only what its firmware actually exposes; every field is
+//! optional. Some firmware reports the PSU's identity and rated voltage envelope
+//! (min/max output voltage), others also report the live output voltage and
+//! current. Voltages are in volts and currents in amps.
+
+#[cfg(feature = "python")]
+use pyo3::pyclass;
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+
+/// Power-supply identity and voltage telemetry for one miner.
+#[cfg_attr(feature = "python", pyclass(from_py_object, module = "asic_rs"))]
+#[cfg_attr(feature = "python", asic_rs_pydantic::py_pydantic_model(getters))]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
+pub struct PsuInfo {
+ /// PSU model / type identifier, when reported.
+ pub model: Option<String>,
+ /// PSU firmware/hardware version, when reported.
+ pub version: Option<String>,
+ /// Minimum rated output voltage in volts, when reported.
+ pub voltage_min: Option<f64>,
+ /// Maximum rated output voltage in volts, when reported.
+ pub voltage_max: Option<f64>,
+ /// Live output voltage in volts, when reported.
+ pub output_voltage: Option<f64>,
+ /// Live output current in amps, when reported.
+ pub output_current: Option<f64>,
+}
diff --git a/vendor/asic-rs-core/src/traits/miner.rs b/vendor/asic-rs-core/src/traits/miner.rs
index d08b1b5a..db1ba653 100644
--- a/vendor/asic-rs-core/src/traits/miner.rs
+++ b/vendor/asic-rs-core/src/traits/miner.rs
@@ -33,6 +33,7 @@ use crate::{
miner::{MinerData, TuningTarget},
operating_state::OperatingState,
pool::PoolGroupData,
+ psu::PsuInfo,
},
traits::firmware::MinerFirmware,
traits::model::MinerModel,
@@ -272,6 +273,7 @@ impl<
let hashrate = self.parse_hashrate(&data);
let expected_hashrate = self.parse_expected_hashrate(&data);
let wattage = self.parse_wattage(&data);
+ let psu = self.parse_psu(&data);
let tuning_percent = self.parse_tuning_percent(&data);
let tuning_target = self.parse_tuning_target(&data);
let scaled_tuning_target = self.parse_scaled_tuning_target(&data);
@@ -367,6 +369,7 @@ impl<
// Power information
wattage,
+ psu,
tuning_percent,
tuning_target,
scaled_tuning_target,
@@ -720,6 +723,10 @@ pub trait GetWattage: CollectData {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
None
}
+ #[allow(unused_variables)]
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ None
+ }
}
// Tuning Percent
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 c21e05b1..3365824d 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -24,6 +24,7 @@ use asic_rs_core::{
miner::TuningTarget,
operating_state::OperatingState,
pool::{PoolData, PoolGroupData, PoolURL},
+ psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
util::unix_timestamp_secs,
@@ -436,6 +437,26 @@ impl GetDataLocations for PowerPlayV1 {
tag: None,
},
)],
+ // PSU: live stats from summary + rated envelope/identity from
+ // capabilities, tagged so parse_psu can read both (round 17 R5/G15).
+ DataField::Psu => vec![
+ (
+ WEB_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Power Supply Stats"),
+ tag: Some("stats"),
+ },
+ ),
+ (
+ WEB_CAPABILITIES,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Psu Info"),
+ tag: Some("info"),
+ },
+ ),
+ ],
DataField::TuningTarget => vec![(
WEB_SUMMARY,
DataExtractor {
@@ -1095,6 +1116,25 @@ impl GetWattage for PowerPlayV1 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<f64, _>(DataField::Wattage, Power::from_watts)
}
+
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ // DataField::Psu is the merged {stats: Power Supply Stats, info: Psu Info}
+ // (see get_locations). capabilities Vout + summary Target Voltage are in
+ // millivolts; summary Output Voltage/Current are already volts/amps.
+ let d = data.get(&DataField::Psu)?;
+ let stats = d.pointer("/stats");
+ let info = d.pointer("/info");
+ let f = |v: Option<&Value>, key: &str| v.and_then(|o| o.pointer(key)).and_then(tuning_value_as_f64);
+ let psu = PsuInfo {
+ model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
+ version: f(info, "/FW").map(|n| format!("{n:.0}")),
+ voltage_min: f(info, "/Min Vout").map(|mv| mv / 1000.0),
+ voltage_max: f(info, "/Max Vout").map(|mv| mv / 1000.0),
+ output_voltage: f(stats, "/Output Voltage"),
+ output_current: f(stats, "/Output Current"),
+ };
+ (psu != PsuInfo::default()).then_some(psu)
+ }
}
fn tuning_value_as_f64(value: &Value) -> Option<f64> {
@@ -0,0 +1,128 @@
Subject: [PATCH 0019] antminer v2023_07: best-share + Bixbit "Power Estimated" wattage
Round 17 R7 (found by flashing Bixbit onto fleet units). The v2023_07 stock
backend scanned hashrate/boards/temps/fans fine but reported no best-share for the
WHOLE Antminer fleet (DataField::BestShare had no get_locations entry, so it was
never fetched) and no wattage for Bixbit-based firmware (it reads the cgminer
stats power, which Bixbit leaves 0, putting the real figure in the summary as
"Power Estimated").
- Map DataField::BestShare / SessionBestShare to the cgminer summary
("Best Share" / "Best Session Share") and implement GetBestShare /
GetSessionBestShare (guard 0 -> None).
- Add the summary to DataField::Wattage under a "summary" tag and fall back to
"Power Estimated" in parse_wattage when the stats power is 0/absent. Stock
behaviour is preserved (a non-zero stats power still wins; a present-but-zero
power still reads 0 W).
Verified live: Bixbit S19j Pro (10.4.1.70) now reads wattage 2615 W + best-share
178930671 (was both blank); stock S21 Pro (10.4.1.90) now reads best-share
299464394 (was blank). 36 antminer backend tests pass; no wattage regression.
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 6d6dc593..1ac2bad1 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
@@ -521,8 +521,40 @@ impl GetDataLocations for AntMinerV202307 {
tag: None,
},
),
+ // Bixbit-based firmware reports Power=0 in stats but the real
+ // figure as "Power Estimated" in the cgminer summary; carry it
+ // under a "summary" tag so parse_wattage can fall back to it
+ // without colliding with the stats keys (round 17 R7).
+ (
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0"),
+ tag: Some("summary"),
+ },
+ ),
]
}
+ // Best share (all-time / session) from the cgminer summary. Antminer
+ // stock, Bixbit, and other cgminer-based firmware all report it here;
+ // it was previously unmapped, so best-share was blank fleet-wide
+ // (round 17 R7).
+ 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::SerialNumber => vec![
(
WEB_SYSTEM_INFO,
@@ -778,8 +810,6 @@ impl GetUptime for AntMinerV202307 {
}
}
-impl GetBestShare for AntMinerV202307 {}
-impl GetSessionBestShare for AntMinerV202307 {}
impl GetOperatingState for AntMinerV202307 {}
@@ -888,14 +918,30 @@ impl GetWattage for AntMinerV202307 {
}
}
- if let Some(power) = stats_data
+ let primary = stats_data
.get("power")
.or_else(|| stats_data.get("Power"))
// Same firmware version spells this differently per model: the
// L9 reports `power`, the L11 `watt`.
.or_else(|| stats_data.get("watt"))
+ .and_then(|v| v.as_f64());
+ if let Some(power) = primary
+ && power > 0.0
+ {
+ return Some(Power::from_watts(power));
+ }
+ // Bixbit-based firmware leaves the stats power at 0 and reports the
+ // real draw as "Power Estimated" in the summary (round 17 R7).
+ if let Some(est) = stats_data
+ .pointer("/summary/Power Estimated")
.and_then(|v| v.as_f64())
+ && est > 0.0
{
+ return Some(Power::from_watts(est));
+ }
+ // Preserve the prior behaviour: a present-but-zero stats power still
+ // reads as 0 W rather than blank.
+ if let Some(power) = primary {
return Some(Power::from_watts(power));
}
}
@@ -903,6 +949,21 @@ impl GetWattage for AntMinerV202307 {
}
}
+impl GetBestShare for AntMinerV202307 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // cgminer summary "Best Share" (all-time). Guard against a firmware that
+ // reports 0 when it has never found a share (round 17 R7).
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
+ }
+}
+
+impl GetSessionBestShare for AntMinerV202307 {
+ fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ data.extract::<f64>(DataField::SessionBestShare)
+ .filter(|&v| v > 0.0)
+ }
+}
+
impl GetTuningTarget for AntMinerV202307 {
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
data.get(&DataField::TuningTarget)
+59
View File
@@ -0,0 +1,59 @@
Subject: [PATCH 0020] braiins v26_04: PSU info (type + rated voltage envelope)
Round 17 R5/G15 extension. BOS reports PSU info at miner/details -> psu_info
{version, min_voltage.volt, max_voltage.volt}. Map DataField::Psu to it and parse
model (the "version" type code, 117 = the same APW12 ePIC reports) + voltage
min/max. Verified live on Braiins S19j Pro (10.4.1.83/.27): model 117, Vmin
11.96 V, Vmax 15.2 V.
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 e65fb201..9b72ed94 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
@@ -22,6 +22,7 @@ use asic_rs_core::{
miner::TuningTarget,
operating_state::OperatingState,
pool::{PoolData, PoolGroupData, PoolURL},
+ psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
};
@@ -294,6 +295,16 @@ impl GetDataLocations for BraiinsV2604 {
tag: None,
},
)],
+ // PSU identity + rated voltage envelope (round 17 R5/G15). BOS reports
+ // it at miner/details -> psu_info {version, min_voltage, max_voltage}.
+ DataField::Psu => vec![(
+ WEB_MINER_DETAILS,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/psu_info"),
+ tag: None,
+ },
+ )],
DataField::TuningTarget => vec![
(
WEB_MINER_CONFIGURATION,
@@ -663,6 +674,22 @@ impl GetWattage for BraiinsV2604 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<i64, _>(DataField::Wattage, |w| Power::from_watts(w as f64))
}
+
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ // BOS miner/details -> psu_info {version, min_voltage.volt, max_voltage.volt}.
+ // "version" is the PSU type code (117 = the APW12 ePIC also reports as model
+ // 117), so expose it as the model for consistency across firmwares.
+ let d = data.get(&DataField::Psu)?;
+ let psu = PsuInfo {
+ model: d.pointer("/version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
+ version: None,
+ voltage_min: d.pointer("/min_voltage/volt").and_then(|v| v.as_f64()),
+ voltage_max: d.pointer("/max_voltage/volt").and_then(|v| v.as_f64()),
+ output_voltage: None,
+ output_current: None,
+ };
+ (psu != PsuInfo::default()).then_some(psu)
+ }
}
impl GetTuningTarget for BraiinsV2604 {
@@ -0,0 +1,173 @@
Subject: [PATCH 0021] whatsminer v1/v2: PSU info + fix pre-existing parse_messages test
Round 17 R5/G15 extension. get_psu /Msg exposes the PSU model + hw/sw version
(no DC output voltage or rated envelope). Map DataField::Psu to it in v1 and v2
and parse model + version. Verified live on a WhatsMiner M30S+ (10.8.1.214, v2):
model P221C, version H20201205. (v3 uses a different /msg/power shape and no v3
unit was available to verify, so it is left for a follow-up.)
Also fixes a pre-existing test bug: test_whatsminer_v1_parse_messages asserted 2
messages but never mocked get_error_code (its only source since patch 0012), so it
returned 0 and failed whenever the vendored backend tests were run (CI runs only
the GUI selftest, so it went unnoticed). Adds a get_error_code.json mock. v1 tests
now 41/41.
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 67907049..3c8512ad 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -18,6 +18,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::TuningTarget,
pool::{PoolData, PoolGroupData, PoolURL},
+ psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
};
@@ -193,6 +194,16 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
+ // PSU identity from get_psu (round 17 R5/G15). WhatsMiner exposes the
+ // model + hw/sw version but not a DC output voltage or rated envelope.
+ DataField::Psu => vec![(
+ RPC_GET_PSU,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Msg"),
+ tag: None,
+ },
+ )],
DataField::Hashboards => vec![(
RPC_DEVS,
DataExtractor {
@@ -463,6 +474,22 @@ impl GetWattage for WhatsMinerV1 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<f64, _>(DataField::Wattage, Power::from_watts)
}
+
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ // get_psu /Msg -> {model, hw_version, sw_version, ...} (values are strings).
+ // No DC output voltage or rated envelope is exposed, so only identity is set.
+ let d = data.get(&DataField::Psu)?;
+ let s = |k: &str| d.pointer(k).and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(str::to_string);
+ let psu = PsuInfo {
+ model: s("/model").or_else(|| s("/name")),
+ version: s("/hw_version").or_else(|| s("/sw_version")),
+ voltage_min: None,
+ voltage_max: None,
+ output_voltage: None,
+ output_current: None,
+ };
+ (psu != PsuInfo::default()).then_some(psu)
+ }
}
impl GetTuningTarget for WhatsMinerV1 {
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
@@ -805,8 +832,8 @@ mod integration_tests {
use super::*;
use crate::test::json::v1::{
- DEVS_COMMAND, GET_PSU_COMMAND, GET_VERSION_COMMAND, POOLS_COMMAND, STATUS_COMMAND,
- SUMMARY_COMMAND, SUMMARY_WITH_ERRORS_COMMAND,
+ DEVS_COMMAND, GET_ERROR_CODE_COMMAND, GET_PSU_COMMAND, GET_VERSION_COMMAND, POOLS_COMMAND,
+ STATUS_COMMAND, SUMMARY_COMMAND, SUMMARY_WITH_ERRORS_COMMAND,
};
#[tokio::test]
@@ -943,6 +970,13 @@ mod integration_tests {
},
Value::from_str(GET_PSU_COMMAND)?,
);
+ results.insert(
+ MinerCommand::RPC {
+ command: "get_error_code",
+ parameters: None,
+ },
+ Value::from_str(GET_ERROR_CODE_COMMAND)?,
+ );
let mock_api = MockAPIClient::new(results);
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 096b2fcb..de36a126 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
@@ -20,6 +20,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
+ psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
util::is_expected_write_error,
@@ -205,6 +206,15 @@ impl GetDataLocations for WhatsMinerV2 {
tag: None,
},
)],
+ // PSU identity from get_psu (round 17 R5/G15): model + hw/sw version.
+ DataField::Psu => vec![(
+ RPC_GET_PSU,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/Msg"),
+ tag: None,
+ },
+ )],
DataField::Hashboards => vec![(
RPC_DEVS,
DataExtractor {
@@ -471,6 +481,22 @@ impl GetWattage for WhatsMinerV2 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<f64, _>(DataField::Wattage, Power::from_watts)
}
+
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ // get_psu /Msg -> {model, hw_version, sw_version} (string values). No DC
+ // output voltage or rated envelope is exposed, so only identity is set.
+ let d = data.get(&DataField::Psu)?;
+ let s = |k: &str| d.pointer(k).and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(str::to_string);
+ let psu = PsuInfo {
+ model: s("/model").or_else(|| s("/name")),
+ version: s("/hw_version").or_else(|| s("/sw_version")),
+ voltage_min: None,
+ voltage_max: None,
+ output_voltage: None,
+ output_current: None,
+ };
+ (psu != PsuInfo::default()).then_some(psu)
+ }
}
/// Parses tuning target from V2 summary data.
/// Low/High → MiningMode, Normal/unknown/empty → Power(limit).
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/get_error_code.json b/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/get_error_code.json
new file mode 100644
index 00000000..1d87b18b
--- /dev/null
+++ b/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/get_error_code.json
@@ -0,0 +1,16 @@
+{
+ "Code": 131,
+ "Description": "",
+ "Msg": {
+ "error_code": [
+ {
+ "110": "2024-06-15 09:15:00"
+ },
+ {
+ "600": "2024-06-15 10:30:00"
+ }
+ ]
+ },
+ "STATUS": "S",
+ "When": 1773871985
+}
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/mod.rs
index 0b3442db..c94c354f 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/test/json/v1/mod.rs
@@ -6,4 +6,5 @@ pub(crate) const POOLS_COMMAND: &str = include_str!("pools.json");
pub(crate) const DEVS_COMMAND: &str = include_str!("devs.json");
pub(crate) const GET_VERSION_COMMAND: &str = include_str!("get_version.json");
pub(crate) const GET_PSU_COMMAND: &str = include_str!("get_psu.json");
+pub(crate) const GET_ERROR_CODE_COMMAND: &str = include_str!("get_error_code.json");
pub(crate) const SUMMARY_WITH_ERRORS_COMMAND: &str = include_str!("summary_with_errors.json");
@@ -0,0 +1,159 @@
Subject: [PATCH 0022] luxminer: named presets + set_tuning_config (roadmap G3)
LuxOS tunes by discrete named profiles. This exposes them as first-class
presets and wires the structured tuning-config setter, so the toolkit can list
and select a profile (not only map a watts number onto one via SetPowerLimit).
- SupportsPresets: supports_presets()=true and get_presets() reads the live
`profiles` RPC into PresetInfo{name, pretty="<W> W ~ <TH> TH @ <MHz> MHz",
status=IsTuned?tuned:untuned}. Never hardcoded -- the step list varies by
model and tune state. New helper parse_profiles_to_presets + unit test.
- SupportsTuningConfig: supports_tuning_config()=true and set_tuning_config
handles Preset(name) -> profileset(name) (the same privileged RPC set_power_limit
already uses, proven in patch 0017) and Power(w) -> set_power_limit; hashrate /
mining-mode / manual targets are refused with clear messages.
Verified live (read) on two production LuxOS S19j Pro (10.4.1.60 / .67): the
profile ladders and supports_tuning_config=true are reported correctly. The
write path reuses the already-proven profileset(name) call; per the parity
roadmap, LuxOS profile writes are bench-only (never on the .60/.67 production
units), so the setter is not exercised against them here.
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 a4db1e03..b5a5a73c 100644
--- a/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-luxminer/src/backends/v1/mod.rs
@@ -5,6 +5,8 @@ use asic_rs_core::{
config::{
collector::{ConfigCollector, ConfigExtractor, ConfigField, ConfigLocation},
pools::{PoolConfig, PoolGroupConfig},
+ preset::PresetInfo,
+ tuning::TuningConfig,
},
data::{
board::{BoardData, ChipData, MinerControlBoard},
@@ -1102,6 +1104,38 @@ fn parse_profile_watts(profiles: &Value) -> Vec<(String, f64)> {
.unwrap_or_default()
}
+/// Parse a LuxOS `profiles` RPC reply into the firmware's tunable presets, one
+/// per dynamic profile (round 18 / roadmap G3). The `Profile Name` is the
+/// identifier `profileset` expects; the pretty string summarises the profile's
+/// watt / hashrate / frequency operating point, and `status` reflects `IsTuned`.
+fn parse_profiles_to_presets(profiles: &Value) -> Vec<PresetInfo> {
+ profiles
+ .get("PROFILES")
+ .and_then(Value::as_array)
+ .map(|arr| {
+ arr.iter()
+ .filter_map(|p| {
+ let name = p.get("Profile Name").and_then(Value::as_str)?.to_string();
+ let watts = p.get("Watts").and_then(Value::as_f64);
+ let hashrate = p.get("Hashrate").and_then(Value::as_f64);
+ let freq = p.get("Frequency").and_then(Value::as_f64);
+ let pretty = match (watts, hashrate, freq) {
+ (Some(w), Some(h), Some(f)) => Some(format!("{w:.0} W ~ {h:.1} TH @ {f:.0} MHz")),
+ (Some(w), Some(h), None) => Some(format!("{w:.0} W ~ {h:.1} TH")),
+ (Some(w), None, _) => Some(format!("{w:.0} W")),
+ _ => None,
+ };
+ let status = p
+ .get("IsTuned")
+ .and_then(Value::as_bool)
+ .map(|t| if t { "tuned" } else { "untuned" }.to_string());
+ Some(PresetInfo { name, pretty, status })
+ })
+ .collect()
+ })
+ .unwrap_or_default()
+}
+
/// Choose the LuxOS profile name 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
@@ -1284,7 +1318,38 @@ impl Validate for LuxMinerV1 {
#[async_trait]
impl SupportsTuningConfig for LuxMinerV1 {
fn supports_tuning_config(&self) -> bool {
- false
+ true
+ }
+
+ /// LuxOS tunes by named profile (roadmap G3). A `Preset` target is applied
+ /// straight through `profileset`; a `Power` target reuses the watts->profile
+ /// mapping in `set_power_limit`. LuxOS has no hashrate/mining-mode targets and
+ /// per-board manual tuning is not wired, so those targets are refused.
+ async fn set_tuning_config(
+ &self,
+ config: TuningConfig,
+ _scaling_config: Option<asic_rs_core::config::scaling::ScalingConfig>,
+ ) -> anyhow::Result<bool> {
+ match config.target {
+ TuningTarget::Preset(name) => {
+ let resp = self.rpc.profileset(&name).await?;
+ Ok(resp
+ .pointer("/STATUS/0/STATUS")
+ .and_then(Value::as_str)
+ .map(|s| matches!(s, "S" | "I"))
+ .unwrap_or(true))
+ }
+ TuningTarget::Power(p) => self.set_power_limit(p).await,
+ TuningTarget::HashRate(_) => {
+ anyhow::bail!("LuxOS does not tune by hashrate target; select a named profile")
+ }
+ TuningTarget::MiningMode(_) => {
+ anyhow::bail!("LuxOS has no mining modes; select a named profile")
+ }
+ TuningTarget::Manual { .. } => {
+ anyhow::bail!("Per-board manual tuning is not wired for LuxOS")
+ }
+ }
}
}
@@ -1299,7 +1364,21 @@ impl SupportsTemperatureConfig for LuxMinerV1 {}
impl GetTuningPercent for LuxMinerV1 {}
impl SetTuningPercent for LuxMinerV1 {}
-impl SupportsPresets for LuxMinerV1 {}
+#[async_trait]
+impl SupportsPresets for LuxMinerV1 {
+ fn supports_presets(&self) -> bool {
+ true
+ }
+
+ /// The firmware's tunable profiles, read live from the `profiles` RPC (roadmap
+ /// G3). Never hardcoded -- the step list varies by model and tune state.
+ async fn get_presets(&self) -> Vec<PresetInfo> {
+ match self.rpc.profiles().await {
+ Ok(profiles) => parse_profiles_to_presets(&profiles),
+ Err(_) => Vec::new(),
+ }
+ }
+}
#[cfg(test)]
mod tests {
use std::sync::{Arc, Mutex};
@@ -1361,6 +1440,22 @@ mod tests {
assert!(select_profile_at_or_below(&parsed, 2500.0).is_some());
}
+ #[test]
+ fn profiles_parse_to_presets() {
+ // The `profiles` reply becomes one PresetInfo per profile (roadmap G3).
+ let profiles: Value = serde_json::from_str(PROFILES).unwrap();
+ let presets = parse_profiles_to_presets(&profiles);
+ assert_eq!(presets.len(), 25, "one preset per fixture profile");
+ // The factory point is named "default"; its pretty string carries the
+ // watt / hashrate / frequency operating point.
+ let default = presets.iter().find(|p| p.name == "default").unwrap();
+ assert_eq!(default.pretty.as_deref(), Some("2794 W ~ 121.8 TH @ 590 MHz"));
+ // IsTuned maps to the status string.
+ let tuned = presets.iter().find(|p| p.name == "290MHz").unwrap();
+ assert_eq!(tuned.status.as_deref(), Some("tuned"));
+ assert_eq!(default.status.as_deref(), Some("untuned"));
+ }
+
#[tokio::test]
async fn test_luxminer_v1() -> anyhow::Result<()> {
@@ -0,0 +1,233 @@
Subject: [PATCH 0023] telemetry: PSU serial + chip/hashboard type + best-share
Round 19 #10 telemetry extension (tier 1 -- struct-only, no new DataField, and
every command read is already fetched so there are no extra round-trips):
- PsuInfo gains a `serial` field. Braiins v26_04 parse_psu is corrected to read
the human model_name and the firmware fw_version (it had used the numeric type
code as the model and dropped fw_version entirely) and to capture serial_number.
ePIC and WhatsMiner v1/v2 report no PSU serial (left None).
- BoardData gains `chip_type` (ASIC model, e.g. "BM1370") and `hashboard_model`
(e.g. "A3HB70601"). Braiins miner/hw/hashboards populates both.
- best_share (all-time) wired for Antminer v2020 and WhatsMiner v1/v2 from the
already-fetched cgminer/btminer `summary` "Best Share"; those backends had the
empty default GetBestShare (v2023_07 already had it).
Existing fixture tests for braiins/antminer/whatsminer pass unchanged.
diff --git a/vendor/asic-rs-core/src/data/board.rs b/vendor/asic-rs-core/src/data/board.rs
index 1a2c5ead..32ce4e6a 100644
--- a/vendor/asic-rs-core/src/data/board.rs
+++ b/vendor/asic-rs-core/src/data/board.rs
@@ -90,6 +90,12 @@ pub struct BoardData {
pub tuned: Option<bool>,
/// Whether this board is enabled and actively mining
pub active: Option<bool>,
+ /// The ASIC chip type/model on this board (e.g. "BM1370"), when reported.
+ /// Not exposed by Antminer/LuxOS (their network API reports only the control
+ /// board type).
+ pub chip_type: Option<String>,
+ /// The hashboard model / part identifier (e.g. "A3HB70601"), when reported.
+ pub hashboard_model: Option<String>,
}
impl BoardData {
diff --git a/vendor/asic-rs-core/src/data/psu.rs b/vendor/asic-rs-core/src/data/psu.rs
index 810ba47c..cb73b23e 100644
--- a/vendor/asic-rs-core/src/data/psu.rs
+++ b/vendor/asic-rs-core/src/data/psu.rs
@@ -19,6 +19,8 @@ pub struct PsuInfo {
pub model: Option<String>,
/// PSU firmware/hardware version, when reported.
pub version: Option<String>,
+ /// PSU serial number, when reported (Braiins, WhatsMiner V3, VNish).
+ pub serial: Option<String>,
/// Minimum rated output voltage in volts, when reported.
pub voltage_min: Option<f64>,
/// Maximum rated output voltage in volts, when reported.
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 bd8662b1..63f819f8 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -499,6 +499,16 @@ impl GetDataLocations for AntMinerV2020 {
tag: None,
},
)],
+ // cgminer summary "Best Share" (all-time). RPC_SUMMARY is already
+ // fetched, so this adds no round-trip (round 19 #10).
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
// `total_rateideal`, by contrast, says nothing about its own
// scale, so carry STATS' `rate_unit` alongside it.
DataField::ExpectedHashrate => vec![
@@ -873,7 +883,13 @@ impl GetUptime for AntMinerV2020 {
}
}
-impl GetBestShare for AntMinerV2020 {}
+impl GetBestShare for AntMinerV2020 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ // cgminer summary "Best Share" (all-time); guard against a 0 placeholder
+ // (round 19 #10).
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
+ }
+}
impl GetSessionBestShare for AntMinerV2020 {}
impl GetOperatingState for AntMinerV2020 {}
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 9b72ed94..22e34b0b 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
@@ -498,6 +498,16 @@ impl GetHashboards for BraiinsV2604 {
.and_then(|v| v.as_f64())
.map(Frequency::from_hertz);
board.active = chain.pointer("/enabled").and_then(|v| v.as_bool());
+ // ASIC chip model + hashboard model/part (round 19 #10 telemetry
+ // extension). BOS+ miner/hw/hashboards reports chip_type ("BM1370")
+ // and model ("A3HB70601"); board_name is the human label if present.
+ board.chip_type =
+ chain.pointer("/chip_type").and_then(|v| v.as_str()).map(str::to_string);
+ board.hashboard_model = chain
+ .pointer("/model")
+ .or_else(|| chain.pointer("/board_name"))
+ .and_then(|v| v.as_str())
+ .map(str::to_string);
}
hashboards
@@ -676,13 +686,15 @@ impl GetWattage for BraiinsV2604 {
}
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
- // BOS miner/details -> psu_info {version, min_voltage.volt, max_voltage.volt}.
- // "version" is the PSU type code (117 = the APW12 ePIC also reports as model
- // 117), so expose it as the model for consistency across firmwares.
+ // BOS miner/details -> psu_info { model_name, fw_version, serial_number,
+ // version (numeric type code), min_voltage.volt, max_voltage.volt }. Read
+ // the human model_name and the firmware version (the old code used the
+ // numeric "version" type code as the model and dropped fw_version entirely).
let d = data.get(&DataField::Psu)?;
let psu = PsuInfo {
- model: d.pointer("/version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
- version: None,
+ model: d.pointer("/model_name").and_then(|v| v.as_str()).map(str::to_string),
+ version: d.pointer("/fw_version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
+ serial: d.pointer("/serial_number").and_then(|v| v.as_str()).map(str::to_string),
voltage_min: d.pointer("/min_voltage/volt").and_then(|v| v.as_f64()),
voltage_max: d.pointer("/max_voltage/volt").and_then(|v| v.as_f64()),
output_voltage: None,
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 3365824d..7238dc27 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -1128,6 +1128,7 @@ impl GetWattage for PowerPlayV1 {
let psu = PsuInfo {
model: f(info, "/PSU Type").map(|n| format!("{n:.0}")),
version: f(info, "/FW").map(|n| format!("{n:.0}")),
+ serial: None, // ePIC capabilities does not report a PSU serial
voltage_min: f(info, "/Min Vout").map(|mv| mv / 1000.0),
voltage_max: f(info, "/Max Vout").map(|mv| mv / 1000.0),
output_voltage: f(stats, "/Output Voltage"),
diff --git a/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs b/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
index 9617da70..f71750e1 100644
--- a/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
+++ b/vendor/asic-rs-firmwares-sealminer/src/backends/v2025/mod.rs
@@ -474,6 +474,7 @@ impl GetHashboards for SealMinerV2025 {
frequency: freq,
tuned,
active: Some(online),
+ ..Default::default()
}
})
.collect()
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 3c8512ad..eb2bdad8 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v1/mod.rs
@@ -244,6 +244,16 @@ impl GetDataLocations for WhatsMinerV1 {
tag: None,
},
)],
+ // btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
+ // (round 19 #10).
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -483,6 +493,7 @@ impl GetWattage for WhatsMinerV1 {
let psu = PsuInfo {
model: s("/model").or_else(|| s("/name")),
version: s("/hw_version").or_else(|| s("/sw_version")),
+ serial: None, // v1/v2 get_psu does not report a serial (V3 does)
voltage_min: None,
voltage_max: None,
output_voltage: None,
@@ -548,7 +559,11 @@ impl GetUptime for WhatsMinerV1 {
}
}
-impl GetBestShare for WhatsMinerV1 {}
+impl GetBestShare for WhatsMinerV1 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
+ }
+}
impl GetSessionBestShare for WhatsMinerV1 {}
impl GetOperatingState for WhatsMinerV1 {}
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 de36a126..5de37579 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
@@ -255,6 +255,16 @@ impl GetDataLocations for WhatsMinerV2 {
tag: None,
},
)],
+ // btminer summary "Best Share" (all-time); RPC_SUMMARY already fetched
+ // (round 19 #10).
+ DataField::BestShare => vec![(
+ RPC_SUMMARY,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/SUMMARY/0/Best Share"),
+ tag: None,
+ },
+ )],
DataField::ExpectedHashrate => vec![(
RPC_SUMMARY,
DataExtractor {
@@ -490,6 +500,7 @@ impl GetWattage for WhatsMinerV2 {
let psu = PsuInfo {
model: s("/model").or_else(|| s("/name")),
version: s("/hw_version").or_else(|| s("/sw_version")),
+ serial: None, // v1/v2 get_psu does not report a serial (V3 does)
voltage_min: None,
voltage_max: None,
output_voltage: None,
@@ -577,7 +588,11 @@ impl GetUptime for WhatsMinerV2 {
}
}
-impl GetBestShare for WhatsMinerV2 {}
+impl GetBestShare for WhatsMinerV2 {
+ fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
+ data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
+ }
+}
impl GetSessionBestShare for WhatsMinerV2 {}
impl GetOperatingState for WhatsMinerV2 {}
@@ -0,0 +1,93 @@
Subject: [PATCH 0024] whatsminer v3 PSU serial + epic chip/hashboard type
Round 19 #10 telemetry extension, tier 1 sub-batch B. Both fields ride existing
DataFields (Psu / Hashboards) on commands the collector already fetches, so there
are no extra round-trips, and both reuse the PsuInfo.serial and
BoardData.chip_type/hashboard_model fields added in patch 0023 -- no core or GUI
change, the existing columns just populate for more firmwares.
- WhatsMiner V3: add a DataField::Psu location (get.device.info /msg/power) and a
parse_psu that reads model/type, sw/hwversion and the serial (sn). V3 carried
no PSU parse at all (default None) even though /msg/power is already fetched for
the PSU fan.
- ePIC: parse_hashboards now reads capabilities "Chip Type" (e.g. "BM1366") and
"Model Subtype" (e.g. "BHB56801") and applies them to every board (capabilities
reports them miner-wide). The capabilities command is already fetched for
hashboards.
Existing fixture tests for whatsminer/epic pass unchanged.
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 7238dc27..2abb0706 100644
--- a/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
+++ b/vendor/asic-rs-firmwares-epic/src/backends/v1/mod.rs
@@ -797,6 +797,21 @@ impl GetHashboards for PowerPlayV1 {
.pointer("/Capabilities/Performance Estimator/Hashes Per Second Per Chip")
.and_then(|v| v.as_f64());
+ // ASIC chip type + hashboard model from capabilities (round 19 #10);
+ // capabilities reports them miner-wide, so apply to every board.
+ let chip_type =
+ api_data.pointer("/Capabilities/Chip Type").and_then(|v| v.as_str()).map(str::to_string);
+ let hashboard_model = api_data
+ .pointer("/Capabilities/Model Subtype")
+ .and_then(|v| v.as_str())
+ .map(str::to_string);
+ if chip_type.is_some() || hashboard_model.is_some() {
+ for board in &mut hashboards {
+ board.chip_type = chip_type.clone();
+ board.hashboard_model = hashboard_model.clone();
+ }
+ }
+
// Active status
if let Some(boards) = api_data
.pointer("/Summary/HBStatus")
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 c00c6d44..930abe38 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
@@ -21,6 +21,7 @@ use asic_rs_core::{
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
+ psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
util::is_expected_write_error,
@@ -235,6 +236,16 @@ impl GetDataLocations for WhatsMinerV3 {
tag: None,
},
)],
+ // PSU identity block (round 19 #10): get.device.info /msg/power carries
+ // model/type, sw/hwversion and the serial (sn). Already fetched.
+ DataField::Psu => vec![(
+ RPC_GET_DEVICE_INFO,
+ DataExtractor {
+ func: get_by_pointer,
+ key: Some("/msg/power"),
+ tag: None,
+ },
+ )],
DataField::Hashboards => vec![
(
RPC_GET_DEVICE_INFO,
@@ -509,6 +520,18 @@ impl GetWattage for WhatsMinerV3 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<f64, _>(DataField::Wattage, Power::from_watts)
}
+ fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
+ // get.device.info /msg/power: model/type, sw/hwversion, sn (round 19 #10).
+ let d = data.get(&DataField::Psu)?;
+ let s = |k: &str| d.pointer(k).and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(str::to_string);
+ let psu = PsuInfo {
+ model: s("/model").or_else(|| s("/type")),
+ version: s("/swversion").or_else(|| s("/hwversion")),
+ serial: s("/sn"),
+ ..Default::default()
+ };
+ (psu != PsuInfo::default()).then_some(psu)
+ }
}
/// Parses tuning target from V3 tagged data (mode from get.device.info, limit from summary).
/// Mode "0" (Low) / "2" (High) → MiningMode, "1" (Normal) / unknown → Power(limit).
+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
+5
View File
@@ -39,6 +39,11 @@ version = "1.0"
[build-dependencies.embed-resource]
version = "1.3"
# reqwest is only used by build.rs to download the wxWidgets source on
# Windows/macOS; on Linux download_dist() returns before touching it, and it is
# never linked into the runtime binary. Kept at the vendored 0.11 (the build tree
# is fully vendored / offline); the h2 0.3 advisory it pulls is build-time only
# and is documented as accepted in audit.toml (RUSTSEC-2026-0258).
[build-dependencies.reqwest]
version = "0.11"
features = ["blocking"]
File diff suppressed because it is too large Load Diff
+377 -3
View File
@@ -7,6 +7,11 @@
use std::ffi::CString;
use std::os::raw::{c_char, c_int, c_long, c_void};
/// Column alignment for `dvlc_append_text_col` / `dvlc_append_colored_col`.
pub const ALIGN_LEFT: i32 = 0;
pub const ALIGN_RIGHT: i32 = 1;
pub const ALIGN_CENTER: i32 = 2;
mod notsafe {
use std::os::raw::{c_char, c_int, c_long, c_void};
@@ -15,6 +20,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 +28,23 @@ 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_password(parent: *mut c_void) -> *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 +58,23 @@ 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_text_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int, align: c_int);
pub fn wxbr_dvlc_append_colored_col(win: *mut c_void, title: *const c_char, width: c_int, reorderable: c_int, align: 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_autosize_col_capped(win: *mut c_void, pos: c_int, cap_px: 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 +83,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 +110,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 +160,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 +181,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 +196,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 +329,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 +370,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 +390,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,10 +431,24 @@ 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) })
}
/// A single-line text control that masks its content (for password entry).
pub fn password_ctrl(parent: Widget) -> Widget {
Widget(unsafe { notsafe::wxbr_text_ctrl_password(parent.0) })
}
pub fn get_value(&self) -> String {
let mut buf = vec![0i8; 65536];
let n = unsafe { notsafe::wxbr_text_ctrl_get(self.0, buf.as_mut_ptr(), buf.len() as c_int) };
@@ -309,6 +462,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,15 +531,74 @@ 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 {
Widget(unsafe { notsafe::wxbr_dvlc(parent.0) })
}
pub fn dvlc_append_text_col(&self, title: &str, width: i32, reorderable: bool) {
/// Append a text column. `align` is the cell + header alignment:
/// [`ALIGN_LEFT`] (0), [`ALIGN_RIGHT`] (1) or [`ALIGN_CENTER`] (2).
pub fn dvlc_append_text_col(&self, title: &str, width: i32, reorderable: bool, align: i32) {
let c = CString::new(title).unwrap_or_default();
unsafe { notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int) }
unsafe {
notsafe::wxbr_dvlc_append_text_col(self.0, c.as_ptr(), width, reorderable as c_int, align)
}
}
/// 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, align: i32) {
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, align)
};
}
pub fn dvlc_append_toggle_col(&self, width: i32) {
@@ -409,6 +628,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 +660,17 @@ 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) }
}
/// Size the column at display position `pos` to its content, then clamp to
/// `cap_px`: the width becomes min(cap, content-fit) (round 18 #10).
pub fn dvlc_autosize_col_capped(&self, pos: usize, cap_px: i32) {
unsafe { notsafe::wxbr_dvlc_autosize_col_capped(self.0, pos as c_int, cap_px) }
}
/// 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 +705,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 +756,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 +803,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 +868,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":"20173e90df24055f67bf03e2b3bb3bc396168f39aa45b36828b1963749d7838a","Cargo.lock":"2f4e619eefd164b57242e6bae57ddf3f73053f6af308a1dea181936d6a41a291","Cargo.toml":"2310d9df1678c138cc82922659ba19d00a92fd2f107a21047890e53fd79c492d","Cargo.toml.orig":"6c6d97588811d1b3b4c0839aa016d6133745b96f7620d390d093d60a8e29d501","src/config/collector.rs":"8c79ac6d3a04f93efc78b176ef7f6b1dc44e50d2bc95d813439b47422d6bb28f","src/config/fan.rs":"80c305261643542f11368342c3dcea29bbd3b016fb6f2962fdad6489dac2734a","src/config/mod.rs":"0d14701319d84ded3cd2f6ba6f92bff18c8e5cff90a2229592d97baae3ed4de3","src/config/pools.rs":"a74ab648053eb51305c4e1bbb6c05db57575ff2542b4fd53d28d33687a62eee3","src/config/preset.rs":"e68d694d3cf537c67ecb3b535a77904e25cc3b206a6ec214fc904011229b8a7c","src/config/scaling.rs":"f402e00c75ef796068765ab1a82ce6a3a0eb88f484c4a67f574ede90a3abaeeb","src/config/temperature.rs":"c6fd6f9cc8e565f27b58fb571fd33b58dcf2112a50b570f6b54a3c11c13d1fbe","src/config/timezone.rs":"4470fd704885e62e3bc8da8087dce6b002dd3fa92cec54d96ce88a06f03e1cbe","src/config/tuning.rs":"31a0826419d4690315f6eecc03250bfb4e5342431ff261015a9f9f3d87e69b6c","src/data/board.rs":"d6816919357d770f9ae6dedea66bbfdec9ab0f4c8391f9928b90039b668ee026","src/data/capabilities.rs":"29cbab6262fb8888b30b4674a30ef03983e005b4e18eefddfbbf9c568e1e1e17","src/data/collector.rs":"792489f8292863a7d57b9867096349d3257ddaf5bb0b5317e7a4366aa1b9dec9","src/data/command.rs":"53cd7e5e87888a76ba866b33b6d87400112bc3eeb4b5e331a381dfbb2c04579e","src/data/deserialize.rs":"461a84defd6f2fb53c8b3c059463c2bfcf69df80db0f5aa2d30b47e710163992","src/data/device.rs":"813b0d41834b217da9f2d51fc7d9cb0f12db6aa7501dd43b6c3f992f29e7827f","src/data/fan.rs":"9307626335008c04d5e5c742bdd7ff5c6e9055dbd84d0e7a655e6e656da3df78","src/data/firmware.rs":"648acace3b289f623cf678f36fb854ff5ddafb8e2f651ae4a15128ae719f87ba","src/data/hashrate.rs":"9d9e47a33753956fcfef7a5fb2a8eb315464aed41fe25be41acb36dd223a0880","src/data/message.rs":"7b399ab1a0b6e43e61a5461d29a2752beed2d1fd7b214eb891572f8994d47c11","src/data/miner.rs":"641ed29589112fdecf96a2065b05a1878af2a08bb60bff5e624bf56cc08e4a3a","src/data/mod.rs":"620b6876d0c88ad80c4aad1ed8ce8f8c4a76641c1e1c61e02cff115b1ab1da55","src/data/operating_state.rs":"7dccbfcc3eada16d0f890772323d4626fa9f298f7fc1882675ae3672d94f6da3","src/data/pool.rs":"a6bff9e56239915a095c4f99187a2d5f4631c3641332071c5134128cacaecceb","src/data/serialize.rs":"347f8cdf619156ac73aa0d89ed41555bd7332ef60cc92f945bc0f16f4ad29137","src/data/share.rs":"46c927b83eddaec7a01c6e0d8cc3af1d163d724421ecc94d4484db158fa27f4f","src/discovery.rs":"efc236592941e72609bd3be18551834f648b608caaf73b9555f75b9838692f6b","src/errors.rs":"0238c8cb6585d05cdd01aec031895e5240e3883f44f3fa22a7398027a360ef1a","src/lib.rs":"e2c8ecde3cf8edda920470f8b938056b60448184a5c81672f04a8e0235c3cf22","src/test/api.rs":"5defa33709c14cadfa7390981c3c7d3f324ef1878e4ee56c089dbf85665b57ae","src/test/mod.rs":"0b44b178ea8950b75fe09047797085f03e5c0eb17d62ca1f3e62a8f643fda87c","src/test/util.rs":"c6f5a3cccb40f1d6a7c316b52c70c59f8dda24a6ad83cb5aeac0b5d970debd0e","src/traits/auth.rs":"dffa58542ac9e57175f5dcad261f80b3efeba76ef3a039b0d9c6f9eb14a19893","src/traits/discovery.rs":"b232ea113c675178ae62c9f5ee35d0329e3a4465388133992c0db8d697113e34","src/traits/entry.rs":"03cf30045be6ba92a414d36990d316d572be21e6c66039ed8193da9a3c27cf53","src/traits/firmware.rs":"94831620bb8c8c4ce2ad69f8fd7b9679ee1de63b1f99529559e24f2118710638","src/traits/identification.rs":"67866931aa28c2e5b0e07dbacae47c1d82b53addea333f75033c451bbd2c9a77","src/traits/make.rs":"1d099cd51ecb354d20acef4cc1d2b3f75b682b6d6c887553861e185602d465f4","src/traits/miner.rs":"b198869b22a5e56366014a4090946cb44e9cddda32e77c62e57a90ceec8f1348","src/traits/mod.rs":"61406c4d2603299e4bad57c6f90115cadf93cee50a857bbfbb00d99f3a6873ac","src/traits/model.rs":"efde2b5cae4c4f018436bb68b236f354b5a733f7dafdeaf3f1c534b469a22d64","src/util.rs":"53255c65e85b97236cb34b452e2cb522edf377f49d2232645e0e0e33c447bb23"},"package":"1f25e625fc4c645ce995c5609a9fdff6f047d6a5e4d6be9dc167999a43197f58"}
{"$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":"20173e90df24055f67bf03e2b3bb3bc396168f39aa45b36828b1963749d7838a","Cargo.lock":"2f4e619eefd164b57242e6bae57ddf3f73053f6af308a1dea181936d6a41a291","Cargo.toml":"2310d9df1678c138cc82922659ba19d00a92fd2f107a21047890e53fd79c492d","Cargo.toml.orig":"6c6d97588811d1b3b4c0839aa016d6133745b96f7620d390d093d60a8e29d501","src/config/collector.rs":"8c79ac6d3a04f93efc78b176ef7f6b1dc44e50d2bc95d813439b47422d6bb28f","src/config/fan.rs":"80c305261643542f11368342c3dcea29bbd3b016fb6f2962fdad6489dac2734a","src/config/mod.rs":"0d14701319d84ded3cd2f6ba6f92bff18c8e5cff90a2229592d97baae3ed4de3","src/config/pools.rs":"a74ab648053eb51305c4e1bbb6c05db57575ff2542b4fd53d28d33687a62eee3","src/config/preset.rs":"e68d694d3cf537c67ecb3b535a77904e25cc3b206a6ec214fc904011229b8a7c","src/config/scaling.rs":"f402e00c75ef796068765ab1a82ce6a3a0eb88f484c4a67f574ede90a3abaeeb","src/config/temperature.rs":"c6fd6f9cc8e565f27b58fb571fd33b58dcf2112a50b570f6b54a3c11c13d1fbe","src/config/timezone.rs":"4470fd704885e62e3bc8da8087dce6b002dd3fa92cec54d96ce88a06f03e1cbe","src/config/tuning.rs":"31a0826419d4690315f6eecc03250bfb4e5342431ff261015a9f9f3d87e69b6c","src/data/board.rs":"0f2547d5763225a3c5387da695de52b65c38eeb7942d14ecef36a72388c7a451","src/data/capabilities.rs":"29cbab6262fb8888b30b4674a30ef03983e005b4e18eefddfbbf9c568e1e1e17","src/data/collector.rs":"dea53811c7c4f6dc2ba0ae5aab3b7bae9a06dfc9df0eef79117074845a0bf91f","src/data/command.rs":"53cd7e5e87888a76ba866b33b6d87400112bc3eeb4b5e331a381dfbb2c04579e","src/data/deserialize.rs":"461a84defd6f2fb53c8b3c059463c2bfcf69df80db0f5aa2d30b47e710163992","src/data/device.rs":"813b0d41834b217da9f2d51fc7d9cb0f12db6aa7501dd43b6c3f992f29e7827f","src/data/fan.rs":"9307626335008c04d5e5c742bdd7ff5c6e9055dbd84d0e7a655e6e656da3df78","src/data/firmware.rs":"648acace3b289f623cf678f36fb854ff5ddafb8e2f651ae4a15128ae719f87ba","src/data/hashrate.rs":"9d9e47a33753956fcfef7a5fb2a8eb315464aed41fe25be41acb36dd223a0880","src/data/message.rs":"7b399ab1a0b6e43e61a5461d29a2752beed2d1fd7b214eb891572f8994d47c11","src/data/miner.rs":"b07fc087b56cdaba6202a0dd23a1bf14d82f1907a7e3a5424aa98113b73c4fe5","src/data/mod.rs":"f63a6bd20fb2389e434257ccfe646321b25449993c937ece0d29850e0ab2279f","src/data/operating_state.rs":"7dccbfcc3eada16d0f890772323d4626fa9f298f7fc1882675ae3672d94f6da3","src/data/pool.rs":"a6bff9e56239915a095c4f99187a2d5f4631c3641332071c5134128cacaecceb","src/data/serialize.rs":"347f8cdf619156ac73aa0d89ed41555bd7332ef60cc92f945bc0f16f4ad29137","src/data/share.rs":"46c927b83eddaec7a01c6e0d8cc3af1d163d724421ecc94d4484db158fa27f4f","src/discovery.rs":"efc236592941e72609bd3be18551834f648b608caaf73b9555f75b9838692f6b","src/errors.rs":"0238c8cb6585d05cdd01aec031895e5240e3883f44f3fa22a7398027a360ef1a","src/lib.rs":"e2c8ecde3cf8edda920470f8b938056b60448184a5c81672f04a8e0235c3cf22","src/test/api.rs":"5defa33709c14cadfa7390981c3c7d3f324ef1878e4ee56c089dbf85665b57ae","src/test/mod.rs":"0b44b178ea8950b75fe09047797085f03e5c0eb17d62ca1f3e62a8f643fda87c","src/test/util.rs":"c6f5a3cccb40f1d6a7c316b52c70c59f8dda24a6ad83cb5aeac0b5d970debd0e","src/traits/auth.rs":"dffa58542ac9e57175f5dcad261f80b3efeba76ef3a039b0d9c6f9eb14a19893","src/traits/discovery.rs":"b232ea113c675178ae62c9f5ee35d0329e3a4465388133992c0db8d697113e34","src/traits/entry.rs":"03cf30045be6ba92a414d36990d316d572be21e6c66039ed8193da9a3c27cf53","src/traits/firmware.rs":"94831620bb8c8c4ce2ad69f8fd7b9679ee1de63b1f99529559e24f2118710638","src/traits/identification.rs":"67866931aa28c2e5b0e07dbacae47c1d82b53addea333f75033c451bbd2c9a77","src/traits/make.rs":"1d099cd51ecb354d20acef4cc1d2b3f75b682b6d6c887553861e185602d465f4","src/traits/miner.rs":"7ed55e9b085ea156357d0519c42e2b622e89fa2f81458bc73c42b6cfc6a94819","src/traits/mod.rs":"61406c4d2603299e4bad57c6f90115cadf93cee50a857bbfbb00d99f3a6873ac","src/traits/model.rs":"efde2b5cae4c4f018436bb68b236f354b5a733f7dafdeaf3f1c534b469a22d64","src/util.rs":"53255c65e85b97236cb34b452e2cb522edf377f49d2232645e0e0e33c447bb23"},"package":"1f25e625fc4c645ce995c5609a9fdff6f047d6a5e4d6be9dc167999a43197f58"}
+6
View File
@@ -90,6 +90,12 @@ pub struct BoardData {
pub tuned: Option<bool>,
/// Whether this board is enabled and actively mining
pub active: Option<bool>,
/// The ASIC chip type/model on this board (e.g. "BM1370"), when reported.
/// Not exposed by Antminer/LuxOS (their network API reports only the control
/// board type).
pub chip_type: Option<String>,
/// The hashboard model / part identifier (e.g. "A3HB70601"), when reported.
pub hashboard_model: Option<String>,
}
impl BoardData {
+3
View File
@@ -74,6 +74,9 @@ pub enum DataField {
/// Current power consumption in watts.
#[cfg_attr(feature = "python", pydantic(value = "Wattage"))]
Wattage,
/// Power-supply info (identity, rated voltage envelope, live output V/A).
#[cfg_attr(feature = "python", pydantic(value = "Psu"))]
Psu,
/// manual tuning percent of full power (100 = unthrottled).
#[cfg_attr(feature = "python", pydantic(value = "TuningPercent"))]
TuningPercent,
+4
View File
@@ -16,6 +16,7 @@ use super::{
message::MinerMessage,
operating_state::OperatingState,
pool::PoolGroupData,
psu::PsuInfo,
};
use crate::data::{
deserialize::deserialize_macaddr,
@@ -192,6 +193,9 @@ pub struct MinerData {
#[serde(serialize_with = "serialize_power")]
#[ts(type = "number | null")]
pub wattage: Option<Power>,
/// Power-supply info (identity, rated voltage envelope, live output V/A),
/// when the firmware reports it.
pub psu: Option<PsuInfo>,
/// The current manual tuning percent of full power (100 = unthrottled), where supported
pub tuning_percent: Option<u8>,
/// The current tuning target of the miner, such as power target or hashrate target
+1
View File
@@ -15,5 +15,6 @@ pub mod message;
pub mod miner;
pub mod operating_state;
pub mod pool;
pub mod psu;
pub(crate) mod serialize;
pub mod share;
+32
View File
@@ -0,0 +1,32 @@
//! Power-supply (PSU) information reported by a miner's firmware.
//!
//! A backend fills in only what its firmware actually exposes; every field is
//! optional. Some firmware reports the PSU's identity and rated voltage envelope
//! (min/max output voltage), others also report the live output voltage and
//! current. Voltages are in volts and currents in amps.
#[cfg(feature = "python")]
use pyo3::pyclass;
use serde::{Deserialize, Serialize};
use ts_rs::TS;
/// Power-supply identity and voltage telemetry for one miner.
#[cfg_attr(feature = "python", pyclass(from_py_object, module = "asic_rs"))]
#[cfg_attr(feature = "python", asic_rs_pydantic::py_pydantic_model(getters))]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
pub struct PsuInfo {
/// PSU model / type identifier, when reported.
pub model: Option<String>,
/// PSU firmware/hardware version, when reported.
pub version: Option<String>,
/// PSU serial number, when reported (Braiins, WhatsMiner V3, VNish).
pub serial: Option<String>,
/// Minimum rated output voltage in volts, when reported.
pub voltage_min: Option<f64>,
/// Maximum rated output voltage in volts, when reported.
pub voltage_max: Option<f64>,
/// Live output voltage in volts, when reported.
pub output_voltage: Option<f64>,
/// Live output current in amps, when reported.
pub output_current: Option<f64>,
}
+7
View File
@@ -33,6 +33,7 @@ use crate::{
miner::{MinerData, TuningTarget},
operating_state::OperatingState,
pool::PoolGroupData,
psu::PsuInfo,
},
traits::firmware::MinerFirmware,
traits::model::MinerModel,
@@ -272,6 +273,7 @@ impl<
let hashrate = self.parse_hashrate(&data);
let expected_hashrate = self.parse_expected_hashrate(&data);
let wattage = self.parse_wattage(&data);
let psu = self.parse_psu(&data);
let tuning_percent = self.parse_tuning_percent(&data);
let tuning_target = self.parse_tuning_target(&data);
let scaled_tuning_target = self.parse_scaled_tuning_target(&data);
@@ -367,6 +369,7 @@ impl<
// Power information
wattage,
psu,
tuning_percent,
tuning_target,
scaled_tuning_target,
@@ -720,6 +723,10 @@ pub trait GetWattage: CollectData {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
None
}
#[allow(unused_variables)]
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
None
}
}
// Tuning Percent
+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":"63872e035c349d10a5377a8992d635bd053911970e29e4bc46b0c6d239994cec","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":"0c294d8515c56149571d2a504d68352bdaa206d0b996056f560c2ec60d9927f4","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"}
+169 -27
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.
@@ -453,6 +499,16 @@ impl GetDataLocations for AntMinerV2020 {
tag: None,
},
)],
// cgminer summary "Best Share" (all-time). RPC_SUMMARY is already
// fetched, so this adds no round-trip (round 19 #10).
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
// `total_rateideal`, by contrast, says nothing about its own
// scale, so carry STATS' `rate_unit` alongside it.
DataField::ExpectedHashrate => vec![
@@ -722,6 +778,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 +804,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 +843,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;
}
}
}
@@ -793,7 +883,13 @@ impl GetUptime for AntMinerV2020 {
}
}
impl GetBestShare for AntMinerV2020 {}
impl GetBestShare for AntMinerV2020 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// cgminer summary "Best Share" (all-time); guard against a 0 placeholder
// (round 19 #10).
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
}
impl GetSessionBestShare for AntMinerV2020 {}
impl GetOperatingState for AntMinerV2020 {}
@@ -879,11 +975,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 +1127,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 +1493,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},
@@ -521,8 +521,40 @@ impl GetDataLocations for AntMinerV202307 {
tag: None,
},
),
// Bixbit-based firmware reports Power=0 in stats but the real
// figure as "Power Estimated" in the cgminer summary; carry it
// under a "summary" tag so parse_wattage can fall back to it
// without colliding with the stats keys (round 17 R7).
(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: Some("summary"),
},
),
]
}
// Best share (all-time / session) from the cgminer summary. Antminer
// stock, Bixbit, and other cgminer-based firmware all report it here;
// it was previously unmapped, so best-share was blank fleet-wide
// (round 17 R7).
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::SerialNumber => vec![
(
WEB_SYSTEM_INFO,
@@ -698,6 +730,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,
@@ -769,8 +810,6 @@ impl GetUptime for AntMinerV202307 {
}
}
impl GetBestShare for AntMinerV202307 {}
impl GetSessionBestShare for AntMinerV202307 {}
impl GetOperatingState for AntMinerV202307 {}
@@ -879,21 +918,52 @@ impl GetWattage for AntMinerV202307 {
}
}
if let Some(power) = stats_data
let primary = stats_data
.get("power")
.or_else(|| stats_data.get("Power"))
// Same firmware version spells this differently per model: the
// L9 reports `power`, the L11 `watt`.
.or_else(|| stats_data.get("watt"))
.and_then(|v| v.as_f64())
.and_then(|v| v.as_f64());
if let Some(power) = primary
&& power > 0.0
{
return Some(Power::from_watts(power));
}
// Bixbit-based firmware leaves the stats power at 0 and reports the
// real draw as "Power Estimated" in the summary (round 17 R7).
if let Some(est) = stats_data
.pointer("/summary/Power Estimated")
.and_then(|v| v.as_f64())
&& est > 0.0
{
return Some(Power::from_watts(est));
}
// Preserve the prior behaviour: a present-but-zero stats power still
// reads as 0 W rather than blank.
if let Some(power) = primary {
return Some(Power::from_watts(power));
}
}
None
}
}
impl GetBestShare for AntMinerV202307 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// cgminer summary "Best Share" (all-time). Guard against a firmware that
// reports 0 when it has never found a share (round 17 R7).
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
}
impl GetSessionBestShare for AntMinerV202307 {
fn parse_session_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
data.extract::<f64>(DataField::SessionBestShare)
.filter(|&v| v > 0.0)
}
}
impl GetTuningTarget for AntMinerV202307 {
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
data.get(&DataField::TuningTarget)
+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
+54 -1
View File
@@ -22,6 +22,7 @@ use asic_rs_core::{
miner::TuningTarget,
operating_state::OperatingState,
pool::{PoolData, PoolGroupData, PoolURL},
psu::PsuInfo,
},
traits::{miner::*, model::MinerModel},
};
@@ -286,6 +287,24 @@ 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,
},
)],
// PSU identity + rated voltage envelope (round 17 R5/G15). BOS reports
// it at miner/details -> psu_info {version, min_voltage, max_voltage}.
DataField::Psu => vec![(
WEB_MINER_DETAILS,
DataExtractor {
func: get_by_pointer,
key: Some("/psu_info"),
tag: None,
},
)],
DataField::TuningTarget => vec![
(
WEB_MINER_CONFIGURATION,
@@ -479,6 +498,16 @@ impl GetHashboards for BraiinsV2604 {
.and_then(|v| v.as_f64())
.map(Frequency::from_hertz);
board.active = chain.pointer("/enabled").and_then(|v| v.as_bool());
// ASIC chip model + hashboard model/part (round 19 #10 telemetry
// extension). BOS+ miner/hw/hashboards reports chip_type ("BM1370")
// and model ("A3HB70601"); board_name is the human label if present.
board.chip_type =
chain.pointer("/chip_type").and_then(|v| v.as_str()).map(str::to_string);
board.hashboard_model = chain
.pointer("/model")
.or_else(|| chain.pointer("/board_name"))
.and_then(|v| v.as_str())
.map(str::to_string);
}
hashboards
@@ -548,7 +577,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 {
@@ -649,6 +684,24 @@ impl GetWattage for BraiinsV2604 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
data.extract_map::<i64, _>(DataField::Wattage, |w| Power::from_watts(w as f64))
}
fn parse_psu(&self, data: &HashMap<DataField, Value>) -> Option<PsuInfo> {
// BOS miner/details -> psu_info { model_name, fw_version, serial_number,
// version (numeric type code), min_voltage.volt, max_voltage.volt }. Read
// the human model_name and the firmware version (the old code used the
// numeric "version" type code as the model and dropped fw_version entirely).
let d = data.get(&DataField::Psu)?;
let psu = PsuInfo {
model: d.pointer("/model_name").and_then(|v| v.as_str()).map(str::to_string),
version: d.pointer("/fw_version").and_then(|v| v.as_i64()).map(|n| n.to_string()),
serial: d.pointer("/serial_number").and_then(|v| v.as_str()).map(str::to_string),
voltage_min: d.pointer("/min_voltage/volt").and_then(|v| v.as_f64()),
voltage_max: d.pointer("/max_voltage/volt").and_then(|v| v.as_f64()),
output_voltage: None,
output_current: None,
};
(psu != PsuInfo::default()).then_some(psu)
}
}
impl GetTuningTarget 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":"b272ad45e4e44a56718596485aa6c3f9f3b28516a6d80d329a1f1594ccc3de95","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"}

Some files were not shown because too many files have changed in this diff Show More