Compare commits

...
18 Commits
Author SHA1 Message Date
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
27 changed files with 3582 additions and 228 deletions
+115
View File
@@ -0,0 +1,115 @@
//! 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).
use std::process::Command;
use std::time::Duration;
/// 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 over its web API with the given credentials.
/// Returns `Ok(Some(true/false))` on a decisive lock/unlock answer, `Ok(None)`
/// if reachable-but-indeterminate or a vendor this probe doesn't cover, or
/// `Err` only on a failure to run curl at all.
pub fn probe_access(ip: &str, firmware: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
let url = format!("http://{ip}{}", endpoint(firmware));
let userpass = format!("{user}:{pass}");
let mut cmd = Command::new("curl");
cmd.args([
"-s",
"-o",
"/dev/null",
"-w",
"%{http_code}",
"--digest",
"-u",
&userpass,
"--connect-timeout",
"5",
"--max-time",
"9",
&url,
]);
let out = wait_with_timeout(cmd, Duration::from_secs(12))?;
// curl prints the status code to stdout regardless of exit status (000 on a
// connection failure), so classify the code rather than the exit status.
let code = String::from_utf8_lossy(&out.stdout);
Ok(classify_http_code(&code))
}
/// Run a command with a wall-clock timeout (curl can hang past --max-time on a
/// black-holed host).
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
use std::io::Read;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(status) => {
let mut stdout = Vec::new();
let mut stderr = Vec::new();
if let Some(mut o) = child.stdout.take() {
let _ = o.read_to_end(&mut stdout);
}
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
}
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
return Err("curl timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
}
}
}
}
#[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);
}
}
+97
View File
@@ -0,0 +1,97 @@
//! miner_probe -- a read-only (by default) asic-rs diagnostic for live-hardware
//! verification of the round-9 power-limit work. It reuses the same MinerFactory
//! + saved-credential setup the GUI uses (see crate::credentials), but as a
//! standalone CLI so hardware checks don't go through the wx event loop.
//!
//! Usage:
//! miner_probe scan <cidr> [<cidr>...]
//! Scan the given subnets and print, per responder (TSV):
//! ip make firmware model_id control_board watts supports_power_limit supports_tuning
//!
//! Mutation modes (setpl) are intentionally NOT included here: asic-rs exposes
//! no read-back of a miner's configured power limit, so an exact
//! restore-to-prior-state cannot be guaranteed from this tool alone.
use asic_rs::MinerFactory;
use asic_rs::core::traits::miner::MinerAuth;
use futures_util::StreamExt;
fn load_creds() -> Option<(String, String)> {
let home = std::env::var("HOME").ok()?;
let p = std::path::PathBuf::from(home)
.join(".config/alkane-toolkit/scan-credentials.txt");
let s = std::fs::read_to_string(p).ok()?;
let mut l = s.lines();
let u = l.next()?.to_string();
let pw = l.next().unwrap_or("").to_string();
Some((u, pw))
}
fn factory() -> MinerFactory {
let mut f = MinerFactory::new();
if let Some((u, pw)) = load_creds() {
for fw in asic_rs::factory::default_firmware_registry() {
f = f.with_firmware_discovery_auth(fw.as_ref(), MinerAuth::new(u.clone(), pw.clone()));
}
eprintln!("(using saved scan credentials for discovery auth)");
} else {
eprintln!("(no saved credentials -- backends use their default auth)");
}
f
}
async fn scan(cidrs: &[String]) {
let mut f = factory();
for c in cidrs {
f = match f.with_subnet(c) {
Ok(f) => f,
Err(e) => {
eprintln!("bad subnet {c}: {e}");
return;
}
};
}
println!("ip\tmake\tfirmware\tmodel_id\tcontrol_board\twatts\tsupports_power_limit\tsupports_tuning");
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();
println!(
"{ip}\t{}\t{}\t{}\t{}\t{watts:.0}\t{}\t{}",
data.device_info.make,
data.device_info.firmware,
data.device_info.model,
cb,
m.supports_set_power_limit(),
m.supports_set_tuning_percent(),
);
found += 1;
}
}
eprintln!("scan complete: {found} miner(s) responded");
}
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..])),
_ => {
eprintln!("usage: miner_probe scan <cidr> [<cidr>...]");
std::process::exit(2);
}
}
}
+41 -10
View File
@@ -14,20 +14,24 @@ use asic_rs::core::traits::miner::MinerAuth;
use crate::scan::config_path;
pub const CREDENTIALS_FILE: &str = "scan-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 the saved miner username/password, if any were saved.
pub fn load_credentials() -> Option<(String, String)> {
let s = std::fs::read_to_string(config_path(CREDENTIALS_FILE)).ok()?;
/// 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 the miner username/password, restricting the file to owner
/// read/write (credentials are plaintext on disk, so the mode matters).
pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
let p = config_path(CREDENTIALS_FILE);
/// 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)?;
}
@@ -47,15 +51,42 @@ pub fn save_credentials(user: &str, pass: &str) -> std::io::Result<()> {
Ok(())
}
/// Remove the saved credentials, if any. Not an error if none were saved.
pub fn clear_credentials() -> std::io::Result<()> {
match std::fs::remove_file(config_path(CREDENTIALS_FILE)) {
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 for the PIC probe, if any.
pub fn load_ssh_credentials() -> Option<(String, String)> {
load_creds_file(SSH_CREDENTIALS_FILE)
}
/// Save the SSH username/password for the PIC probe (0600).
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),
}
}
/// Build a `MinerFactory` with the saved credentials (if any) applied as
/// discovery auth for every firmware backend, so scans, refreshes, config
/// actions, and firmware flashes all authenticate against a non-default
+81 -33
View File
@@ -14,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,
@@ -47,23 +53,67 @@ impl Board {
} else {
vec![]
};
// Three per-hashboard chip temps around the average (so the offline demo
// shows the "77 / 64 / 74" per-board Chip-temp cell).
let board_temps = if self.mining && self.temp > 0.0 {
vec![self.temp + 2.0, self.temp - 3.0, self.temp + 1.0]
} else {
vec![]
};
// Air-cooled WhatsMiners report an ambient reading (asic-rs surfaces it in
// its fluid_temperature field); the scan routes it to env_temp for
// air-cooled models, so the demo mirrors that (round 11 #17).
let env_temp_c = if self.mining && self.make.eq_ignore_ascii_case("whatsminer") {
27.0
} else {
0.0
};
// Per-hashboard health dots for the Boards column (round 11 #10): mining
// units show three green dots, except two demo cases -- the slow S21 Pro
// has one faulted (red) board, and one VNish S19 has a board that wasn't
// detected (grey) -- so the offline demo exercises all three states.
use crate::model::BoardHealth::{Fault, Missing, Ok};
let board_status = if self.mining {
match self.ip {
"10.255.1.149" => vec![Ok, Fault, Ok],
"10.255.1.166" => vec![Ok, Ok, Missing],
_ => vec![Ok, Ok, Ok],
}
} else {
vec![]
};
// Firmware-flash capability is modeled on the real Bitmain/Antminer
// upgrade path (S17/S19/S21 family); WhatsMiner boards in this fleet
// don't advertise it, so both true and false show up and the
// firmware menu item is testable.
let firmware_flash = self.model == "Antminer S17"
|| self.model.starts_with("Antminer S19")
|| self.model.starts_with("Antminer S21");
let firmware_flash = self.make.eq_ignore_ascii_case("antminer")
&& (self.model_id == "S17"
|| self.model_id.starts_with("S19")
|| self.model_id.starts_with("S21"));
// Derive the display identity through the same path the live scan uses.
let brand = crate::naming::brand(self.make);
let model = crate::naming::clean_model(self.make, self.model_id);
let submodel = crate::naming::submodel(self.make, self.model_id);
let control_board = crate::naming::control_board_code(self.make, self.board, &model);
let cpu = crate::naming::control_board_cpu(self.make, self.board, &model);
let board_code = crate::naming::control_board_board(self.make, self.board, &model);
MinerRow {
ip: self.ip.to_string(),
selected: false,
model: self.model.to_string(),
model,
brand,
submodel,
firmware: self.firmware.to_string(),
fw_version: self.fw_version.to_string(),
cpu,
board_code,
hashrate_ths: self.hashrate,
expected_ths: self.expected,
efficiency,
power_w: self.power,
chip_temp_c: self.temp,
board_temps,
env_temp_c,
fan_rpms,
worker: self.worker.to_string(),
is_mining: self.mining,
@@ -74,10 +124,13 @@ impl Board {
hostname: format!("miner-{last_octet}"),
hashboards: boards,
expected_hashboards: Some(3),
board_status,
total_chips: chips,
psu_fan_rpm: if self.mining { self.fan * 0.9 } else { 0.0 },
uptime_secs: if self.mining { 3600 * 24 * 2 + 3600 * 5 } else { 0 },
light_flashing: Some(false),
// One unit is "being located" so the Light column's yellow dot is
// demonstrable offline (round 11 #10).
light_flashing: Some(self.ip == "10.255.1.167"),
pool_url: if self.worker.is_empty() { String::new() } else { "stratum+tcp://pool.blueflare:3333".to_string() },
pools: if self.worker.is_empty() {
Vec::new()
@@ -106,22 +159,13 @@ impl Board {
tuning: self.mining,
firmware_flash,
},
// Demo values for the round-8 columns (synthetic, so the columns
// show variety offline).
control_board: if self.model.contains("S17") {
"Xilinx".to_string()
} else if self.model.contains("S19j") || self.model.contains("S19k") {
"AMLogic".to_string()
} else if self.model.contains("S19") {
"BeagleBone Black".to_string()
} else if self.model.contains("S21") {
"CVITek".to_string()
} else {
String::new()
},
pic_present: if self.model.contains("S21") {
// Demo values for the round-8/9 columns (synthetic, so the columns
// show variety offline). control_board is derived above via naming.
algorithm: "SHA256".to_string(),
control_board,
pic_present: if self.model_id.contains("S21") {
Some(false) // noPIC example
} else if self.model.starts_with("Antminer") {
} else if self.make.eq_ignore_ascii_case("antminer") {
Some(true)
} else {
None // WhatsMiner: unknown over the network
@@ -129,10 +173,12 @@ impl Board {
// 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()),
errors: if self.model.contains("S21 Pro") {
// 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![
"[Warning] hashrate 70% below expected".to_string(),
"[Warning] chip temperature high (HashBoard 2)".to_string(),
"hashrate 70% below expected".to_string(),
"chip temperature high (HashBoard 2)".to_string(),
]
} else {
Vec::new()
@@ -152,33 +198,35 @@ impl Board {
/// 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, paused: false },
Board { ip: "10.255.1.166", model: "Antminer S19", firmware: "[removed] 1.2",
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, paused: false },
Board { ip: "10.255.1.152", model: "Antminer S19j Pro", firmware: "[removed] 1.2",
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, paused: false },
Board { ip: "10.255.1.167", model: "Antminer S19k Pro", firmware: "[removed] 1.2",
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, paused: false },
Board { ip: "10.255.1.149", model: "Antminer S21 Pro", firmware: "Stock",
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, paused: false }, // slow: 60/200 = 30%
Board { ip: "10.255.1.126", model: "WhatsMiner M30S", firmware: "WMOS H3",
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, paused: false },
Board { ip: "10.255.1.131", model: "WhatsMiner M30S+", firmware: "WMOS H616",
Board { ip: "10.255.1.131", make: "Whatsminer", model_id: "M30SPlusVE40", board: "H616", firmware: "Hive", fw_version: "1.0",
hashrate: 100.0, expected: 100.0, power: 3450.0, temp: 71.0, fan: 4900.0,
worker: "blueflare.h616", mining: true, paused: false },
Board { ip: "10.255.1.148", model: "WhatsMiner M50", firmware: "WMOS CB4",
Board { ip: "10.255.1.148", make: "Whatsminer", model_id: "M50VH50", board: "H6", firmware: "BixBit", fw_version: "2.1",
hashrate: 118.0, expected: 122.0, power: 3300.0, temp: 66.0, fan: 4600.0,
worker: "blueflare.m50", mining: true, 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", model: "Antminer S19", firmware: "WardenOS dev",
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, paused: true },
];
+3
View File
@@ -1,9 +1,12 @@
//! alkane-toolkit — primary view (docs/UI-SPEC.md).
//! Pure-Rust wxWidgets app on the vendored, patched wx-rs.
mod access_probe;
mod credentials;
mod fixtures;
mod model;
mod naming;
mod pic_probe;
mod presets;
mod scan;
mod ui;
+188 -29
View File
@@ -134,6 +134,16 @@ pub fn decode_segments_plain(s: &str) -> String {
.collect::<String>()
}
/// Split a full pool worker "account.worker" into (account, worker). Mining
/// pools name a worker "<account>.<rig>"; split on the first '.'. With no '.',
/// the whole string is the account and the worker name is empty.
fn split_worker(full: &str) -> (&str, &str) {
match full.split_once('.') {
Some((account, worker)) => (account, worker),
None => (full, ""),
}
}
/// Compact human duration (e.g. "3d 4h", "5h 12m", "42m", "18s").
pub fn format_uptime(secs: u64) -> String {
if secs == 0 {
@@ -226,6 +236,16 @@ impl MinerCaps {
}
}
/// Per-hashboard health for the Boards column's status dots (round 11 #10):
/// green = present and hashing, red = present but idle/faulty, grey = expected
/// but not detected at all.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BoardHealth {
Ok,
Fault,
Missing,
}
/// One miner's telemetry snapshot, flattened from asic-rs `MinerData` into the
/// scalar fields the table can display. Absent metrics are `None` / empty /
/// 0.0 and render as a blank cell.
@@ -237,12 +257,27 @@ pub struct MinerRow {
pub caps: MinerCaps,
// identity
pub model: String,
/// Manufacturer brand ("Antminer", "WhatsMiner", ...), its own column so the
/// Model column can carry just the cleaned model name.
pub brand: String,
/// Model sub-variant: WhatsMiner's version block ("VE40"); blank for Antminer
/// (its hashboard type is not reported over the network by asic-rs).
pub submodel: String,
pub mac: String,
pub hostname: String,
pub serial: String,
/// Firmware family only ("Stock", "VNish", "Braiins", ...); the Firmware
/// column colours by this. The version string lives in `fw_version`.
pub firmware: String,
pub fw_version: String,
pub api_version: String,
/// Combined "CPU (code)" control-board label (e.g. "AML (C76)"); `cpu` and
/// `board_code` hold the split halves for their own columns.
pub control_board: String,
pub cpu: String,
pub board_code: String,
/// Mining algorithm (e.g. "SHA256", "Scrypt", "Equihash"), from asic-rs.
pub algorithm: String,
/// Whether the hashboards carry a PIC MCU. asic-rs does not report this over
/// the network, so it is a best-effort inference (model-string heuristic):
/// `None` = unknown, `Some(true)` = PIC, `Some(false)` = noPIC. True
@@ -264,8 +299,20 @@ pub struct MinerRow {
pub power_w: f64,
pub tuning_percent: Option<u8>,
// thermal / cooling
/// Average chip temperature (used for sorting/colour banding of the
/// combined Chip-temp cell).
pub chip_temp_c: f64,
/// Per-hashboard chip temperature (hottest chip per board), shown in the
/// Chip-temp column as "77 / 64 / 74". Empty falls back to the average.
pub board_temps: Vec<f64>,
/// Coolant/immersion-fluid temperature (liquid-cooled miners only).
pub fluid_temp_c: f64,
/// Environment/ambient air temperature. asic-rs reports air-cooled miners'
/// ambient reading in its `fluid_temperature` field (see the WhatsMiner
/// backends' "Env Temp"/"environment-temperature" key); the scan routes it
/// here for air-cooled models so it isn't mislabelled as a fluid temp
/// (round 11 #17).
pub env_temp_c: f64,
pub outlet_temp_c: f64,
/// Individual cooling-fan RPMs (empty if unknown). PSU fan is tracked
/// separately below since it is not part of the cooling-fan set.
@@ -278,6 +325,10 @@ pub struct MinerRow {
pub expected_chips: Option<u32>,
pub hashboards: Option<u32>,
pub expected_hashboards: Option<u32>,
/// Per-hashboard health for the Boards status dots (round 11 #10), one entry
/// per expected board, ordered by position (index 0 = board 1). Empty = no
/// per-board data (the cell renders blank).
pub board_status: Vec<BoardHealth>,
// pool: active-pool convenience fields, plus the (url, worker) of each
// configured pool (miners usually allow up to 3 redundant pools).
pub worker: String,
@@ -349,15 +400,25 @@ pub fn flash_confirmed(input: &str) -> bool {
pub enum Column {
Ip,
Hashrate,
/// Sort-only pseudo-column (round 11 #16): the actual/expected hashrate
/// ratio. Deliberately NOT in `ALL_COLUMNS`, so it never appears in the
/// column picker or the display order; it exists only as a `sort` target the
/// Hashrate header cycles into.
HashrateRel,
Power,
ChipTemp,
Cooling,
Firmware,
FwVersion,
Worker,
PoolAccount,
Model,
Brand,
Submodel,
Status,
Efficiency,
FluidTemp,
EnvTemp,
OutletTemp,
PsuFan,
FanCount,
@@ -368,7 +429,9 @@ pub enum Column {
Hostname,
Serial,
ApiVersion,
ControlBoard,
Cpu,
BoardCode,
Algorithm,
Pic,
Locked,
Error,
@@ -389,18 +452,23 @@ pub enum Column {
/// Every column, in registry order. Ip first, then the default-visible set
/// (UI-SPEC order), then all remaining metrics.
pub const ALL_COLUMNS: [Column; 38] = [
pub const ALL_COLUMNS: [Column; 45] = [
Column::Ip,
Column::Hashrate,
Column::Power,
Column::ChipTemp,
Column::Cooling,
Column::Firmware,
Column::FwVersion,
Column::Worker,
Column::PoolAccount,
Column::Model,
Column::Brand,
Column::Submodel,
Column::Status,
Column::Efficiency,
Column::FluidTemp,
Column::EnvTemp,
Column::OutletTemp,
Column::PsuFan,
Column::FanCount,
@@ -411,7 +479,9 @@ pub const ALL_COLUMNS: [Column; 38] = [
Column::Hostname,
Column::Serial,
Column::ApiVersion,
Column::ControlBoard,
Column::Cpu,
Column::BoardCode,
Column::Algorithm,
Column::Pic,
Column::Locked,
Column::Error,
@@ -430,16 +500,19 @@ pub const ALL_COLUMNS: [Column; 38] = [
Column::Pool3Worker,
];
/// The columns shown by default (UI-SPEC), after the fixed IP column.
pub const DEFAULT_VISIBLE: [Column; 8] = [
/// The columns shown by default (UI-SPEC), after the fixed IP column, in display
/// order: model, errors, hashrate, power, chip temp, firmware, CPU, boards
/// (hashboard health), access.
pub const DEFAULT_VISIBLE: [Column; 9] = [
Column::Model,
Column::Error,
Column::Hashrate,
Column::Power,
Column::ChipTemp,
Column::Cooling,
Column::Firmware,
Column::Worker,
Column::Model,
Column::Status,
Column::Cpu,
Column::Hashboards,
Column::Locked,
];
impl Column {
@@ -447,15 +520,21 @@ impl Column {
match self {
Column::Ip => "IP",
Column::Hashrate => "Hashrate",
Column::HashrateRel => "Rel. hashrate",
Column::Power => "Power",
Column::ChipTemp => "Chip temp",
Column::Cooling => "Fan (RPM)",
Column::Firmware => "Firmware",
Column::Worker => "Pool worker",
Column::FwVersion => "FW Version",
Column::Worker => "Worker",
Column::PoolAccount => "Pool account",
Column::Model => "Model",
Column::Brand => "Brand",
Column::Submodel => "Submodel",
Column::Status => "Status",
Column::Efficiency => "Efficiency (J/TH)",
Column::FluidTemp => "Fluid temp",
Column::EnvTemp => "Env temp",
Column::OutletTemp => "Outlet temp",
Column::PsuFan => "PSU fan (RPM)",
Column::FanCount => "Fans",
@@ -466,7 +545,9 @@ impl Column {
Column::Hostname => "Hostname",
Column::Serial => "Serial",
Column::ApiVersion => "API ver",
Column::ControlBoard => "Control board",
Column::Cpu => "CPU",
Column::BoardCode => "Board",
Column::Algorithm => "Algorithm",
Column::Pic => "PIC",
Column::Locked => "Access",
Column::Error => "Errors",
@@ -490,19 +571,26 @@ impl Column {
match self {
Column::Ip => 130,
Column::Hashrate => 110,
Column::HashrateRel => 110,
Column::Power => 90,
Column::ChipTemp | Column::FluidTemp | Column::OutletTemp => 95,
Column::ChipTemp | Column::FluidTemp | Column::EnvTemp | Column::OutletTemp => 95,
Column::Cooling | Column::PsuFan => 100,
Column::Firmware => 160,
Column::Worker => 150,
Column::Firmware => 110,
Column::FwVersion => 130,
Column::Worker => 130,
Column::PoolAccount => 120,
Column::Model => 150,
Column::Brand => 100,
Column::Submodel => 100,
Column::Status => 95,
Column::Efficiency => 120,
Column::FanCount | Column::TotalChips | Column::Hashboards => 70,
Column::ExpectedFans | Column::TuningPercent => 90,
Column::Mac | Column::Hostname | Column::Serial => 150,
Column::ApiVersion | Column::Light => 90,
Column::ControlBoard => 130,
Column::Cpu => 70,
Column::BoardCode => 70,
Column::Algorithm => 100,
Column::Pic => 70,
Column::Locked => 90,
Column::Error => 160,
@@ -521,10 +609,12 @@ impl Column {
matches!(
self,
Column::Hashrate
| Column::HashrateRel
| Column::Power
| Column::Efficiency
| Column::ChipTemp
| Column::FluidTemp
| Column::EnvTemp
| Column::OutletTemp
| Column::Cooling
| Column::PsuFan
@@ -572,10 +662,16 @@ impl Column {
let none = f64::NEG_INFINITY;
match self {
Column::Hashrate => SortKey::Num(r.hashrate_ths),
// Relative hashrate = actual/expected; unknown expectation sorts to
// the bottom (round 11 #16).
Column::HashrateRel => {
SortKey::Num(actual_expected_ratio(r.hashrate_ths, r.expected_ths).unwrap_or(none))
}
Column::Power => SortKey::Num(r.power_w),
Column::Efficiency => SortKey::Num(if r.efficiency > 0.0 { r.efficiency } else { none }),
Column::ChipTemp => SortKey::Num(r.chip_temp_c),
Column::FluidTemp => SortKey::Num(r.fluid_temp_c),
Column::EnvTemp => SortKey::Num(r.env_temp_c),
Column::OutletTemp => SortKey::Num(r.outlet_temp_c),
Column::Cooling => SortKey::Num(if r.fan_rpms.is_empty() {
none
@@ -616,6 +712,11 @@ impl Column {
match self {
Column::Ip => r.ip.clone(),
Column::Hashrate => combined_si(r.hashrate_ths, r.expected_ths),
// Never displayed as its own column; rendered as a percentage only for
// completeness (e.g. a debug/self-test read of the cell).
Column::HashrateRel => actual_expected_ratio(r.hashrate_ths, r.expected_ths)
.map(|ratio| format!("{:.0}%", ratio * 100.0))
.unwrap_or_default(),
Column::Power => {
if r.power_w > 0.0 {
format_si(r.power_w, "W")
@@ -624,8 +725,17 @@ impl Column {
}
}
Column::Efficiency => num(r.efficiency, 1, ""),
Column::ChipTemp => num(r.chip_temp_c, 1, " C"),
// Per-hashboard chip temps as integers ("77 / 64 / 74"); fall back to
// the average (integer) when per-board readings aren't available.
Column::ChipTemp => {
if r.board_temps.is_empty() {
if r.chip_temp_c > 0.0 { format!("{:.0}", r.chip_temp_c) } else { String::new() }
} else {
r.board_temps.iter().map(|&t| format!("{t:.0}")).collect::<Vec<_>>().join(" / ")
}
}
Column::FluidTemp => num(r.fluid_temp_c, 1, " C"),
Column::EnvTemp => num(r.env_temp_c, 1, " C"),
Column::OutletTemp => num(r.outlet_temp_c, 1, " C"),
Column::Cooling => {
r.fan_rpms.iter().map(|&v| format_fan_rpm(v)).collect::<Vec<_>>().join("/")
@@ -636,14 +746,20 @@ impl Column {
Column::TotalChips => combined_count(r.total_chips, r.expected_chips),
Column::Hashboards => combined_count(r.hashboards, r.expected_hashboards),
Column::Firmware => r.firmware.clone(),
Column::Worker => r.worker.clone(),
Column::FwVersion => r.fw_version.clone(),
Column::Worker => split_worker(&r.worker).1.to_string(),
Column::PoolAccount => split_worker(&r.worker).0.to_string(),
Column::PoolUrl => r.pool_url.clone(),
Column::Model => r.model.clone(),
Column::Brand => r.brand.clone(),
Column::Submodel => r.submodel.clone(),
Column::Mac => r.mac.clone(),
Column::Hostname => r.hostname.clone(),
Column::Serial => r.serial.clone(),
Column::ApiVersion => r.api_version.clone(),
Column::ControlBoard => r.control_board.clone(),
Column::Cpu => r.cpu.clone(),
Column::BoardCode => r.board_code.clone(),
Column::Algorithm => r.algorithm.clone(),
Column::Pic => match r.pic_present {
Some(true) => "PIC".to_string(),
Some(false) => "noPIC".to_string(),
@@ -654,10 +770,11 @@ impl Column {
Some(false) => "unlocked".to_string(),
None => "?".to_string(),
},
// Just the count (blank when none); the full list is the hover
// tooltip (see fill_rows). No "errors" word, even for a single one.
Column::Error => match r.errors.len() {
0 => String::new(),
1 => r.errors[0].clone(),
n => format!("{n} errors"),
n => n.to_string(),
},
Column::Status => r.status().to_string(),
Column::Uptime => format_uptime(r.uptime_secs),
@@ -764,9 +881,17 @@ pub struct ViewState {
impl Default for ViewState {
fn default() -> Self {
// Registry order for `order`; Ip + DEFAULT_VISIBLE are shown. Default
// sort is by IP ascending.
let order: Vec<Column> = ALL_COLUMNS.to_vec();
// Display order = Ip, then DEFAULT_VISIBLE in its own order, then every
// remaining metric (so the initial columns match the UI-SPEC order rather
// than the ALL_COLUMNS registry order). Default sort is by IP ascending.
let mut order: Vec<Column> = Vec::with_capacity(ALL_COLUMNS.len());
order.push(Column::Ip);
order.extend(DEFAULT_VISIBLE);
for c in ALL_COLUMNS {
if !order.contains(&c) {
order.push(c);
}
}
let mut visible: HashSet<Column> = DEFAULT_VISIBLE.iter().copied().collect();
visible.insert(Column::Ip);
ViewState { order, visible, sort: Some((Column::Ip, true)), filters: HashMap::new() }
@@ -783,6 +908,16 @@ impl ViewState {
.collect()
}
/// Every column available to filter on, independent of visibility: a filter
/// matches a row by that column's cell text whether or not the column is
/// shown, so (e.g.) Algorithm can be filtered without first un-hiding it.
/// Ip first, then the registry order.
pub fn filter_columns(&self) -> Vec<Column> {
let mut v = vec![Column::Ip];
v.extend(self.order.iter().copied().filter(|c| *c != Column::Ip));
v
}
pub fn is_fixed(&self, c: Column) -> bool {
c == Column::Ip
}
@@ -852,6 +987,11 @@ pub struct Kpis {
pub paused: usize,
pub total_hashrate_ths: f64,
pub total_power_w: f64,
/// Per-algorithm hashrate totals (algorithm name, total TH/s), only for
/// algorithms actually producing hashrate, ordered by total descending then
/// name. The hashrate KPI card cycles through these when more than one
/// algorithm is running in the fleet.
pub hashrate_by_algo: Vec<(String, f64)>,
}
pub fn compute_kpis(rows: &[MinerRow], view_idx: &[usize]) -> Kpis {
@@ -863,7 +1003,11 @@ pub fn compute_kpis(rows: &[MinerRow], view_idx: &[usize]) -> Kpis {
paused: 0,
total_hashrate_ths: 0.0,
total_power_w: 0.0,
hashrate_by_algo: Vec::new(),
};
// Accumulate per-algorithm totals in an insertion-ordered list (fleets have
// a handful of algorithms at most, so a linear scan is cheaper than a map).
let mut by_algo: Vec<(String, f64)> = Vec::new();
for &i in view_idx {
let r = &rows[i];
// Bucket by the same precedence status() uses, so the KPI header can
@@ -876,7 +1020,19 @@ pub fn compute_kpis(rows: &[MinerRow], view_idx: &[usize]) -> Kpis {
}
k.total_hashrate_ths += r.hashrate_ths;
k.total_power_w += r.power_w;
if r.hashrate_ths > 0.0 {
// Fall back to "SHA256" when a miner didn't report its algorithm, so
// a producing miner is never dropped from the per-algorithm cycle.
let algo = if r.algorithm.is_empty() { "SHA256" } else { r.algorithm.as_str() };
match by_algo.iter_mut().find(|(a, _)| a == algo) {
Some((_, t)) => *t += r.hashrate_ths,
None => by_algo.push((algo.to_string(), r.hashrate_ths)),
}
}
}
// Stable order: largest total first, ties broken alphabetically.
by_algo.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal).then(a.0.cmp(&b.0)));
k.hashrate_by_algo = by_algo;
k
}
@@ -1040,9 +1196,12 @@ mod tests {
fn reorder_with_hidden_column_keeps_all_columns() {
let mut view = ViewState::default();
view.visible.remove(&Column::Power);
// display now: Ip(0), Hashrate(1), ChipTemp(2), ... - swap Hashrate/ChipTemp
// Swap Hashrate and ChipTemp in the visible display order (order-agnostic:
// find them by identity rather than by a fixed index).
let mut vis = view.display_columns();
vis.swap(1, 2);
let hr0 = vis.iter().position(|c| *c == Column::Hashrate).unwrap();
let ct0 = vis.iter().position(|c| *c == Column::ChipTemp).unwrap();
vis.swap(hr0, ct0);
view.apply_visible_reorder(&vis);
assert!(view.order.contains(&Column::Power), "hidden column dropped!");
assert_eq!(view.order.len(), ALL_COLUMNS.len());
@@ -1204,13 +1363,13 @@ mod tests {
assert_eq!(Column::Locked.cell(&unlocked), "unlocked");
assert_eq!(Column::Locked.cell(&MinerRow::default()), "?");
// Error column: blank / single message / count.
// Error column shows only the count (blank when none), even for one.
let none = MinerRow { errors: vec![], ..Default::default() };
let one = MinerRow { errors: vec!["[Error] boom".into()], ..Default::default() };
let one = MinerRow { errors: vec!["boom".into()], ..Default::default() };
let many = MinerRow { errors: vec!["a".into(), "b".into(), "c".into()], ..Default::default() };
assert_eq!(Column::Error.cell(&none), "");
assert_eq!(Column::Error.cell(&one), "[Error] boom");
assert_eq!(Column::Error.cell(&many), "3 errors");
assert_eq!(Column::Error.cell(&one), "1");
assert_eq!(Column::Error.cell(&many), "3");
}
#[test]
+413
View File
@@ -0,0 +1,413 @@
//! Display-layer device-naming cleanup (round-9 item #11).
//!
//! asic-rs hands us compact Rust-identifier model strings and bare control-board
//! names, not human-facing labels:
//! - `device_info.make` = "Antminer" / "Whatsminer" (note the casing)
//! - `device_info.model` = the model enum's variant identifier verbatim, e.g.
//! "S19KPro", "S19jPro", "M30SPlusVE40", "M30SPlusPlusVE40" -- no spaces,
//! "+" rendered "Plus", "++" rendered "PlusPlus", the WhatsMiner version
//! block ("VE40") baked in.
//! - `control_board_version` = a bare board name ("Xilinx", "CVITek",
//! "AMLogic", "BeagleBoneBlack"; WhatsMiner "H3"/"H6"/"H6OS"/"H616").
//!
//! This module turns those into the Brand / Model / Submodel / control-board
//! short code the table shows. It is a pure string transform -- no asic-rs edit
//! -- so it stays a build-on-top layer over the vendored crate.
//!
//! Known limitations (asic-rs does not expose the data):
//! - Antminer has no hashboard-type/submodel over the network, so Submodel is
//! blank for Antminer (only WhatsMiner's version block is recoverable).
//! - asic-rs reports only "AMLogic" (not the 120mm C76 vs 140mm CBE board) and
//! only "Xilinx" (not C49 vs C55); we disambiguate by model family as a
//! best-effort heuristic documented at `control_board_code`.
/// Human brand from asic-rs `device_info.make`.
pub fn brand(make: &str) -> String {
match make.trim().to_ascii_lowercase().as_str() {
"antminer" => "Antminer".to_string(),
"whatsminer" => "WhatsMiner".to_string(),
"" => String::new(),
other => {
// Title-case an unknown make so the Brand column still reads well.
let mut c = other.chars();
match c.next() {
Some(f) => f.to_ascii_uppercase().to_string() + c.as_str(),
None => String::new(),
}
}
}
}
fn is_whatsminer(make: &str) -> bool {
make.trim().eq_ignore_ascii_case("whatsminer")
}
fn is_antminer(make: &str) -> bool {
make.trim().eq_ignore_ascii_case("antminer")
}
/// Split asic-rs's firmware family string into the family shown in the Firmware
/// column and an optional vendor prefix that moves into the FW Version column
/// (round 11 #6). asic-rs reports stock firmware as "AntMiner Stock" /
/// "WhatsMiner Stock"; the Firmware column should read just "Stock" (so it
/// colours as the neutral/default family), and the vendor word belongs with the
/// version. Aftermarket families ("VNish", "Braiins", ...) carry no vendor
/// prefix and pass through unchanged.
pub fn firmware_family(raw: &str) -> (String, Option<String>) {
let trimmed = raw.trim();
// Vendor prefixes asic-rs prepends on stock-firmware family strings, matched
// case-insensitively.
for vendor in ["AntMiner", "WhatsMiner"] {
if trimmed.len() > vendor.len() && trimmed[..vendor.len()].eq_ignore_ascii_case(vendor) {
let rest = trimmed[vendor.len()..].trim();
if !rest.is_empty() {
return (rest.to_string(), Some(vendor.to_string()));
}
}
}
(trimmed.to_string(), None)
}
/// Whether a miner is liquid-cooled (hydro / water / immersion) rather than
/// air-cooled, inferred from the model name (round 11 #17). asic-rs exposes no
/// cooling-type field, so this is a best-effort model-string heuristic: it
/// decides whether a reported "fluid" temperature is a real coolant reading or
/// (for air-cooled units) the ambient/environment temperature.
pub fn is_liquid_cooled(model: &str) -> bool {
let m = model.to_ascii_lowercase();
m.contains("hydro") || m.contains("immers") || m.contains("water")
}
/// The human model name for the Model column: brand dropped (it has its own
/// column), family-letter suffix lowercased, word suffixes spaced, "+"/"++" for
/// Plus/PlusPlus, and (WhatsMiner) the trailing version block moved to Submodel.
pub fn clean_model(make: &str, model_id: &str) -> String {
let id = model_id.trim();
if id.is_empty() {
return String::new();
}
if is_whatsminer(make) {
clean_whatsminer(id).0
} else if is_antminer(make) {
clean_antminer(id)
} else {
id.to_string()
}
}
/// The Submodel column value. WhatsMiner: the version block ("VE40"). Antminer:
/// empty -- the hashboard type is not reported over the network by asic-rs.
pub fn submodel(make: &str, model_id: &str) -> String {
if is_whatsminer(make) {
clean_whatsminer(model_id.trim()).1
} else {
String::new()
}
}
/// Split a WhatsMiner identifier into (clean model, version submodel). The
/// version block is the trailing run beginning at the first 'V' (WhatsMiner
/// tiers never contain a 'V', so the first 'V' always starts the version). The
/// prefix's Plus/PlusPlus become +/++.
fn clean_whatsminer(id: &str) -> (String, String) {
let (prefix, version) = match id.find('V') {
Some(i) => (&id[..i], id[i..].to_string()),
None => (id, String::new()),
};
let model = prefix.replace("PlusPlus", "++").replace("Plus", "+");
(model, version)
}
/// Known Antminer word-suffixes, longest-first so "PlusPlus" wins over "Plus"
/// and "NoPIC" is matched whole. Each maps to its spaced display form.
const ANT_SUFFIXES: &[(&str, &str)] = &[
("PlusPlus", "++"),
("Plus", "+"),
("NoPIC", " NoPIC"),
("Hydro", " Hydro"),
("Pro", " Pro"),
("XP", " XP"),
];
/// Clean an Antminer identifier, e.g. "S19KPro" -> "S19k Pro", "S21eXPHydro" ->
/// "S21e XP Hydro", "L3PlusPlus" -> "L3++". Unknown/odd inputs pass through.
fn clean_antminer(id: &str) -> String {
// asic-rs "Unknown" models pass the raw vendor string through with the brand
// still in it (e.g. "ANTMINER S19 (88)", a NoPIC S19); drop a redundant
// leading brand word so the Model column never repeats the Brand column.
let id = if id.len() >= 9 && id[..9].eq_ignore_ascii_case("ANTMINER ") {
id[9..].trim_start()
} else {
id
};
let bytes = id.as_bytes();
// Base = leading letters then digits ("S19", "KS5", "L3", "Z15"). Without a
// letter+digit base (e.g. an Unknown passthrough), return the id unchanged.
let mut i = 0;
while i < bytes.len() && bytes[i].is_ascii_alphabetic() {
i += 1;
}
let letters_end = i;
while i < bytes.len() && bytes[i].is_ascii_digit() {
i += 1;
}
if letters_end == 0 || i == letters_end {
return id.to_string();
}
let mut out = String::from(&id[..i]);
let mut rest = &id[i..];
// An optional single family letter directly after the digits (j/i/a/e/K/L),
// recognised as "not the start of a known suffix". Lowercase it, keep it
// attached to the base (no space): "S19K" -> "S19k".
if let Some(first) = rest.chars().next() {
let starts_suffix = ANT_SUFFIXES.iter().any(|(s, _)| rest.starts_with(s));
if first.is_ascii_alphabetic() && !starts_suffix {
out.push(first.to_ascii_lowercase());
rest = &rest[first.len_utf8()..];
}
}
// Remaining suffix words, matched greedily against the known set.
while !rest.is_empty() {
match ANT_SUFFIXES.iter().find(|(s, _)| rest.starts_with(s)) {
Some((s, disp)) => {
out.push_str(disp);
rest = &rest[s.len()..];
}
None => {
// Unknown trailing token: emit it space-separated and stop.
out.push(' ');
out.push_str(rest.trim_start());
break;
}
}
}
out
}
/// Normalise a raw control-board name for matching: drop spaces/punctuation and
/// uppercase, so "BeagleBone Black", "BeagleBoneBlack" and "BBB" all collapse.
fn compact_upper(s: &str) -> String {
s.chars().filter(|c| c.is_ascii_alphanumeric()).flat_map(|c| c.to_uppercase()).collect()
}
/// The control-board short code for the Control-board column, e.g.
/// "BeagleBoneBlack" -> "BBB (C77)", "Xilinx" on an S17 -> "XIL (C49)".
///
/// asic-rs reports only the board FAMILY ("AMLogic"/"Xilinx"), never the exact
/// Bitmain board number, so where a family spans two boards we disambiguate by
/// model era/class (best-effort, since the network data can't distinguish them):
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
/// - AMLogic: XP-class / S19k (140mm fans) -> CBE, otherwise (120mm) -> C76.
/// `clean_model` is the already-cleaned model name (used for the era/class test).
pub fn control_board_code(make: &str, board_name: &str, clean_model: &str) -> String {
let (cpu, code) = control_board_split(make, board_name, clean_model);
if code.is_empty() {
cpu
} else {
format!("{cpu} ({code})")
}
}
/// The control-board CPU family short code alone ("AML", "CVI", "BBB", "XIL",
/// WhatsMiner "H3"/"H6"/"H6os"/"H616", or the raw name if unrecognised).
pub fn control_board_cpu(make: &str, board_name: &str, clean_model: &str) -> String {
control_board_split(make, board_name, clean_model).0
}
/// The Bitmain board code alone ("C77"/"C88"/"C49"/"C55"/"C76"/"CBE";
/// WhatsMiner "CB2"/"CB4"/"CB6"), or "" when unknown.
pub fn control_board_board(make: &str, board_name: &str, clean_model: &str) -> String {
control_board_split(make, board_name, clean_model).1
}
/// Split a raw control-board name into (CPU family short code, Bitmain board
/// code). asic-rs reports only the board FAMILY ("AMLogic"/"Xilinx"), never the
/// exact board number, so where a family spans two boards we disambiguate by
/// model era/class (best-effort):
/// - Xilinx: S17/T17-era -> C49, otherwise (S19-era) -> C55.
/// - AMLogic: XP-class / S19k / S21 (140mm fans) -> CBE, otherwise 120mm C76.
fn control_board_split(make: &str, board_name: &str, clean_model: &str) -> (String, String) {
let raw = board_name.trim();
if raw.is_empty() {
return (String::new(), String::new());
}
// asic-rs renders an unrecognised board as "Unknown: <raw>"; surface it in
// the CPU part with no code.
if raw.starts_with("Unknown") {
return (raw.to_string(), String::new());
}
let key = compact_upper(raw);
let pair = |cpu: &str, code: &str| (cpu.to_string(), code.to_string());
if is_whatsminer(make) {
return match key.as_str() {
"H3" => pair("H3", "CB2"),
"H6" => pair("H6", "CB4"),
"H6OS" => pair("H6os", "CB4"),
"H616" => pair("H616", "CB6"),
_ => (raw.to_string(), String::new()),
};
}
// Antminer (and any make that reports these families).
match key.as_str() {
"BEAGLEBONEBLACK" | "BBB" | "BB" | "BEAGLEBONE" => pair("BBB", "C77"),
"CVITEK" | "CVI" => pair("CVI", "C88"),
"XILINX" | "XIL" => {
if is_s17_era(clean_model) {
pair("XIL", "C49")
} else {
pair("XIL", "C55")
}
}
"AMLOGIC" | "AML" => {
if is_aml_140mm(clean_model) {
pair("AML", "CBE")
} else {
pair("AML", "C76")
}
}
_ => (raw.to_string(), String::new()),
}
}
/// S17/T17-era models use the Xilinx C49 control board.
fn is_s17_era(clean_model: &str) -> bool {
let m = clean_model.trim_start();
m.starts_with("S17") || m.starts_with("T17")
}
/// Best-effort: the 140mm-fan AMLogic board (CBE) is used on the XP-class, the
/// S19k Pro, and the S21 Pro; everything else AMLogic is the 120mm C76. asic-rs
/// cannot tell these apart, so this is a model-family heuristic, not a read.
fn is_aml_140mm(clean_model: &str) -> bool {
let m = clean_model.trim_start();
m.contains("XP") || m.starts_with("S19k") || m.starts_with("S21")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn brand_normalises_case() {
assert_eq!(brand("Antminer"), "Antminer");
assert_eq!(brand("Whatsminer"), "WhatsMiner");
assert_eq!(brand("whatsminer"), "WhatsMiner");
assert_eq!(brand(""), "");
assert_eq!(brand("avalonminer"), "Avalonminer");
}
#[test]
fn antminer_model_cleanup() {
// The headline example from the spec.
assert_eq!(clean_model("Antminer", "S19KPro"), "S19k Pro");
assert_eq!(clean_model("Antminer", "S19jPro"), "S19j Pro");
assert_eq!(clean_model("Antminer", "S21Pro"), "S21 Pro");
assert_eq!(clean_model("Antminer", "S19"), "S19");
assert_eq!(clean_model("Antminer", "S19XP"), "S19 XP");
assert_eq!(clean_model("Antminer", "S19jXP"), "S19j XP");
assert_eq!(clean_model("Antminer", "S19Plus"), "S19+");
assert_eq!(clean_model("Antminer", "S19ProPlus"), "S19 Pro+");
assert_eq!(clean_model("Antminer", "S19jProPlus"), "S19j Pro+");
assert_eq!(clean_model("Antminer", "S19ProPlusHydro"), "S19 Pro+ Hydro");
assert_eq!(clean_model("Antminer", "S19jNoPIC"), "S19j NoPIC");
assert_eq!(clean_model("Antminer", "S21PlusPlus"), "S21++");
assert_eq!(clean_model("Antminer", "S21eXPHydro"), "S21e XP Hydro");
assert_eq!(clean_model("Antminer", "L3PlusPlus"), "L3++");
assert_eq!(clean_model("Antminer", "KS5Pro"), "KS5 Pro");
assert_eq!(clean_model("Antminer", "Z15Pro"), "Z15 Pro");
assert_eq!(clean_model("Antminer", "S9i"), "S9i");
assert_eq!(clean_model("Antminer", "S17e"), "S17e");
assert_eq!(clean_model("Antminer", "S19a"), "S19a");
assert_eq!(clean_model("Antminer", "S19aPro"), "S19a Pro");
// asic-rs Unknown passthrough carrying the raw vendor string (a NoPIC
// S19 seen live at 10.4.x): drop the redundant brand, keep the rest.
assert_eq!(clean_model("Antminer", "ANTMINER S19 (88)"), "S19 (88)");
}
#[test]
fn whatsminer_model_and_submodel() {
assert_eq!(clean_model("Whatsminer", "M30SPlusVE40"), "M30S+");
assert_eq!(submodel("Whatsminer", "M30SPlusVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M30SPlusPlusVE40"), "M30S++");
assert_eq!(submodel("Whatsminer", "M30SPlusPlusVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M30SVE40"), "M30S");
assert_eq!(submodel("Whatsminer", "M30SVE40"), "VE40");
assert_eq!(clean_model("Whatsminer", "M20S"), "M20S");
assert_eq!(submodel("Whatsminer", "M20S"), "");
assert_eq!(clean_model("Whatsminer", "M50S++VK30"), "M50S++");
assert_eq!(submodel("Whatsminer", "M50S++VK30"), "VK30");
}
#[test]
fn antminer_has_no_submodel() {
assert_eq!(submodel("Antminer", "S19KPro"), "");
}
#[test]
fn control_board_short_codes() {
// Antminer families (board name as asic-rs renders the enum variant).
assert_eq!(control_board_code("Antminer", "BeagleBoneBlack", "S19"), "BBB (C77)");
// Also accept the spaced form some layers produce.
assert_eq!(control_board_code("Antminer", "BeagleBone Black", "S19"), "BBB (C77)");
assert_eq!(control_board_code("Antminer", "CVITek", "S21 Pro"), "CVI (C88)");
assert_eq!(control_board_code("Antminer", "Xilinx", "S17 Pro"), "XIL (C49)");
assert_eq!(control_board_code("Antminer", "Xilinx", "T17"), "XIL (C49)");
assert_eq!(control_board_code("Antminer", "Xilinx", "S19 Pro"), "XIL (C55)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19j Pro"), "AML (C76)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19k Pro"), "AML (CBE)");
assert_eq!(control_board_code("Antminer", "AMLogic", "S19 XP"), "AML (CBE)");
// WhatsMiner families.
assert_eq!(control_board_code("Whatsminer", "H3", "M30S"), "H3 (CB2)");
assert_eq!(control_board_code("Whatsminer", "H6", "M50"), "H6 (CB4)");
assert_eq!(control_board_code("Whatsminer", "H6OS", "M50"), "H6os (CB4)");
assert_eq!(control_board_code("Whatsminer", "H616", "M30S+"), "H616 (CB6)");
// Unknown / blank pass through.
assert_eq!(control_board_code("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
assert_eq!(control_board_code("Antminer", "", "S19"), "");
}
#[test]
fn control_board_cpu_and_board_split() {
// CPU column vs board-code column.
assert_eq!(control_board_cpu("Antminer", "AMLogic", "S19j Pro"), "AML");
assert_eq!(control_board_board("Antminer", "AMLogic", "S19j Pro"), "C76");
assert_eq!(control_board_cpu("Antminer", "CVITek", "S21 Pro"), "CVI");
assert_eq!(control_board_board("Antminer", "CVITek", "S21 Pro"), "C88");
assert_eq!(control_board_cpu("Whatsminer", "H616", "M30S+"), "H616");
assert_eq!(control_board_board("Whatsminer", "H616", "M30S+"), "CB6");
// S21 Pro on an AMLogic board is the 140mm CBE, not C76.
assert_eq!(control_board_board("Antminer", "AMLogic", "S21 Pro"), "CBE");
assert_eq!(control_board_code("Antminer", "AMLogic", "S21 Pro"), "AML (CBE)");
// Unknown -> cpu holds the raw string, no board code.
assert_eq!(control_board_cpu("Antminer", "Unknown: FOO", "S19"), "Unknown: FOO");
assert_eq!(control_board_board("Antminer", "Unknown: FOO", "S19"), "");
}
#[test]
fn firmware_family_splits_vendor_prefix() {
// Stock firmware: vendor word moves out of the family word (round 11 #6).
assert_eq!(firmware_family("AntMiner Stock"), ("Stock".to_string(), Some("AntMiner".to_string())));
assert_eq!(
firmware_family("WhatsMiner Stock"),
("Stock".to_string(), Some("WhatsMiner".to_string()))
);
// Aftermarket families pass through with no vendor prefix.
assert_eq!(firmware_family("VNish"), ("VNish".to_string(), None));
assert_eq!(firmware_family("Braiins"), ("Braiins".to_string(), None));
// A bare vendor word with nothing after it is left as-is (not emptied).
assert_eq!(firmware_family("AntMiner"), ("AntMiner".to_string(), None));
}
#[test]
fn liquid_cooling_detection() {
assert!(is_liquid_cooled("S21 XP Hydro"));
assert!(is_liquid_cooled("Antminer S19 Hydro"));
assert!(is_liquid_cooled("M53 immersion"));
assert!(!is_liquid_cooled("S21 Pro"));
assert!(!is_liquid_cooled("M30S++"));
}
}
+223
View File
@@ -0,0 +1,223 @@
//! Real PIC-vs-noPIC detection for Antminer control boards, over SSH + i2c-tools.
//!
//! asic-rs and the miner's network API cannot report PIC presence (see the
//! project wiki, 30-power-thermal-and-board-identity/hashboard-eeprom-pic.md);
//! the authoritative tell lives on the control board's I2C bus. On a
//! PIC/MCU-equipped board, I2C 0x48 is a hashboard MCU exposing an 8-byte
//! register file that WRAPS every 8 bytes (e.g. `17 00 4b 50 7f 00 00 00 ...`);
//! on a noPIC board, 0x48 is a plain LM75 temperature sensor with a 4-register
//! layout that wraps every 4 bytes. We read 0x48 with `i2cdump` over SSH and
//! discriminate by that period.
//!
//! This is a slow, credentialed, opt-in probe (an SSH handshake + shell command
//! per miner), never part of the fast network scan. We shell out to `ssh`
//! (via `sshpass` for password auth) rather than pull in an SSH crate, so the
//! offline/vendored build is unaffected.
use std::process::Command;
use std::time::Duration;
/// SSH login for the miner's control board (distinct from the web/API creds).
#[derive(Debug, Clone)]
pub struct SshCreds {
pub user: String,
/// Empty means key-based auth (BatchMode); otherwise `sshpass` is used.
pub pass: String,
}
/// Which I2C bus to probe, chosen from the control-board family. AMLogic uses
/// i2c-1, BeagleBone uses i2c-0; for anything else (Xilinx/CVITek/unknown) we
/// try both. The wiki confirms the AML/BB buses; Zynx/CVITek are unconfirmed.
pub fn bus_candidates(control_board: &str) -> Vec<u8> {
let cb = control_board.to_lowercase();
if cb.contains("amlogic") || cb.contains("aml") {
vec![1]
} else if cb.contains("beaglebone") || cb.contains("bb") {
vec![0]
} else {
vec![1, 0]
}
}
/// Classify an `i2cdump -y <bus> 0x48 b` dump: `Some(true)` = PIC (8-byte MCU
/// register file), `Some(false)` = noPIC (4-register LM75), `None` = couldn't
/// tell (address unresponsive, no periodicity, or unparseable). Conservative:
/// anything ambiguous is `None`, never a guess.
pub fn classify_i2cdump(stdout: &str) -> Option<bool> {
let bytes = parse_dump_offset0(stdout)?;
// An LM75's 4 registers repeat every 4 bytes; check that first because a
// period-4 sequence is trivially also period-8.
let period4 = (0..12).all(|i| bytes[i] == bytes[i + 4]);
if period4 {
return Some(false); // LM75 -> noPIC
}
let period8 = (0..8).all(|i| bytes[i] == bytes[i + 8]);
if period8 {
return Some(true); // 8-byte MCU register file -> PIC
}
None
}
/// Parse the 16 bytes of the `00:` row of an `i2cdump ... b` output. Returns
/// `None` if the row is missing or any cell is unreadable ("XX").
fn parse_dump_offset0(stdout: &str) -> Option<[u8; 16]> {
let line = stdout.lines().find_map(|l| {
let l = l.trim();
l.strip_prefix("00:").map(str::trim_start)
})?;
// The row is "<16 hex/XX cells> <ascii gutter>"; take the first 16 cells.
let mut out = [0u8; 16];
let mut n = 0;
for tok in line.split_whitespace() {
if n == 16 {
break;
}
if tok.len() != 2 {
break; // reached the ascii gutter
}
match u8::from_str_radix(tok, 16) {
Ok(b) => {
out[n] = b;
n += 1;
}
Err(_) => return None, // "XX" = no response -> indeterminate
}
}
(n == 16).then_some(out)
}
/// Build the ssh argv for one `i2cdump` on `bus`. Uses `sshpass -p <pass>` when
/// a password is set, else relies on key auth (BatchMode).
fn ssh_command(ip: &str, bus: u8, creds: &SshCreds) -> Command {
let remote = format!("i2cdump -y {bus} 0x48 b");
let target = format!("{}@{ip}", creds.user);
let ssh_opts = [
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "ConnectTimeout=6",
"-o", "NumberOfPasswordPrompts=1",
];
if creds.pass.is_empty() {
let mut c = Command::new("ssh");
c.arg("-o").arg("BatchMode=yes");
c.args(ssh_opts).arg(&target).arg(&remote);
c
} else {
// sshpass reads the password from the env var named after -e's default,
// but we use -p for simplicity; the password never reaches the argv of
// a child that logs it (sshpass scrubs its own argv).
let mut c = Command::new("sshpass");
c.arg("-p").arg(&creds.pass).arg("ssh");
c.args(ssh_opts).arg(&target).arg(&remote);
c
}
}
/// Probe one miner's PIC state over SSH. Returns `Ok(Some(true/false))` on a
/// confident PIC/noPIC read, `Ok(None)` if reachable but indeterminate, or
/// `Err` on an SSH/connection/auth failure.
pub fn probe_pic(ip: &str, control_board: &str, creds: &SshCreds) -> Result<Option<bool>, String> {
let mut last_err = String::from("no i2c bus responded");
for bus in bus_candidates(control_board) {
match run_probe(ip, bus, creds) {
Ok(Some(v)) => return Ok(Some(v)),
Ok(None) => last_err = format!("i2c-0x48 on bus {bus} was indeterminate"),
Err(e) => return Err(e), // an auth/connection error won't improve on another bus
}
}
// Reachable but couldn't classify on any candidate bus.
let _ = last_err;
Ok(None)
}
fn run_probe(ip: &str, bus: u8, creds: &SshCreds) -> Result<Option<bool>, String> {
let out = wait_with_timeout(ssh_command(ip, bus, creds), Duration::from_secs(12))?;
if !out.status.success() {
let err = String::from_utf8_lossy(&out.stderr);
// A failed i2cdump on this bus (e.g. bus doesn't exist) is not fatal --
// let the caller try the next bus. But an SSH/auth failure is fatal.
let e = err.trim().to_string();
if e.to_lowercase().contains("permission denied")
|| e.to_lowercase().contains("connection")
|| e.to_lowercase().contains("timed out")
|| e.to_lowercase().contains("no route")
|| e.to_lowercase().contains("host key")
{
return Err(if e.is_empty() { "ssh failed".into() } else { e });
}
return Ok(None);
}
Ok(classify_i2cdump(&String::from_utf8_lossy(&out.stdout)))
}
/// Run a command with a wall-clock timeout (SSH can hang on a dead host).
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
use std::io::Read;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
let mut child = cmd.spawn().map_err(|e| format!("spawn ssh: {e}"))?;
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
Some(status) => {
let mut stdout = Vec::new();
let mut stderr = Vec::new();
if let Some(mut o) = child.stdout.take() {
let _ = o.read_to_end(&mut stdout);
}
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
}
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
return Err("ssh timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_pic_from_wiki_dump() {
// The wiki's PIC/MCU board dump: 8-byte register file that wraps.
let dump = "\
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 17 00 4b 50 7f 00 00 00 17 00 4b 50 7f 00 00 00 ................
10: 17 00 4b 50 7f 00 00 00 17 00 4b 50 7f 00 00 00 ................";
assert_eq!(classify_i2cdump(dump), Some(true), "8-byte wrap -> PIC");
}
#[test]
fn classify_nopic_from_lm75() {
// An LM75 has 4 registers (temp/config/Thyst/Tos) that wrap every 4.
let dump = "\
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 19 00 4b 50 19 00 4b 50 19 00 4b 50 19 00 4b 50 ................";
assert_eq!(classify_i2cdump(dump), Some(false), "4-register LM75 -> noPIC");
}
#[test]
fn classify_indeterminate() {
// No response (XX) or no periodicity -> None (never a guess).
let xx = "00: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX";
assert_eq!(classify_i2cdump(xx), None);
let noisy = "00: 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10";
assert_eq!(classify_i2cdump(noisy), None);
assert_eq!(classify_i2cdump("no offset row here"), None);
}
#[test]
fn bus_from_control_board() {
assert_eq!(bus_candidates("AMLogic"), vec![1]);
assert_eq!(bus_candidates("BeagleBone Black"), vec![0]);
assert_eq!(bus_candidates("Xilinx"), vec![1, 0]);
assert_eq!(bus_candidates(""), vec![1, 0]);
}
}
+15 -8
View File
@@ -11,17 +11,20 @@ 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).
const DEFAULT_PROFILE: [Column; 9] = [
/// The built-in default profile's visible columns, in display order (Ip first):
/// IP, model, errors, hashrate, power, chip temp, firmware, CPU, boards
/// (hashboard health), access.
const DEFAULT_PROFILE: [Column; 10] = [
Column::Ip,
Column::Model,
Column::Error,
Column::Hashrate,
Column::Power,
Column::ChipTemp,
Column::Firmware,
Column::ControlBoard,
Column::Pic,
Column::Status,
Column::Cpu,
Column::Hashboards,
Column::Locked,
];
/// A serializable snapshot of a `ViewState` (Vec-based so JSON has no map keys
@@ -123,9 +126,13 @@ mod tests {
let view = p.view.to_view();
// IP first + the requested default columns visible.
assert!(view.visible.contains(&Column::Ip));
assert!(view.visible.contains(&Column::ControlBoard));
assert!(view.visible.contains(&Column::Pic));
assert!(view.visible.contains(&Column::Status));
assert!(view.visible.contains(&Column::Model));
assert!(view.visible.contains(&Column::Error));
assert!(view.visible.contains(&Column::Cpu));
assert!(view.visible.contains(&Column::Hashboards));
assert!(view.visible.contains(&Column::Locked));
// Columns dropped from the default profile in round 11.
assert!(!view.visible.contains(&Column::BoardCode), "not in the default profile");
assert!(!view.visible.contains(&Column::Cooling), "not in the default profile");
// to_view covers every column in `order`.
assert_eq!(view.order.len(), ALL_COLUMNS.len());
+268 -26
View File
@@ -397,31 +397,37 @@ pub fn start_scan(lines: Vec<String>) -> ScanHandle {
ScanHandle { rx, cancel }
}
/// Flatten a miner's structured messages into display lines, most severe first
/// ("[Error] text (component)"), for the Errors column + hover tooltip.
/// Flatten a miner's structured messages into concise display lines for the
/// Errors column's hover tooltip (the column cell itself shows only the count).
/// Only actionable messages (Error + Warning) are kept -- Info is dropped as
/// noise. Each line is just "message (component)" (no repetitive "[Error]"
/// prefix), duplicates are collapsed, and errors sort before warnings.
fn summarize_messages(messages: &[asic_rs::core::data::message::MinerMessage]) -> Vec<String> {
use asic_rs::core::data::message::MessageSeverity;
let rank = |s: &MessageSeverity| match s {
MessageSeverity::Error => 0u8,
MessageSeverity::Warning => 1,
MessageSeverity::Info => 2,
};
let mut ranked: Vec<(u8, String)> = messages
.iter()
.map(|m| {
let sev = match m.severity {
MessageSeverity::Error => "Error",
MessageSeverity::Warning => "Warning",
MessageSeverity::Info => "Info",
.filter_map(|m| {
let rank = match m.severity {
MessageSeverity::Error => 0u8,
MessageSeverity::Warning => 1,
MessageSeverity::Info => return None, // informational, not an error/warning
};
let line = match &m.component {
Some(c) => format!("[{sev}] {} ({c})", m.message),
None => format!("[{sev}] {}", m.message),
let text = m.message.trim();
if text.is_empty() {
return None;
}
let line = match m.component.as_ref().map(|c| c.to_string()) {
Some(c) if !c.trim().is_empty() => format!("{text} ({})", c.trim()),
_ => text.to_string(),
};
(rank(&m.severity), line)
Some((rank, line))
})
.collect();
// Stable sort keeps discovery order within a severity; errors before warnings.
ranked.sort_by_key(|(r, _)| *r);
// Collapse exact duplicates (asic-rs sometimes repeats the same fault per board).
let mut seen = HashSet::new();
ranked.retain(|(_, s)| seen.insert(s.clone()));
ranked.into_iter().map(|(_, s)| s).collect()
}
@@ -443,6 +449,19 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.as_ref()
.map(|t| t.as_celsius())
.unwrap_or(0.0);
// Per-hashboard chip temperature (hottest chip per board, falling back to
// the board/PCB temp), for the "77 / 64 / 74" Chip-temp cell.
let board_temps: Vec<f64> = data
.hashboards
.iter()
.filter_map(|b| {
b.outlet_chip_temperature
.as_ref()
.or(b.board_temperature.as_ref())
.map(|t| t.as_celsius())
})
.filter(|&t| t > 0.0)
.collect();
let fan_rpms: Vec<f64> = data
.fans
.iter()
@@ -477,17 +496,38 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
)
})
.collect();
let firmware = match (&data.device_info.firmware, &data.firmware_version) {
(fw, Some(v)) if !fw.is_empty() => format!("{fw} {v}"),
(fw, Some(v)) => format!("{fw}{v}"),
(fw, None) => fw.clone(),
// Firmware family (coloured column) and version go in separate columns. Strip
// the vendor word asic-rs prepends on stock firmware ("AntMiner Stock" ->
// "Stock") and carry it into the version instead (round 11 #6).
let (firmware, fw_vendor) = crate::naming::firmware_family(&data.device_info.firmware);
let raw_fw_version = data.firmware_version.clone().unwrap_or_default();
let fw_version = match (fw_vendor, raw_fw_version.is_empty()) {
(Some(vendor), false) => format!("{vendor} {raw_fw_version}"),
(Some(vendor), true) => vendor,
(None, _) => raw_fw_version,
};
let model = if data.device_info.make.is_empty() {
data.device_info.model.clone()
// Split asic-rs's compact make/model identifiers into the human-facing
// Brand / Model / Submodel the table shows (see crate::naming). asic-rs hands
// us "Antminer"/"S19KPro"; we render brand "Antminer", model "S19k Pro".
let make = data.device_info.make.clone();
let model_id = data.device_info.model.clone();
let brand = crate::naming::brand(&make);
let model = crate::naming::clean_model(&make, &model_id);
let submodel = crate::naming::submodel(&make, &model_id);
let raw_board = data.control_board_version.as_ref().map(|c| c.to_string()).unwrap_or_default();
let control_board = crate::naming::control_board_code(&make, &raw_board, &model);
let cpu = crate::naming::control_board_cpu(&make, &raw_board, &model);
let board_code = crate::naming::control_board_board(&make, &raw_board, &model);
// asic-rs has no cooling-type field and reports air-cooled miners' ambient
// reading in `fluid_temperature` (the WhatsMiner backends read the "Env
// Temp"/"environment-temperature" key). Route it to the Env-temp column for
// air-cooled models so it isn't mislabelled as a coolant temp (round 11 #17).
let reported_fluid = data.fluid_temperature.as_ref().map(|t| t.as_celsius()).unwrap_or(0.0);
let (fluid_temp_c, env_temp_c) = if crate::naming::is_liquid_cooled(&model) {
(reported_fluid, 0.0)
} else {
format!("{} {}", data.device_info.make, data.device_info.model)
(0.0, reported_fluid)
};
let fluid_temp_c = data.fluid_temperature.as_ref().map(|t| t.as_celsius()).unwrap_or(0.0);
let outlet_temp_c = data
.outlet_fluid_temperature
.as_ref()
@@ -498,17 +538,24 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
.iter()
.filter_map(|f| f.rpm.as_ref().map(|r| r.as_rpm()))
.fold(0.0f64, f64::max);
let algorithm = data.hashrate.as_ref().map(|h| h.algo.to_string()).unwrap_or_default();
let is_mining = data.is_mining;
let slow = crate::model::is_slow(is_mining, hashrate_ths, expected_ths);
let operating_state = data.operating_state.as_ref().map(|s| s.to_string()).unwrap_or_default();
let paused = crate::model::is_paused(&operating_state, is_mining);
// asic-rs advertises supports_set_power_limit=true unconditionally for whole
// firmware families, VNish included -- where, per operator guidance, the
// power-limit control should not be offered (round-9 #3). Mask it off for
// VNish; Braiins and the rest keep asic-rs's answer.
let power_limit = miner.supports_set_power_limit()
&& !data.device_info.firmware.eq_ignore_ascii_case("VNish");
// Probe what this miner supports being told to do (sync, no extra I/O).
let caps = MinerCaps {
fault_light: miner.supports_set_fault_light(),
restart: miner.supports_restart(),
pause: miner.supports_pause(),
resume: miner.supports_resume(),
power_limit: miner.supports_set_power_limit(),
power_limit,
tuning: miner.supports_set_tuning_percent(),
firmware_flash: miner.supports_upgrade_firmware(),
};
@@ -520,28 +567,61 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
// all, otherwise unlocked. Inferred from capabilities (asic-rs has no direct
// lock-state field).
let write_locked = Some(!caps.any_control());
// Per-hashboard health for the Boards status dots (round 11 #10): green =
// present & hashing, red = present but idle/faulty, grey = expected but not
// detected. Boards keep asic-rs's reported order (board 1 first); any boards
// expected beyond those reported are padded as Missing.
let mut board_status: Vec<crate::model::BoardHealth> = data
.hashboards
.iter()
.map(|b| {
let ok = match (b.active, b.working_chips) {
(Some(a), _) => a,
(None, Some(c)) => c > 0,
(None, None) => true,
};
if ok {
crate::model::BoardHealth::Ok
} else {
crate::model::BoardHealth::Fault
}
})
.collect();
if let Some(exp) = data.expected_hashboards {
while board_status.len() < exp as usize {
board_status.push(crate::model::BoardHealth::Missing);
}
}
let errors = summarize_messages(&data.messages);
MinerRow {
ip: data.ip.to_string(),
selected: false,
caps,
algorithm,
pic_present,
write_locked,
errors,
model,
brand,
submodel,
mac: data.mac.map(|m| m.to_string()).unwrap_or_default(),
hostname: data.hostname.clone().unwrap_or_default(),
serial: data.serial_number.clone().unwrap_or_default(),
firmware,
fw_version,
api_version: data.api_version.clone().unwrap_or_default(),
control_board: data.control_board_version.as_ref().map(|c| c.to_string()).unwrap_or_default(),
control_board,
cpu,
board_code,
hashrate_ths,
expected_ths,
efficiency: data.efficiency.unwrap_or(0.0),
power_w,
tuning_percent: data.tuning_percent,
chip_temp_c,
board_temps,
fluid_temp_c,
env_temp_c,
outlet_temp_c,
fan_rpms,
psu_fan_rpm,
@@ -551,6 +631,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
expected_chips: data.expected_chips.map(|v| v as u32),
hashboards: (!data.hashboards.is_empty()).then_some(data.hashboards.len() as u32),
expected_hashboards: data.expected_hashboards.map(|v| v as u32),
board_status,
worker,
pool_url,
pools,
@@ -905,6 +986,167 @@ pub fn start_firmware_flash_action(ips: Vec<String>, image: FirmwareImage) -> Ac
ActionHandle { rx, cancel }
}
/// Progress/results from a background SSH PIC probe of specific miners.
pub enum PicProbeMsg {
Started { total: usize },
/// One miner's PIC result: `pic` = Some(true/false)/None (indeterminate),
/// or `error` set on an SSH/connection failure.
Result { ip: String, pic: Option<bool>, error: Option<String> },
Done { total: usize },
}
/// A running PIC probe; `stop` cancels the remaining miners.
pub struct PicProbeHandle {
pub rx: Receiver<PicProbeMsg>,
cancel: Arc<AtomicBool>,
}
impl PicProbeHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
/// Probe the PIC state of `targets` (ip + control-board string) over SSH on a
/// background thread, one miner at a time (each is a slow SSH round trip). In
/// fake-scan mode it reports simulated results without touching the network.
pub fn start_pic_probe(
targets: Vec<(String, String)>,
creds: crate::pic_probe::SshCreds,
) -> PicProbeHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = targets.len();
let _ = tx.send(PicProbeMsg::Started { total });
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-pic-probe".into()).spawn(move || {
for (ip, cb) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
// Deterministic demo: Antminer S21 (CVITek) noPIC, other
// Antminers PIC, WhatsMiner indeterminate.
let pic = if cb.to_lowercase().contains("cvitek") {
Some(false)
} else if !cb.is_empty() {
Some(true)
} else {
None
};
let _ = tx.send(PicProbeMsg::Result { ip, pic, error: None });
}
let _ = tx.send(PicProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(PicProbeMsg::Done { total });
}
return PicProbeHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("pic-probe".into()).spawn(move || {
for (ip, cb) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let (pic, error) = match crate::pic_probe::probe_pic(&ip, &cb, &creds) {
Ok(v) => (v, None),
Err(e) => (None, Some(e)),
};
if tx.send(PicProbeMsg::Result { ip, pic, error }).is_err() {
return; // UI gone
}
}
let _ = tx.send(PicProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(PicProbeMsg::Done { total });
}
PicProbeHandle { rx, cancel }
}
/// Progress/results from a background access (lock-state) probe.
pub enum AccessProbeMsg {
Started { total: usize },
/// `locked` = Some(true) locked/view-only, Some(false) unlocked/writable,
/// None indeterminate; `error` set only when the probe couldn't run.
Result { ip: String, locked: Option<bool>, error: Option<String> },
Done { total: usize },
}
/// A running access probe; `stop` cancels the remaining miners.
pub struct AccessProbeHandle {
pub rx: Receiver<AccessProbeMsg>,
cancel: Arc<AtomicBool>,
}
impl AccessProbeHandle {
pub fn stop(&self) {
self.cancel.store(true, Ordering::Relaxed);
}
}
/// Probe the access/lock state of `targets` (ip + firmware string) over the web
/// API with `creds` (user, pass), on a background thread. A digest-auth GET is
/// fast, but we still run one miner at a time with cancel-between. Fake-scan mode
/// returns deterministic demo results.
pub fn start_access_probe(
targets: Vec<(String, String)>,
creds: (String, String),
) -> AccessProbeHandle {
let (tx, rx) = channel();
let cancel = Arc::new(AtomicBool::new(false));
let total = targets.len();
let _ = tx.send(AccessProbeMsg::Started { total });
let (user, pass) = creds;
if fake_scan_enabled() {
let err_tx = tx.clone();
let thread_cancel = cancel.clone();
let res = std::thread::Builder::new().name("fake-access-probe".into()).spawn(move || {
for (ip, _fw) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
// Demo: the WardenOS-dev unit (.115) is locked, others unlocked.
let locked = Some(ip.ends_with(".115"));
let _ = tx.send(AccessProbeMsg::Result { ip, locked, error: None });
}
let _ = tx.send(AccessProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(AccessProbeMsg::Done { total });
}
return AccessProbeHandle { rx, cancel };
}
let thread_cancel = cancel.clone();
let err_tx = tx.clone();
let res = std::thread::Builder::new().name("access-probe".into()).spawn(move || {
for (ip, fw) in targets {
if thread_cancel.load(Ordering::Relaxed) {
break;
}
let (locked, error) = match crate::access_probe::probe_access(&ip, &fw, &user, &pass) {
Ok(v) => (v, None),
Err(e) => (None, Some(e)),
};
if tx.send(AccessProbeMsg::Result { ip, locked, error }).is_err() {
return; // UI gone
}
}
let _ = tx.send(AccessProbeMsg::Done { total });
});
if res.is_err() {
let _ = err_tx.send(AccessProbeMsg::Done { total });
}
AccessProbeHandle { rx, cancel }
}
#[cfg(test)]
mod tests {
use super::*;
File diff suppressed because it is too large Load Diff
+9 -1
View File
@@ -20,7 +20,15 @@ vendor/ cargo-managed crate sources ONLY (regenerated by
`cargo vendor vendor`; it deletes unmanaged dirs - never
put hand-made trees here; learned the hard way)
thirdparty/
asic-rs lives in vendor/ (pure crates.io dep, cargo-vendored)
asic-rs the vendored crates live in vendor/ (crates.io dep,
VERSION cargo-vendored); this dir holds their patch queue:
patches/ 0001 whatsminer set_power_limit error propagation (#4)
refresh-checksums.py rewrites a vendored crate's .cargo-checksum.json
after a patch (cargo verifies each file's SHA256)
The committed vendor/ tree has the patches applied and the
affected .cargo-checksum.json refreshed, so builds need
nothing extra. On re-vendor, run
scripts/apply-asic-rs-patches.sh to re-apply + refresh.
wxwidgets/
wxWidgets-3.3.3/ pristine release tree, never edited directly
VERSION upstream version + tarball URL + sha256
+33
View File
@@ -0,0 +1,33 @@
#!/bin/bash
# Re-apply the asic-rs patch queue to the cargo-vendored tree and refresh the
# affected crates' .cargo-checksum.json. Run this after `cargo vendor vendor`
# (which regenerates a pristine vendor/ and drops our edits). A normal build
# does NOT need this -- the committed vendor/ tree already has the patches
# applied and checksums refreshed; this is the re-vendoring recipe (ADR 0003).
set -euo pipefail
REPO=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
cd "$REPO"
PATCHES_DIR="thirdparty/asic-rs/patches"
shopt -s nullglob
patches=("$PATCHES_DIR"/*.patch)
if [ ${#patches[@]} -eq 0 ]; then
echo "no patches in $PATCHES_DIR"
exit 0
fi
for p in "${patches[@]}"; do
echo "== applying $p =="
if git apply --check -p1 "$p" 2>/dev/null; then
git apply -p1 "$p"
elif git apply --check -p1 --reverse "$p" 2>/dev/null; then
echo " (already applied -- skipping)"
else
echo "ERROR: $p does not apply cleanly; resolve manually." >&2
exit 1
fi
done
echo "== refreshing checksums for all vendored asic-rs crates =="
python3 thirdparty/asic-rs/refresh-checksums.py --all
echo "done."
+37
View File
@@ -0,0 +1,37 @@
upstream: asic-rs (crates.io)
version: 0.8.1 (cargo-vendored under vendor/, per ADR 0003)
state: pristine cargo-vendored tree + this patch queue.
asic-rs is materialized with `cargo vendor vendor` and consumed through
.cargo/config.toml's vendored-sources replacement (directory = "vendor").
Unlike wx-rs, asic-rs is many crates (asic-rs, asic-rs-core, and the
per-make / per-firmware crates); a change to any of them lives here as a
numbered .patch, NOT as an in-place edit of the pristine tree (ADR 0003).
The committed vendor/ tree already has the patches applied AND its affected
crates' .cargo-checksum.json refreshed, so a normal build needs nothing extra
-- the patch queue is provenance + the re-vendoring recipe.
GOTCHA (cargo caching): cargo fingerprints a registry/vendored crate by
(name, version, source), NOT by file content, so it will REUSE a cached
build of a vendored crate even after its source is edited. CI is unaffected
(fresh target/ each run compiles the patched source). But an incremental
LOCAL build that already compiled the unpatched crate must be forced:
cargo clean -p asic-rs-firmwares-whatsminer # then rebuild
Otherwise the local binary silently keeps the old behaviour.
Update / re-vendor flow:
1. bump the pin in crates/alkane-gui/Cargo.toml, `cargo vendor vendor`
(this regenerates a pristine vendor/ and DROPS our edits)
2. scripts/apply-asic-rs-patches.sh # re-applies patches/ + refreshes checksums
3. resolve any patch that no longer applies, rebuild, commit
patches/:
0001 whatsminer set_power_limit (round-9 #4): fix the v3 (WhatsMinerOS)
privileged auth -- the "super" account's token password is the separate
v3 credential (default "super"), not the web/admin password -- and send
the watts as a bare integer; also treat the apply-restart's transient
RPC error as success. See the patch header.
0002 antminer Equihash (Z15/Z15J) hashrate (round-10 #8): the cgminer "GHS"
key carries a Sol/s value, so use the base Hash unit for Equihash so the
SI prefix is correct ("288k", not "288T"). See the patch header.
@@ -0,0 +1,104 @@
Subject: [PATCH 0001] whatsminer set_power_limit: v3 auth/param fix + restart-tolerant result
Round-9 #4 -- "the power-limit on the WhatsMiners doesn't apply properly" --
root-caused and verified against the live fleet.
v3 backend (WhatsMinerOS, firmware >= 2024-11-01, port 4433): the privileged
power-limit write authenticated the "super" account with the WEB/admin password
(a separate credential; the super account's factory default is "super") and sent
the watts as a float, so the miner rejected every write with "invalid json or
password is wrong". Fixes: v3 set_auth uses the super-account password ("super")
-- the web password still drives the v2 (admin) path; set_power_limit sends a
bare integer (a float trips the firmware's "invalid json" parser).
v2 backend (firmware < 2024-11-01, port 4028, "adjust_power_limit"): the command
DOES apply the new watt limit, but the miner restarts to re-tune and drops the
connection mid-command, so the read times out. Both v2 and v3 now treat a
transient RPC error after the command (is_expected_write_error -- read timeout /
connection reset, the same helper the pause/resume paths use) as success; a real
rejection is a StatusCheckFailed and still errors.
Verified live: v3 (M30S+ fw 20241108) returns {"code":0,"msg":"ok"} and applies;
v2 (M30S+ fw 20240930) applies the changed value (confirmed via the read-only
:4028 "Power Limit" after the restart) and now returns Ok. All test miners were
returned to their prior configured limit. Matches the pyasic / HashSource
whatsminer-api-3 references.
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
index c7b00e3b..096b2fcb 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v2/mod.rs
@@ -637,11 +637,21 @@ impl SetFaultLight for WhatsMinerV2 {
impl SetPowerLimit for WhatsMinerV2 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
- let data = self
+ match self
.rpc
.send_command("adjust_power_limit", true, parameters)
- .await;
- Ok(data.is_ok())
+ .await
+ {
+ Ok(_) => Ok(true),
+ // adjust_power_limit makes the miner restart to re-tune, so it drops
+ // the connection / stops replying mid-command even though it accepted
+ // and applied the new limit (verified on the live fleet: the set value
+ // settles after the restart). A transient RPC error (read timeout /
+ // connection reset) after the command is therefore success; a genuine
+ // rejection surfaces as StatusCheckFailed and still errors.
+ Err(e) if is_expected_write_error(&e) => Ok(true),
+ Err(e) => Err(e),
+ }
}
fn supports_set_power_limit(&self) -> bool {
true
diff --git a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
index 77d724d5..c00c6d44 100644
--- a/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
+++ b/vendor/asic-rs-firmwares-whatsminer/src/backends/v3/mod.rs
@@ -669,12 +669,21 @@ impl SetFaultLight for WhatsMinerV3 {
#[async_trait]
impl SetPowerLimit for WhatsMinerV3 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
- let data = self
+ // WhatsMinerOS wants a BARE INTEGER watt value; a float ("3000.0")
+ // trips the firmware's "invalid json" parser (round-9 #4).
+ let watts = limit.as_watts().round() as u64;
+ match self
.rpc
- .send_command("set.miner.power_limit", true, Some(json!(limit.as_watts())))
- .await;
-
- Ok(data.is_ok())
+ .send_command("set.miner.power_limit", true, Some(json!(watts)))
+ .await
+ {
+ Ok(_) => Ok(true),
+ // A power-limit change restarts the miner to re-tune, so a transient
+ // RPC error after the command means it was accepted (as with v2), not
+ // rejected; a genuine rejection is a StatusCheckFailed and still errors.
+ Err(e) if is_expected_write_error(&e) => Ok(true),
+ Err(e) => Err(e),
+ }
}
fn supports_set_power_limit(&self) -> bool {
true
@@ -806,8 +815,15 @@ impl HasDefaultAuth for WhatsMinerV3 {
impl HasAuth for WhatsMinerV3 {
fn set_auth(&mut self, auth: MinerAuth) {
- // WhatsMiner V3 username is always "super", V2 is always "admin"
- self.rpc.set_auth(MinerAuth::new("super", auth.password()));
+ // WhatsMiner V3 username is always "super", V2 is always "admin".
+ // The V3 privileged token authenticates against the "super" ACCOUNT,
+ // whose password is a separate v3 credential (factory default "super")
+ // -- NOT the web/admin password carried by `auth`. Pairing account
+ // "super" with the web password made every v3 privileged write fail with
+ // "invalid json or password is wrong" (round-9 #4, confirmed on the live
+ // fleet). Keep the super-account default password here; the web password
+ // still drives the v2 (admin) path below.
+ self.rpc.set_auth(MinerAuth::new("super", "super"));
self.v2_rpc
.set_auth(MinerAuth::new("admin", auth.password()));
}
@@ -0,0 +1,69 @@
Subject: [PATCH 0002] antminer: Equihash (Z15/Z15J) hashrate uses base Sol/s unit
Round-10 #8 -- a Z15 shows its hashrate in 'T' (e.g. "288T") when it should be
'k' (~288 kSol/s). Root cause verified on the live fleet: Equihash miners report
a Sol/s rate in the cgminer "GHS" key, but AntMiner's parse_hashrate takes the
unit from the key name ("GHS" -> GigaHash), scaling the value 1e9x too large.
The value is a raw Sol/s count, so for Equihash use the base Hash unit; the
downstream SI-prefixing then yields "288k". Matched by algorithm, and by "Z15"
model name for the Z15J which asic-rs leaves algo Unknown. Applies to both the
v2020 and v2023_07 backends. Verified: Z15 288T -> 288k, Z15J 138T -> 110k.
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
index cd4f7cbd..5b9f77b3 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
@@ -14,7 +14,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
- device::DeviceInfo,
+ device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -722,6 +722,15 @@ impl GetHashrate for AntMinerV2020 {
})
})?;
+ // Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
+ // "GHS" key, so the key's GigaHash label is wrong -- the value is the
+ // raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
+ // is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
+ // and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
+ || self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
+ let unit = if is_equihash { HashRateUnit::Hash } else { unit };
+
Some(
HashRate {
value,
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
index 4ba13537..6d6dc593 100644
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2023_07/mod.rs
@@ -16,7 +16,7 @@ use asic_rs_core::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
- device::DeviceInfo,
+ device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
@@ -698,6 +698,15 @@ impl GetHashrate for AntMinerV202307 {
})
})?;
+ // Equihash miners (e.g. Z15/Z15J) report a Sol/s rate in the cgminer
+ // "GHS" key, so the key's GigaHash label is wrong -- the value is the
+ // raw Sol/s count. Use the base unit so the magnitude (and SI prefix)
+ // is correct (e.g. ~288000 Sol/s -> "288k", not "288T"). Match by algo,
+ // and by Z15 model name for the Z15J which asic-rs leaves algo Unknown.
+ let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
+ || self.device_info.model.to_string().to_ascii_uppercase().contains("Z15");
+ let unit = if is_equihash { HashRateUnit::Hash } else { unit };
+
Some(
HashRate {
value,
+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()
+73 -1
View File
@@ -10,7 +10,7 @@
+pub use widgets::*;
--- a/src/widgets.rs
+++ b/src/widgets.rs
@@ -0,0 +1,728 @@
@@ -0,0 +1,800 @@
+// 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).
@@ -36,6 +36,8 @@
+ 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_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
@@ -90,6 +92,8 @@
+ 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_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);
@@ -112,10 +116,13 @@
+ 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_kpi_icon(parent: *mut c_void, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
+ 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);
+ }
+}
+
@@ -152,6 +159,8 @@
+ SysColour,
+ Deferred,
+ DvlcHeaderRightClick,
+ /// Window resized; p1 = new client width, p2 = new client height.
+ Sized,
+}
+
+impl WxEventKind {
@@ -171,6 +180,7 @@
+ 13 => WxEventKind::SysColour,
+ 14 => WxEventKind::Deferred,
+ 15 => WxEventKind::DvlcHeaderRightClick,
+ 16 => WxEventKind::Sized,
+ _ => return None,
+ })
+ }
@@ -188,6 +198,21 @@
+ 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) }
+}
+
+/// 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) }
+}
+
+/// 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();
@@ -304,6 +329,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) }
+ }
@@ -609,6 +646,27 @@
+ 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()
+ }
+
+ // ---- popup menu ----
+
+ pub fn menu_new() -> Widget {
@@ -723,6 +781,20 @@
+ })
+ }
+
+ /// A small drawn KPI icon (static bitmap). kind: 0 rabbit, 1 turtle,
+ /// 2 broken wine glass, 3 otter, 4 hive, 5 lightning bolt (round 11 #15).
+ pub fn kpi_icon(parent: Widget, kind: i32, color: (u8, u8, u8)) -> Widget {
+ Widget(unsafe {
+ notsafe::wxbr_kpi_icon(
+ parent.0,
+ kind,
+ color.0 as c_int,
+ color.1 as c_int,
+ color.2 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) }
+435 -11
View File
@@ -1,6 +1,6 @@
--- a/cpp_src/widgets_bridge.cpp
+++ b/cpp_src/widgets_bridge.cpp
@@ -0,0 +1,1059 @@
@@ -0,0 +1,1483 @@
+// widgets_bridge.cpp — alkane-toolkit extension to wx-rs
+// Adds the widget/event surface the toolkit UI needs on top of the upstream
+// render-callback bridge (which is kept untouched).
@@ -22,6 +22,7 @@
+#include <wx/utils.h>
+#include <wx/app.h>
+#include <wx/rearrangectrl.h>
+#include <wx/listctrl.h>
+#include <wx/menu.h>
+#include <wx/choice.h>
+#include <wx/bmpbuttn.h>
@@ -32,6 +33,7 @@
+#include <wx/graphics.h>
+#include <wx/wrapsizer.h>
+#include <wx/filedlg.h>
+#include <wx/statusbr.h>
+#include <cstring>
+#include <cstdio>
+#include <map>
@@ -68,6 +70,7 @@
+ WxEV_SYS_COLOUR = 13,
+ WxEV_DEFERRED = 14,
+ WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
+ WxEV_SIZE = 16, // p1 = new client width, p2 = new client height
+};
+
+// A list store that carries an optional per-row foreground colour plus an
@@ -148,6 +151,57 @@
+ return segs;
+}
+
+// Shape sentinels a segment's text may carry instead of glyphs (round 11
+// #10/#13): a single control char selects a small vector icon drawn in the
+// segment's colour. These are control characters (never emoji/pictographs) so
+// they are safe in source and independent of the font's glyph coverage.
+const wxUniChar SHAPE_DOT = 0x07; // filled status dot (hashboards, locate light)
+const wxUniChar SHAPE_LOCK = 0x02; // closed padlock (locked / view-only)
+const wxUniChar SHAPE_UNLOCK = 0x03; // open padlock (unlocked / writable)
+const int SHAPE_ADVANCE = 15; // horizontal space one shape occupies
+
+bool IsShapeSentinel(const wxString& s, wxUniChar& out) {
+ if (s.length() != 1) return false;
+ wxUniChar c = s[0];
+ if (c == SHAPE_DOT || c == SHAPE_LOCK || c == SHAPE_UNLOCK) {
+ out = c;
+ return true;
+ }
+ return false;
+}
+
+// Draw one shape sentinel, centred in the SHAPE_ADVANCE-wide slot at x.
+void DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell, const wxColour& colour) {
+ int cy = cell.y + cell.height / 2;
+ int cx = x + SHAPE_ADVANCE / 2;
+ if (shape == SHAPE_DOT) {
+ dc->SetPen(*wxTRANSPARENT_PEN);
+ dc->SetBrush(wxBrush(colour));
+ dc->DrawCircle(cx, cy, 4);
+ return;
+ }
+ // Padlock: a filled body with a staple shackle above. The colour carries the
+ // state (green = unlocked, red = locked); the shackle is drawn ajar when open.
+ bool open = (shape == SHAPE_UNLOCK);
+ int bw = 9, bh = 7;
+ int bx = cx - bw / 2;
+ int by = cy - bh / 2 + 1;
+ dc->SetPen(*wxTRANSPARENT_PEN);
+ dc->SetBrush(wxBrush(colour));
+ dc->DrawRoundedRectangle(bx, by, bw, bh, 1.5);
+ dc->SetBrush(*wxTRANSPARENT_BRUSH);
+ dc->SetPen(wxPen(colour, 2));
+ int sr = 3;
+ int legTop = by - sr - 1;
+ int lx = cx - sr, rx = cx + sr;
+ dc->DrawLine(lx, by, lx, legTop); // left leg
+ dc->DrawLine(lx, legTop, rx, legTop); // top bar
+ if (open)
+ dc->DrawLine(rx, legTop, rx, legTop + sr); // ajar: right leg lifted
+ else
+ dc->DrawLine(rx, legTop, rx, by); // closed: right leg to body
+}
+
+} // namespace
+
+class SegmentRenderer : public wxDataViewCustomRenderer {
@@ -167,12 +221,59 @@
+
+ bool Render(wxRect cell, wxDC* dc, int state) override {
+ bool selected = (state & wxDATAVIEW_CELL_SELECTED) != 0;
+ // wxGTK does NOT paint a custom renderer's cell background, so the per-row
+ // (zebra) background set via GetAttrByRow shows on the native columns but
+ // not here -- the zebra looked inconsistent across columns. Paint it here so
+ // every column stripes the same (skip when the row is selected: the control
+ // already drew the selection highlight).
+ if (!selected && GetAttr().HasBackgroundColour()) {
+ dc->SetBrush(wxBrush(GetAttr().GetBackgroundColour()));
+ dc->SetPen(*wxTRANSPARENT_PEN);
+ // The `cell` rect wx hands a custom renderer is shrunk to the content
+ // (text/shape) size by the alignment logic, so filling it alone left the
+ // zebra covering only the text and looking inconsistent with the full-cell
+ // native columns. Fill the whole column-wide cell instead; wxGTK clips the
+ // cell DC to the visible cell area, so the over-wide rect lands exactly on
+ // this cell without bleeding into the next column (round 11 #3).
+ wxRect bg = cell;
+ if (wxDataViewColumn* owner = const_cast<SegmentRenderer*>(this)->GetOwner()) {
+ int cw = owner->GetWidth();
+ if (cw > bg.width) bg.width = cw;
+ }
+ dc->DrawRectangle(bg);
+ }
+ wxColour highlight = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+ wxColour plain = GetAttr().HasColour()
+ ? GetAttr().GetColour()
+ : wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
+ // An uncoloured (default) segment -- the "/" in a combined cell, a "Stock"
+ // firmware family, etc. -- must dim exactly like the native columns when the
+ // top-level window is backdropped. wxGTK dims a native cell's text via the
+ // widget's themed state colour, but a custom renderer's DC keeps the normal
+ // WINDOWTEXT, so ask the tree widget for its themed text colour AT ITS
+ // CURRENT STATE (which carries GTK_STATE_FLAG_BACKDROP while unfocused) and
+ // use that; off-GTK (or if the widget isn't reachable) fall back to the DC
+ // then the system colour (round 11 #1/#7).
+ wxColour plain;
+ if (GetAttr().HasColour()) {
+ plain = GetAttr().GetColour();
+ } else {
+ plain = ThemedTextColour();
+ }
+ if (!plain.IsOk()) {
+ plain = dc->GetTextForeground();
+ }
+ if (!plain.IsOk()) {
+ plain = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
+ }
+ wxCoord x = cell.x;
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) {
+ // Shape segments (status dots, access padlock) keep their own semantic
+ // colour even on a selected row, so the green/red reading survives the
+ // selection highlight (round 11 #10/#13).
+ wxUniChar shape;
+ if (IsShapeSentinel(seg.text, shape)) {
+ DrawShape(dc, shape, x, cell, seg.has_colour ? seg.colour : plain);
+ x += SHAPE_ADVANCE;
+ continue;
+ }
+ if (seg.text.IsEmpty()) continue;
+ dc->SetTextForeground(selected ? highlight : (seg.has_colour ? seg.colour : plain));
+ wxSize extent = dc->GetTextExtent(seg.text);
@@ -184,14 +285,49 @@
+ }
+
+ wxSize GetSize() const override {
+ wxString plain;
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) plain += seg.text;
+ wxSize sz = GetTextExtent(plain);
+ if (sz.GetWidth() < 1) sz.SetWidth(1);
+ return sz;
+ int w = 0, h = 0;
+ for (const ColorSegment& seg : ParseColorSegments(m_value)) {
+ wxUniChar shape;
+ if (IsShapeSentinel(seg.text, shape)) {
+ w += SHAPE_ADVANCE;
+ if (h < 12) h = 12;
+ continue;
+ }
+ wxSize e = GetTextExtent(seg.text);
+ w += e.GetWidth();
+ if (e.GetHeight() > h) h = e.GetHeight();
+ }
+ if (w < 1) w = 1;
+ if (h < 1) h = 1;
+ return wxSize(w, h);
+ }
+
+ private:
+ // The owning tree widget's themed text colour at its current GTK state, so
+ // uncoloured segments dim on window-backdrop like the native columns
+ // (round 11 #1/#7). Returns an invalid colour off wxGTK or when the widget is
+ // unreachable, so the caller falls back to the DC / system colour.
+ wxColour ThemedTextColour() const {
+#ifdef __WXGTK__
+ wxDataViewColumn* col = const_cast<SegmentRenderer*>(this)->GetOwner();
+ if (col && col->GetOwner()) {
+ GtkWidget* tv = col->GetOwner()->GtkGetTreeView();
+ if (tv && GTK_IS_WIDGET(tv)) {
+ GtkStyleContext* ctx = gtk_widget_get_style_context(tv);
+ GtkStateFlags st = gtk_widget_get_state_flags(tv);
+ GdkRGBA c;
+ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+ gtk_style_context_get_color(ctx, st, &c);
+ G_GNUC_END_IGNORE_DEPRECATIONS
+ return wxColour((unsigned char)(c.red * 255.0 + 0.5),
+ (unsigned char)(c.green * 255.0 + 0.5),
+ (unsigned char)(c.blue * 255.0 + 0.5));
+ }
+ }
+#endif
+ return wxColour();
+ }
+
+ wxString m_value;
+};
+
@@ -273,6 +409,23 @@
+ ((wxSizer*)sizer)->Detach((wxWindow*)win);
+}
+
+// Show or hide a sizer-managed child window AND reclaim (or restore) its space
+// on the next Layout(). Used to collapse the wide KPI cards when the window is
+// too narrow (round 11 #2).
+void wxbr_sizer_show(void* sizer, void* win, int show) {
+ ((wxSizer*)sizer)->Show((wxWindow*)win, show != 0);
+}
+
+// Emit WxEV_SIZE (p1 = new client width, p2 = height) whenever this window is
+// resized. e.Skip() keeps the normal sizer layout running (round 11 #2).
+void wxbr_bind_size(void* win) {
+ ((wxWindow*)win)->Bind(wxEVT_SIZE, [](wxSizeEvent& e) {
+ if (g_widget_event) g_widget_event(WxEV_SIZE, (long)e.GetSize().GetWidth(),
+ (long)e.GetSize().GetHeight());
+ e.Skip();
+ });
+}
+
+void wxbr_fit(void* win) { ((wxWindow*)win)->Fit(); }
+
+void wxbr_set_min_size(void* win, int w, int h) {
@@ -701,9 +854,11 @@
+}
+
+// Scroll so `row` is visible (used with wxbr_dvlc_get_top_row to restore the
+// scroll position after a refill). Out-of-range rows are ignored.
+// scroll position after a refill). Out-of-range rows are ignored -- GetItem()
+// itself asserts on row >= count, so the bound MUST be checked before calling.
+void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
+ if (row >= (unsigned)dvlc_store(win)->GetItemCount()) return;
+ wxDataViewItem item = ((wxDataViewIndexListModel*)dv->GetModel())->GetItem(row);
+ if (item.IsOk()) dv->EnsureVisible(item);
+}
@@ -775,6 +930,25 @@
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
+ unsigned n = dv->GetColumnCount();
+ if (pos < 0 || (unsigned)pos >= n) return -1;
+#ifdef __WXGTK__
+ // wxGTK's GetColumnPosition() does NOT reflect a native GtkTreeView column
+ // drag, so after the user reorders columns it reports the creation order and
+ // the reorder is silently lost. Read the real display order from the
+ // GtkTreeView instead, then map the column back to its wx creation index.
+ GtkWidget* tvw = dv->GtkGetTreeView();
+ if (tvw) {
+ GList* cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(tvw)); // display order
+ GtkTreeViewColumn* gcol = (GtkTreeViewColumn*)g_list_nth_data(cols, (guint)pos);
+ g_list_free(cols);
+ if (gcol) {
+ wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
+ for (unsigned i = 0; i < n; i++) {
+ if (dv->GetColumn(i) == wxcol) return (int)i;
+ }
+ }
+ return -1;
+ }
+#endif
+ for (unsigned i = 0; i < n; i++) {
+ wxDataViewColumn* c = dv->GetColumn(i);
+ if (c && dv->GetColumnPosition(c) == (unsigned)pos) return (int)i;
@@ -806,9 +980,11 @@
+void wxbr_dvlc_select_rows(void* win, const int* rows, int n) {
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
+ wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
+ int count = (int)dvlc_store(win)->GetItemCount();
+ dv->UnselectAll();
+ for (int i = 0; i < n; i++) {
+ if (rows[i] >= 0) dv->Select(m->GetItem((unsigned)rows[i]));
+ // GetItem() asserts on an out-of-range row, so bound both ends.
+ if (rows[i] >= 0 && rows[i] < count) dv->Select(m->GetItem((unsigned)rows[i]));
+ }
+}
+
@@ -827,6 +1003,7 @@
+ if (row < 0) return;
+ wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
+ wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
+ if (row >= (long)dvlc_store(win)->GetItemCount()) return;
+ dv->Select(m->GetItem((unsigned)row));
+}
+
@@ -937,6 +1114,109 @@
+ return n < cap ? n : cap;
+}
+
+// ---- reorder list: a checkable, multi-select, drag-reorderable column list
+// for the Columns dialog (round 11 #4). Replaces wxRearrangeCtrl (which had
+// up/down buttons and no drag / multi-select). It is a single-column headerless
+// wxListCtrl with native checkboxes; rows carry their base model index as item
+// data, and the check state + row order encode the same [idx | ~idx] contract
+// as wxbr_rearrange_get_order. Selection (shift/ctrl-click, rubber-band drag) is
+// native to wxListCtrl. Drag-reorder: on begin-drag we record the selected rows'
+// base indices, and on the following mouse-up we move that group to the row
+// under the cursor (we never start a real DnD loop, so the mouse-up still
+// arrives).
+static wxVector<long> g_reorder_drag;
+static wxListCtrl* g_reorder_list = nullptr;
+
+void* wxbr_reorder_list(void* parent, int n, const int* order, const char** items) {
+ wxListCtrl* lc = new wxListCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
+ wxSize(-1, 240), wxLC_REPORT | wxLC_NO_HEADER);
+ lc->EnableCheckBoxes(true);
+ lc->InsertColumn(0, wxT("Column"), wxLIST_FORMAT_LEFT, 260);
+ for (int i = 0; i < n; i++) {
+ int enc = order[i];
+ int idx = enc < 0 ? ~enc : enc;
+ long row = lc->InsertItem(i, wxString::FromUTF8(items[idx]));
+ lc->SetItemData(row, (long)idx);
+ lc->CheckItem(row, enc >= 0);
+ }
+ lc->Bind(wxEVT_LIST_BEGIN_DRAG, [lc](wxListEvent&) {
+ g_reorder_drag.clear();
+ g_reorder_list = lc;
+ long it = -1;
+ for (;;) {
+ it = lc->GetNextItem(it, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+ if (it == -1) break;
+ g_reorder_drag.push_back(lc->GetItemData(it));
+ }
+ });
+ lc->Bind(wxEVT_LEFT_UP, [lc](wxMouseEvent& e) {
+ e.Skip();
+ if (g_reorder_list != lc || g_reorder_drag.empty()) return;
+ struct Row {
+ long data;
+ bool checked;
+ wxString text;
+ };
+ int count = lc->GetItemCount();
+ wxVector<Row> rows;
+ for (int i = 0; i < count; i++) {
+ Row r;
+ r.data = lc->GetItemData(i);
+ r.checked = lc->IsItemChecked(i);
+ r.text = lc->GetItemText(i);
+ rows.push_back(r);
+ }
+ auto isDragged = [](long d) {
+ for (size_t i = 0; i < g_reorder_drag.size(); i++)
+ if (g_reorder_drag[i] == d) return true;
+ return false;
+ };
+ int flags = 0;
+ long targetRow = lc->HitTest(e.GetPosition(), flags);
+ long anchor = (targetRow >= 0 && targetRow < count) ? rows[targetRow].data : -1;
+ if (anchor >= 0 && isDragged(anchor)) anchor = -1;
+ wxVector<Row> remaining, moved;
+ for (size_t i = 0; i < rows.size(); i++) {
+ if (isDragged(rows[i].data))
+ moved.push_back(rows[i]);
+ else
+ remaining.push_back(rows[i]);
+ }
+ int insertAt = (int)remaining.size();
+ if (anchor >= 0) {
+ for (size_t i = 0; i < remaining.size(); i++)
+ if (remaining[i].data == anchor) {
+ insertAt = (int)i;
+ break;
+ }
+ }
+ wxVector<Row> result;
+ for (int i = 0; i < insertAt; i++) result.push_back(remaining[i]);
+ for (size_t i = 0; i < moved.size(); i++) result.push_back(moved[i]);
+ for (int i = insertAt; i < (int)remaining.size(); i++) result.push_back(remaining[i]);
+ lc->DeleteAllItems();
+ for (size_t i = 0; i < result.size(); i++) {
+ long row = lc->InsertItem((long)i, result[i].text);
+ lc->SetItemData(row, result[i].data);
+ lc->CheckItem(row, result[i].checked);
+ }
+ g_reorder_drag.clear();
+ g_reorder_list = nullptr;
+ });
+ return (void*)lc;
+}
+
+int wxbr_reorder_get_order(void* win, int* buf, int cap) {
+ wxListCtrl* lc = (wxListCtrl*)win;
+ int count = lc->GetItemCount();
+ int n = 0;
+ for (int i = 0; i < count && n < cap; i++) {
+ int idx = (int)lc->GetItemData(i);
+ buf[n++] = lc->IsItemChecked(i) ? idx : ~idx;
+ }
+ return n;
+}
+
+// ---- popup menu (right-click context menu) ----------------------------------
+
+void* wxbr_menu_new() { return (void*)new wxMenu(); }
@@ -1029,6 +1309,101 @@
+ return (void*)btn;
+}
+
+// A small vector icon drawn into a transparent bitmap and wrapped in a
+// wxStaticBitmap, for the KPI cards (round 11 #15). kind: 0 rabbit (hashing),
+// 1 turtle (slow), 2 broken wine glass (not hashing), 3 otter (paused),
+// 4 hive (hashrate), 5 lightning bolt (power). Drawn as simple silhouettes so
+// they read at ~22px; the colour matches the card's value colour.
+void* wxbr_kpi_icon(void* parent, int kind, int r, int g, int b) {
+ const int sz = 22;
+ wxImage img(sz, sz);
+ img.InitAlpha();
+ unsigned char* a = img.GetAlpha();
+ if (a) memset(a, 0, (size_t)sz * sz);
+ wxBitmap bmp(img);
+ {
+ wxMemoryDC mdc(bmp);
+ wxGraphicsContext* gc = wxGraphicsContext::Create(mdc);
+ if (gc) {
+ gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
+ wxColour col(r, g, b);
+ wxColour dark((unsigned char)(r * 0.5), (unsigned char)(g * 0.5), (unsigned char)(b * 0.5));
+ gc->SetBrush(wxBrush(col));
+ gc->SetPen(wxPen(col, 1.0));
+ switch (kind) {
+ case 0: { // rabbit: low haunch body + head + two long spread ears
+ gc->DrawEllipse(4, 12, 14, 8); // haunch (low, wide)
+ gc->DrawEllipse(6.5, 7, 8, 8); // head
+ gc->DrawEllipse(6, 0, 2.6, 9); // left ear (long)
+ gc->DrawEllipse(12, 0, 2.6, 9); // right ear (long, spread)
+ break;
+ }
+ case 1: { // turtle: wide shell + head + two visible legs
+ gc->DrawEllipse(4, 6, 13, 9);
+ gc->DrawEllipse(15.5, 8, 4.5, 4.5); // head
+ gc->DrawEllipse(4.5, 12.5, 4, 4); // front leg
+ gc->DrawEllipse(11, 12.5, 4, 4); // back leg
+ break;
+ }
+ case 2: { // broken wine glass: bowl + stem + base, with a crack
+ wxGraphicsPath bowl = gc->CreatePath();
+ bowl.MoveToPoint(5, 3);
+ bowl.AddLineToPoint(17, 3);
+ bowl.AddLineToPoint(11, 12);
+ bowl.CloseSubpath();
+ gc->FillPath(bowl);
+ gc->DrawRectangle(10.2, 12, 1.6, 6);
+ gc->DrawRoundedRectangle(7, 18, 8, 2, 1);
+ wxGraphicsPath crack = gc->CreatePath(); // jagged crack across the bowl
+ crack.MoveToPoint(11, 3);
+ crack.AddLineToPoint(9, 6);
+ crack.AddLineToPoint(12.5, 8);
+ crack.AddLineToPoint(10.5, 11.5);
+ gc->SetPen(wxPen(dark, 1.4));
+ gc->StrokePath(crack);
+ break;
+ }
+ case 3: { // otter: upright tapered body + head + small ears + thick tail
+ wxGraphicsPath tail = gc->CreatePath(); // thick tapering tail curving right
+ tail.MoveToPoint(13, 17);
+ tail.AddCurveToPoint(19, 16, 21, 20, 19, 21);
+ tail.AddCurveToPoint(17, 21, 15, 20, 12, 19);
+ tail.CloseSubpath();
+ gc->FillPath(tail);
+ gc->DrawEllipse(6, 8, 10, 13); // body (tapered upright)
+ gc->DrawEllipse(7, 3, 8, 8); // head (wide)
+ gc->DrawEllipse(7, 2.5, 2.6, 2.6); // ear L
+ gc->DrawEllipse(12.4, 2.5, 2.6, 2.6);// ear R
+ break;
+ }
+ case 4: { // hive (skep): three stacked bands narrowing upward + entrance
+ gc->DrawRoundedRectangle(6, 2.5, 10, 4, 2);
+ gc->DrawRoundedRectangle(4, 7, 14, 4, 2);
+ gc->DrawRoundedRectangle(2.5, 11.5, 17, 5, 2.5);
+ gc->SetBrush(wxBrush(dark));
+ gc->SetPen(wxPen(dark, 1.0));
+ gc->DrawEllipse(9.3, 13, 3.4, 3.6);
+ break;
+ }
+ default: { // 5 lightning bolt
+ wxGraphicsPath p = gc->CreatePath();
+ p.MoveToPoint(13, 2);
+ p.AddLineToPoint(5, 12);
+ p.AddLineToPoint(10, 12);
+ p.AddLineToPoint(8, 20);
+ p.AddLineToPoint(17, 9);
+ p.AddLineToPoint(11, 9);
+ p.CloseSubpath();
+ gc->FillPath(p);
+ break;
+ }
+ }
+ delete gc;
+ }
+ }
+ return (void*)new wxStaticBitmap((wxWindow*)parent, wxID_ANY, bmp);
+}
+
+// ---- live theme changes -----------------------------------------------------
+
+// Emit WxEV_SYS_COLOUR when the OS light/dark theme changes so the app can
@@ -1051,6 +1426,55 @@
+ }
+}
+
+// ---- status-bar error/warning indicator -------------------------------------
+// A colour-tinted static text pinned to the RIGHT-hand field of the frame's
+// status bar, so scan/apply errors surface in the bottom-right corner without
+// overwriting the main (left) scan-status text. The status bar is reconfigured
+// to two fields: field 0 (stretch) carries the scan status set via the upstream
+// SetStatusText path; field 1 (fixed) hosts this coloured label, which we
+// reposition into that field's rect whenever the bar is resized.
+static wxStaticText* g_status_indicator = nullptr;
+
+static void reposition_status_indicator() {
+ if (!g_status_indicator) return;
+ wxStatusBar* sb = wxDynamicCast(g_status_indicator->GetParent(), wxStatusBar);
+ if (!sb) return;
+ wxRect r;
+ if (!sb->GetFieldRect(1, r)) return;
+ wxSize best = g_status_indicator->GetBestSize();
+ int h = best.GetHeight();
+ int y = r.y + (r.height - h) / 2;
+ g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
+}
+
+void wxbr_status_indicator_init(void* frame_ptr) {
+ wxFrame* frame = (wxFrame*)frame_ptr;
+ wxStatusBar* sb = frame->GetStatusBar();
+ if (!sb) sb = frame->CreateStatusBar();
+ int widths[2] = { -1, 340 };
+ sb->SetFieldsCount(2);
+ sb->SetStatusWidths(2, widths);
+ if (!g_status_indicator) {
+ g_status_indicator = new wxStaticText(sb, wxID_ANY, wxEmptyString,
+ wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
+ sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
+ reposition_status_indicator();
+ ev.Skip();
+ });
+ }
+ reposition_status_indicator();
+}
+
+// Set the bottom-right indicator text and its colour. An empty string clears it.
+void wxbr_status_indicator_set(const char* text, int r, int g, int b) {
+ if (!g_status_indicator) return;
+ g_status_indicator->SetLabel(wxString::FromUTF8(text ? text : ""));
+ g_status_indicator->SetForegroundColour(
+ wxColour((unsigned char)r, (unsigned char)g, (unsigned char)b));
+ reposition_status_indicator();
+ g_status_indicator->Refresh();
+}
+
+// ---- deferred destroy (safe from event handlers) ----------------------------
+
+void wxbr_destroy(void* win) { ((wxWindow*)win)->Destroy(); }
@@ -19,6 +19,7 @@
#include <wx/utils.h>
#include <wx/app.h>
#include <wx/rearrangectrl.h>
#include <wx/listctrl.h>
#include <wx/menu.h>
#include <wx/choice.h>
#include <wx/bmpbuttn.h>
@@ -29,6 +30,7 @@
#include <wx/graphics.h>
#include <wx/wrapsizer.h>
#include <wx/filedlg.h>
#include <wx/statusbr.h>
#include <cstring>
#include <cstdio>
#include <map>
@@ -65,6 +67,7 @@ enum WxWidgetEventKind {
WxEV_SYS_COLOUR = 13,
WxEV_DEFERRED = 14,
WxEV_DVLC_HEADER_RIGHT_CLICK = 15,
WxEV_SIZE = 16, // p1 = new client width, p2 = new client height
};
// A list store that carries an optional per-row foreground colour plus an
@@ -145,6 +148,57 @@ std::vector<ColorSegment> ParseColorSegments(const wxString& value) {
return segs;
}
// Shape sentinels a segment's text may carry instead of glyphs (round 11
// #10/#13): a single control char selects a small vector icon drawn in the
// segment's colour. These are control characters (never emoji/pictographs) so
// they are safe in source and independent of the font's glyph coverage.
const wxUniChar SHAPE_DOT = 0x07; // filled status dot (hashboards, locate light)
const wxUniChar SHAPE_LOCK = 0x02; // closed padlock (locked / view-only)
const wxUniChar SHAPE_UNLOCK = 0x03; // open padlock (unlocked / writable)
const int SHAPE_ADVANCE = 15; // horizontal space one shape occupies
bool IsShapeSentinel(const wxString& s, wxUniChar& out) {
if (s.length() != 1) return false;
wxUniChar c = s[0];
if (c == SHAPE_DOT || c == SHAPE_LOCK || c == SHAPE_UNLOCK) {
out = c;
return true;
}
return false;
}
// Draw one shape sentinel, centred in the SHAPE_ADVANCE-wide slot at x.
void DrawShape(wxDC* dc, wxUniChar shape, wxCoord x, const wxRect& cell, const wxColour& colour) {
int cy = cell.y + cell.height / 2;
int cx = x + SHAPE_ADVANCE / 2;
if (shape == SHAPE_DOT) {
dc->SetPen(*wxTRANSPARENT_PEN);
dc->SetBrush(wxBrush(colour));
dc->DrawCircle(cx, cy, 4);
return;
}
// Padlock: a filled body with a staple shackle above. The colour carries the
// state (green = unlocked, red = locked); the shackle is drawn ajar when open.
bool open = (shape == SHAPE_UNLOCK);
int bw = 9, bh = 7;
int bx = cx - bw / 2;
int by = cy - bh / 2 + 1;
dc->SetPen(*wxTRANSPARENT_PEN);
dc->SetBrush(wxBrush(colour));
dc->DrawRoundedRectangle(bx, by, bw, bh, 1.5);
dc->SetBrush(*wxTRANSPARENT_BRUSH);
dc->SetPen(wxPen(colour, 2));
int sr = 3;
int legTop = by - sr - 1;
int lx = cx - sr, rx = cx + sr;
dc->DrawLine(lx, by, lx, legTop); // left leg
dc->DrawLine(lx, legTop, rx, legTop); // top bar
if (open)
dc->DrawLine(rx, legTop, rx, legTop + sr); // ajar: right leg lifted
else
dc->DrawLine(rx, legTop, rx, by); // closed: right leg to body
}
} // namespace
class SegmentRenderer : public wxDataViewCustomRenderer {
@@ -164,12 +218,59 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
bool Render(wxRect cell, wxDC* dc, int state) override {
bool selected = (state & wxDATAVIEW_CELL_SELECTED) != 0;
// wxGTK does NOT paint a custom renderer's cell background, so the per-row
// (zebra) background set via GetAttrByRow shows on the native columns but
// not here -- the zebra looked inconsistent across columns. Paint it here so
// every column stripes the same (skip when the row is selected: the control
// already drew the selection highlight).
if (!selected && GetAttr().HasBackgroundColour()) {
dc->SetBrush(wxBrush(GetAttr().GetBackgroundColour()));
dc->SetPen(*wxTRANSPARENT_PEN);
// The `cell` rect wx hands a custom renderer is shrunk to the content
// (text/shape) size by the alignment logic, so filling it alone left the
// zebra covering only the text and looking inconsistent with the full-cell
// native columns. Fill the whole column-wide cell instead; wxGTK clips the
// cell DC to the visible cell area, so the over-wide rect lands exactly on
// this cell without bleeding into the next column (round 11 #3).
wxRect bg = cell;
if (wxDataViewColumn* owner = const_cast<SegmentRenderer*>(this)->GetOwner()) {
int cw = owner->GetWidth();
if (cw > bg.width) bg.width = cw;
}
dc->DrawRectangle(bg);
}
wxColour highlight = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
wxColour plain = GetAttr().HasColour()
? GetAttr().GetColour()
: wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
// An uncoloured (default) segment -- the "/" in a combined cell, a "Stock"
// firmware family, etc. -- must dim exactly like the native columns when the
// top-level window is backdropped. wxGTK dims a native cell's text via the
// widget's themed state colour, but a custom renderer's DC keeps the normal
// WINDOWTEXT, so ask the tree widget for its themed text colour AT ITS
// CURRENT STATE (which carries GTK_STATE_FLAG_BACKDROP while unfocused) and
// use that; off-GTK (or if the widget isn't reachable) fall back to the DC
// then the system colour (round 11 #1/#7).
wxColour plain;
if (GetAttr().HasColour()) {
plain = GetAttr().GetColour();
} else {
plain = ThemedTextColour();
}
if (!plain.IsOk()) {
plain = dc->GetTextForeground();
}
if (!plain.IsOk()) {
plain = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
}
wxCoord x = cell.x;
for (const ColorSegment& seg : ParseColorSegments(m_value)) {
// Shape segments (status dots, access padlock) keep their own semantic
// colour even on a selected row, so the green/red reading survives the
// selection highlight (round 11 #10/#13).
wxUniChar shape;
if (IsShapeSentinel(seg.text, shape)) {
DrawShape(dc, shape, x, cell, seg.has_colour ? seg.colour : plain);
x += SHAPE_ADVANCE;
continue;
}
if (seg.text.IsEmpty()) continue;
dc->SetTextForeground(selected ? highlight : (seg.has_colour ? seg.colour : plain));
wxSize extent = dc->GetTextExtent(seg.text);
@@ -181,14 +282,49 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
}
wxSize GetSize() const override {
wxString plain;
for (const ColorSegment& seg : ParseColorSegments(m_value)) plain += seg.text;
wxSize sz = GetTextExtent(plain);
if (sz.GetWidth() < 1) sz.SetWidth(1);
return sz;
int w = 0, h = 0;
for (const ColorSegment& seg : ParseColorSegments(m_value)) {
wxUniChar shape;
if (IsShapeSentinel(seg.text, shape)) {
w += SHAPE_ADVANCE;
if (h < 12) h = 12;
continue;
}
wxSize e = GetTextExtent(seg.text);
w += e.GetWidth();
if (e.GetHeight() > h) h = e.GetHeight();
}
if (w < 1) w = 1;
if (h < 1) h = 1;
return wxSize(w, h);
}
private:
// The owning tree widget's themed text colour at its current GTK state, so
// uncoloured segments dim on window-backdrop like the native columns
// (round 11 #1/#7). Returns an invalid colour off wxGTK or when the widget is
// unreachable, so the caller falls back to the DC / system colour.
wxColour ThemedTextColour() const {
#ifdef __WXGTK__
wxDataViewColumn* col = const_cast<SegmentRenderer*>(this)->GetOwner();
if (col && col->GetOwner()) {
GtkWidget* tv = col->GetOwner()->GtkGetTreeView();
if (tv && GTK_IS_WIDGET(tv)) {
GtkStyleContext* ctx = gtk_widget_get_style_context(tv);
GtkStateFlags st = gtk_widget_get_state_flags(tv);
GdkRGBA c;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_style_context_get_color(ctx, st, &c);
G_GNUC_END_IGNORE_DEPRECATIONS
return wxColour((unsigned char)(c.red * 255.0 + 0.5),
(unsigned char)(c.green * 255.0 + 0.5),
(unsigned char)(c.blue * 255.0 + 0.5));
}
}
#endif
return wxColour();
}
wxString m_value;
};
@@ -270,6 +406,23 @@ void wxbr_sizer_detach(void* sizer, void* win) {
((wxSizer*)sizer)->Detach((wxWindow*)win);
}
// Show or hide a sizer-managed child window AND reclaim (or restore) its space
// on the next Layout(). Used to collapse the wide KPI cards when the window is
// too narrow (round 11 #2).
void wxbr_sizer_show(void* sizer, void* win, int show) {
((wxSizer*)sizer)->Show((wxWindow*)win, show != 0);
}
// Emit WxEV_SIZE (p1 = new client width, p2 = height) whenever this window is
// resized. e.Skip() keeps the normal sizer layout running (round 11 #2).
void wxbr_bind_size(void* win) {
((wxWindow*)win)->Bind(wxEVT_SIZE, [](wxSizeEvent& e) {
if (g_widget_event) g_widget_event(WxEV_SIZE, (long)e.GetSize().GetWidth(),
(long)e.GetSize().GetHeight());
e.Skip();
});
}
void wxbr_fit(void* win) { ((wxWindow*)win)->Fit(); }
void wxbr_set_min_size(void* win, int w, int h) {
@@ -698,9 +851,11 @@ int wxbr_dvlc_get_top_row(void* win) {
}
// Scroll so `row` is visible (used with wxbr_dvlc_get_top_row to restore the
// scroll position after a refill). Out-of-range rows are ignored.
// scroll position after a refill). Out-of-range rows are ignored -- GetItem()
// itself asserts on row >= count, so the bound MUST be checked before calling.
void wxbr_dvlc_ensure_visible(void* win, unsigned row) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
if (row >= (unsigned)dvlc_store(win)->GetItemCount()) return;
wxDataViewItem item = ((wxDataViewIndexListModel*)dv->GetModel())->GetItem(row);
if (item.IsOk()) dv->EnsureVisible(item);
}
@@ -772,6 +927,25 @@ int wxbr_dvlc_col_at_pos(void* win, int pos) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
unsigned n = dv->GetColumnCount();
if (pos < 0 || (unsigned)pos >= n) return -1;
#ifdef __WXGTK__
// wxGTK's GetColumnPosition() does NOT reflect a native GtkTreeView column
// drag, so after the user reorders columns it reports the creation order and
// the reorder is silently lost. Read the real display order from the
// GtkTreeView instead, then map the column back to its wx creation index.
GtkWidget* tvw = dv->GtkGetTreeView();
if (tvw) {
GList* cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(tvw)); // display order
GtkTreeViewColumn* gcol = (GtkTreeViewColumn*)g_list_nth_data(cols, (guint)pos);
g_list_free(cols);
if (gcol) {
wxDataViewColumn* wxcol = dv->GTKColumnToWX(gcol);
for (unsigned i = 0; i < n; i++) {
if (dv->GetColumn(i) == wxcol) return (int)i;
}
}
return -1;
}
#endif
for (unsigned i = 0; i < n; i++) {
wxDataViewColumn* c = dv->GetColumn(i);
if (c && dv->GetColumnPosition(c) == (unsigned)pos) return (int)i;
@@ -803,9 +977,11 @@ int wxbr_dvlc_get_selections(void* win, int* buf, int cap) {
void wxbr_dvlc_select_rows(void* win, const int* rows, int n) {
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
int count = (int)dvlc_store(win)->GetItemCount();
dv->UnselectAll();
for (int i = 0; i < n; i++) {
if (rows[i] >= 0) dv->Select(m->GetItem((unsigned)rows[i]));
// GetItem() asserts on an out-of-range row, so bound both ends.
if (rows[i] >= 0 && rows[i] < count) dv->Select(m->GetItem((unsigned)rows[i]));
}
}
@@ -824,6 +1000,7 @@ void wxbr_dvlc_select_row(void* win, long row) {
if (row < 0) return;
wxDataViewCtrl* dv = (wxDataViewCtrl*)win;
wxDataViewIndexListModel* m = (wxDataViewIndexListModel*)dv->GetModel();
if (row >= (long)dvlc_store(win)->GetItemCount()) return;
dv->Select(m->GetItem((unsigned)row));
}
@@ -934,6 +1111,109 @@ int wxbr_rearrange_get_order(void* win, int* buf, int cap) {
return n < cap ? n : cap;
}
// ---- reorder list: a checkable, multi-select, drag-reorderable column list
// for the Columns dialog (round 11 #4). Replaces wxRearrangeCtrl (which had
// up/down buttons and no drag / multi-select). It is a single-column headerless
// wxListCtrl with native checkboxes; rows carry their base model index as item
// data, and the check state + row order encode the same [idx | ~idx] contract
// as wxbr_rearrange_get_order. Selection (shift/ctrl-click, rubber-band drag) is
// native to wxListCtrl. Drag-reorder: on begin-drag we record the selected rows'
// base indices, and on the following mouse-up we move that group to the row
// under the cursor (we never start a real DnD loop, so the mouse-up still
// arrives).
static wxVector<long> g_reorder_drag;
static wxListCtrl* g_reorder_list = nullptr;
void* wxbr_reorder_list(void* parent, int n, const int* order, const char** items) {
wxListCtrl* lc = new wxListCtrl((wxWindow*)parent, wxID_ANY, wxDefaultPosition,
wxSize(-1, 240), wxLC_REPORT | wxLC_NO_HEADER);
lc->EnableCheckBoxes(true);
lc->InsertColumn(0, wxT("Column"), wxLIST_FORMAT_LEFT, 260);
for (int i = 0; i < n; i++) {
int enc = order[i];
int idx = enc < 0 ? ~enc : enc;
long row = lc->InsertItem(i, wxString::FromUTF8(items[idx]));
lc->SetItemData(row, (long)idx);
lc->CheckItem(row, enc >= 0);
}
lc->Bind(wxEVT_LIST_BEGIN_DRAG, [lc](wxListEvent&) {
g_reorder_drag.clear();
g_reorder_list = lc;
long it = -1;
for (;;) {
it = lc->GetNextItem(it, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (it == -1) break;
g_reorder_drag.push_back(lc->GetItemData(it));
}
});
lc->Bind(wxEVT_LEFT_UP, [lc](wxMouseEvent& e) {
e.Skip();
if (g_reorder_list != lc || g_reorder_drag.empty()) return;
struct Row {
long data;
bool checked;
wxString text;
};
int count = lc->GetItemCount();
wxVector<Row> rows;
for (int i = 0; i < count; i++) {
Row r;
r.data = lc->GetItemData(i);
r.checked = lc->IsItemChecked(i);
r.text = lc->GetItemText(i);
rows.push_back(r);
}
auto isDragged = [](long d) {
for (size_t i = 0; i < g_reorder_drag.size(); i++)
if (g_reorder_drag[i] == d) return true;
return false;
};
int flags = 0;
long targetRow = lc->HitTest(e.GetPosition(), flags);
long anchor = (targetRow >= 0 && targetRow < count) ? rows[targetRow].data : -1;
if (anchor >= 0 && isDragged(anchor)) anchor = -1;
wxVector<Row> remaining, moved;
for (size_t i = 0; i < rows.size(); i++) {
if (isDragged(rows[i].data))
moved.push_back(rows[i]);
else
remaining.push_back(rows[i]);
}
int insertAt = (int)remaining.size();
if (anchor >= 0) {
for (size_t i = 0; i < remaining.size(); i++)
if (remaining[i].data == anchor) {
insertAt = (int)i;
break;
}
}
wxVector<Row> result;
for (int i = 0; i < insertAt; i++) result.push_back(remaining[i]);
for (size_t i = 0; i < moved.size(); i++) result.push_back(moved[i]);
for (int i = insertAt; i < (int)remaining.size(); i++) result.push_back(remaining[i]);
lc->DeleteAllItems();
for (size_t i = 0; i < result.size(); i++) {
long row = lc->InsertItem((long)i, result[i].text);
lc->SetItemData(row, result[i].data);
lc->CheckItem(row, result[i].checked);
}
g_reorder_drag.clear();
g_reorder_list = nullptr;
});
return (void*)lc;
}
int wxbr_reorder_get_order(void* win, int* buf, int cap) {
wxListCtrl* lc = (wxListCtrl*)win;
int count = lc->GetItemCount();
int n = 0;
for (int i = 0; i < count && n < cap; i++) {
int idx = (int)lc->GetItemData(i);
buf[n++] = lc->IsItemChecked(i) ? idx : ~idx;
}
return n;
}
// ---- popup menu (right-click context menu) ----------------------------------
void* wxbr_menu_new() { return (void*)new wxMenu(); }
@@ -1026,6 +1306,101 @@ void* wxbr_media_button(void* parent, int id, int kind, int r, int g, int b) {
return (void*)btn;
}
// A small vector icon drawn into a transparent bitmap and wrapped in a
// wxStaticBitmap, for the KPI cards (round 11 #15). kind: 0 rabbit (hashing),
// 1 turtle (slow), 2 broken wine glass (not hashing), 3 otter (paused),
// 4 hive (hashrate), 5 lightning bolt (power). Drawn as simple silhouettes so
// they read at ~22px; the colour matches the card's value colour.
void* wxbr_kpi_icon(void* parent, int kind, int r, int g, int b) {
const int sz = 22;
wxImage img(sz, sz);
img.InitAlpha();
unsigned char* a = img.GetAlpha();
if (a) memset(a, 0, (size_t)sz * sz);
wxBitmap bmp(img);
{
wxMemoryDC mdc(bmp);
wxGraphicsContext* gc = wxGraphicsContext::Create(mdc);
if (gc) {
gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
wxColour col(r, g, b);
wxColour dark((unsigned char)(r * 0.5), (unsigned char)(g * 0.5), (unsigned char)(b * 0.5));
gc->SetBrush(wxBrush(col));
gc->SetPen(wxPen(col, 1.0));
switch (kind) {
case 0: { // rabbit: low haunch body + head + two long spread ears
gc->DrawEllipse(4, 12, 14, 8); // haunch (low, wide)
gc->DrawEllipse(6.5, 7, 8, 8); // head
gc->DrawEllipse(6, 0, 2.6, 9); // left ear (long)
gc->DrawEllipse(12, 0, 2.6, 9); // right ear (long, spread)
break;
}
case 1: { // turtle: wide shell + head + two visible legs
gc->DrawEllipse(4, 6, 13, 9);
gc->DrawEllipse(15.5, 8, 4.5, 4.5); // head
gc->DrawEllipse(4.5, 12.5, 4, 4); // front leg
gc->DrawEllipse(11, 12.5, 4, 4); // back leg
break;
}
case 2: { // broken wine glass: bowl + stem + base, with a crack
wxGraphicsPath bowl = gc->CreatePath();
bowl.MoveToPoint(5, 3);
bowl.AddLineToPoint(17, 3);
bowl.AddLineToPoint(11, 12);
bowl.CloseSubpath();
gc->FillPath(bowl);
gc->DrawRectangle(10.2, 12, 1.6, 6);
gc->DrawRoundedRectangle(7, 18, 8, 2, 1);
wxGraphicsPath crack = gc->CreatePath(); // jagged crack across the bowl
crack.MoveToPoint(11, 3);
crack.AddLineToPoint(9, 6);
crack.AddLineToPoint(12.5, 8);
crack.AddLineToPoint(10.5, 11.5);
gc->SetPen(wxPen(dark, 1.4));
gc->StrokePath(crack);
break;
}
case 3: { // otter: upright tapered body + head + small ears + thick tail
wxGraphicsPath tail = gc->CreatePath(); // thick tapering tail curving right
tail.MoveToPoint(13, 17);
tail.AddCurveToPoint(19, 16, 21, 20, 19, 21);
tail.AddCurveToPoint(17, 21, 15, 20, 12, 19);
tail.CloseSubpath();
gc->FillPath(tail);
gc->DrawEllipse(6, 8, 10, 13); // body (tapered upright)
gc->DrawEllipse(7, 3, 8, 8); // head (wide)
gc->DrawEllipse(7, 2.5, 2.6, 2.6); // ear L
gc->DrawEllipse(12.4, 2.5, 2.6, 2.6);// ear R
break;
}
case 4: { // hive (skep): three stacked bands narrowing upward + entrance
gc->DrawRoundedRectangle(6, 2.5, 10, 4, 2);
gc->DrawRoundedRectangle(4, 7, 14, 4, 2);
gc->DrawRoundedRectangle(2.5, 11.5, 17, 5, 2.5);
gc->SetBrush(wxBrush(dark));
gc->SetPen(wxPen(dark, 1.0));
gc->DrawEllipse(9.3, 13, 3.4, 3.6);
break;
}
default: { // 5 lightning bolt
wxGraphicsPath p = gc->CreatePath();
p.MoveToPoint(13, 2);
p.AddLineToPoint(5, 12);
p.AddLineToPoint(10, 12);
p.AddLineToPoint(8, 20);
p.AddLineToPoint(17, 9);
p.AddLineToPoint(11, 9);
p.CloseSubpath();
gc->FillPath(p);
break;
}
}
delete gc;
}
}
return (void*)new wxStaticBitmap((wxWindow*)parent, wxID_ANY, bmp);
}
// ---- live theme changes -----------------------------------------------------
// Emit WxEV_SYS_COLOUR when the OS light/dark theme changes so the app can
@@ -1048,6 +1423,55 @@ void wxbr_call_after(int id) {
}
}
// ---- status-bar error/warning indicator -------------------------------------
// A colour-tinted static text pinned to the RIGHT-hand field of the frame's
// status bar, so scan/apply errors surface in the bottom-right corner without
// overwriting the main (left) scan-status text. The status bar is reconfigured
// to two fields: field 0 (stretch) carries the scan status set via the upstream
// SetStatusText path; field 1 (fixed) hosts this coloured label, which we
// reposition into that field's rect whenever the bar is resized.
static wxStaticText* g_status_indicator = nullptr;
static void reposition_status_indicator() {
if (!g_status_indicator) return;
wxStatusBar* sb = wxDynamicCast(g_status_indicator->GetParent(), wxStatusBar);
if (!sb) return;
wxRect r;
if (!sb->GetFieldRect(1, r)) return;
wxSize best = g_status_indicator->GetBestSize();
int h = best.GetHeight();
int y = r.y + (r.height - h) / 2;
g_status_indicator->SetSize(r.x + 4, y, r.width - 8, h);
}
void wxbr_status_indicator_init(void* frame_ptr) {
wxFrame* frame = (wxFrame*)frame_ptr;
wxStatusBar* sb = frame->GetStatusBar();
if (!sb) sb = frame->CreateStatusBar();
int widths[2] = { -1, 340 };
sb->SetFieldsCount(2);
sb->SetStatusWidths(2, widths);
if (!g_status_indicator) {
g_status_indicator = new wxStaticText(sb, wxID_ANY, wxEmptyString,
wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT | wxST_NO_AUTORESIZE);
sb->Bind(wxEVT_SIZE, [](wxSizeEvent& ev) {
reposition_status_indicator();
ev.Skip();
});
}
reposition_status_indicator();
}
// Set the bottom-right indicator text and its colour. An empty string clears it.
void wxbr_status_indicator_set(const char* text, int r, int g, int b) {
if (!g_status_indicator) return;
g_status_indicator->SetLabel(wxString::FromUTF8(text ? text : ""));
g_status_indicator->SetForegroundColour(
wxColour((unsigned char)r, (unsigned char)g, (unsigned char)b));
reposition_status_indicator();
g_status_indicator->Refresh();
}
// ---- deferred destroy (safe from event handlers) ----------------------------
void wxbr_destroy(void* win) { ((wxWindow*)win)->Destroy(); }
+72
View File
@@ -23,6 +23,8 @@ 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_static_text(parent: *mut c_void, label: *const c_char) -> *mut c_void;
@@ -77,6 +79,8 @@ mod notsafe {
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_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);
@@ -99,10 +103,13 @@ mod notsafe {
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_kpi_icon(parent: *mut c_void, kind: c_int, r: c_int, g: c_int, b: c_int) -> *mut c_void;
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);
}
}
@@ -139,6 +146,8 @@ pub enum WxEventKind {
SysColour,
Deferred,
DvlcHeaderRightClick,
/// Window resized; p1 = new client width, p2 = new client height.
Sized,
}
impl WxEventKind {
@@ -158,6 +167,7 @@ impl WxEventKind {
13 => WxEventKind::SysColour,
14 => WxEventKind::Deferred,
15 => WxEventKind::DvlcHeaderRightClick,
16 => WxEventKind::Sized,
_ => return None,
})
}
@@ -175,6 +185,21 @@ 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) }
}
/// 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) }
}
/// 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();
@@ -291,6 +316,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) }
}
@@ -596,6 +633,27 @@ 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()
}
// ---- popup menu ----
pub fn menu_new() -> Widget {
@@ -710,6 +768,20 @@ impl Widget {
})
}
/// A small drawn KPI icon (static bitmap). kind: 0 rabbit, 1 turtle,
/// 2 broken wine glass, 3 otter, 4 hive, 5 lightning bolt (round 11 #15).
pub fn kpi_icon(parent: Widget, kind: i32, color: (u8, u8, u8)) -> Widget {
Widget(unsafe {
notsafe::wxbr_kpi_icon(
parent.0,
kind,
color.0 as c_int,
color.1 as c_int,
color.2 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) }
+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":"f1972769a1b4811d5772e96b2e6c45b461cdcb4175355dba2b586b9df776fc1d","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":"278e4dd04a753858e12df96ead3522aef0616ebf6f27b3da4f1a12b064c19ee6","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"}
+10 -1
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},
@@ -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,
@@ -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,
+1 -1
View File
@@ -1 +1 @@
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"80f3915f1e87c6f7483e9bd0e5b1fb5552f8d017634c82eea6150fe5134b171f","src/backends/v1/rpc.rs":"4cee9caeb9bc291c4efec04f4b7fc2b8eaead904a1f2d0f30e13236476d9aac5","src/backends/v2/mod.rs":"a1a054eda0b1466b8ae1693f47d6f2d79cc0ac067eb82320c4d659c9e1eaef0f","src/backends/v2/rpc.rs":"b7afc5357d24de42350d4ec15a6b5a37698e4fd77b2c2cc8071f303ee62e957c","src/backends/v3/mod.rs":"fd232f2df64b148f0998726fc41c089d08080ba25b3ca37bcb1c7f43b08b1c17","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"de85845f52b1d4e1a0bff73462cef00962b60fad8a3ed71c7bb083c02df3a413","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"30f09ad063df45fdf223aff235fe2da15cb1a7e79e86d7012074153b91662fc4","Cargo.lock":"9d0886791db53421d3218ab72d964145b86cfbe9738eaf09aac5d3c89a1c0190","Cargo.toml":"8c2e9938436850f2e250e8268ed7b385fce903e2077923b207a0560ca3e3242c","Cargo.toml.orig":"891fcfa45e79d6bc4d838c4f3075618f791bd013c99231da48e752b987f409d5","src/backends/mod.rs":"0f5a0ae31d5443d0d0f41a2540def806196238c92d22761b3ad9843cb2e77f45","src/backends/v1/mod.rs":"80f3915f1e87c6f7483e9bd0e5b1fb5552f8d017634c82eea6150fe5134b171f","src/backends/v1/rpc.rs":"4cee9caeb9bc291c4efec04f4b7fc2b8eaead904a1f2d0f30e13236476d9aac5","src/backends/v2/mod.rs":"68fd8c1762b424a7785174fdb3ae4fede1d599632657808d4b7c76bcfbfb202c","src/backends/v2/rpc.rs":"b7afc5357d24de42350d4ec15a6b5a37698e4fd77b2c2cc8071f303ee62e957c","src/backends/v3/mod.rs":"f19e673c47c2cc366e2ff7782bca93daf750563d62221a12a043b3ee79a15251","src/backends/v3/rpc.rs":"7a5f80aec4af1bcaa0d36e67345aa9acbbd8ead73c0be474f06305358b38e81b","src/error_codes.rs":"de85845f52b1d4e1a0bff73462cef00962b60fad8a3ed71c7bb083c02df3a413","src/firmware.rs":"6d002e481ce0a897c0485b9393b0382fcb25811164e893eb8eb67b2ff392ca0d","src/lib.rs":"710b46c9d934f26f900e1366ca1df5f872896e7d8da03569c0f159859e899cc9","src/test/json/mod.rs":"99760925ccfefc40d2455d3567fb1ecfc99e9e55e70478190ef372a954825909","src/test/json/v1/devs.json":"b4fd010f0bae3584efde93387cf2dab5933b499cc30a2dd7635fdc994b56c3b8","src/test/json/v1/get_psu.json":"8c11b6495e0bd5da496dd5c10ca53ec53b2d8fe9a3737f470ec9ce2c1aaf9d99","src/test/json/v1/get_version.json":"c43e947e654792ab191210d50c6f793ee0dd7af41e8cb59f0722b70f32a203bc","src/test/json/v1/mod.rs":"e79509eee78a1fef63735afe385299813726822c8259a02d1dcf5e8b4db9d04e","src/test/json/v1/pools.json":"b570808a3428a0773d7d2ee322150d8fd0794a33804af970300a7fef128a8a01","src/test/json/v1/status.json":"00ec38dd9f980b7ac0ffd6f815374afdbbed98d601bd8ef18bcf0f76ae0aa853","src/test/json/v1/summary.json":"d6e3e75654eb4019e1f479b3d9cf3097130f1afb85dd3338682c094fd4ab498a","src/test/json/v1/summary_with_errors.json":"1ba682f6ad5c43e41ae22a4069d0f52f04da3f07a18031bf4c07e07b3c59cc97","src/test/json/v2/devs.json":"2d203e41ef6ef337c0c81456b73d08730882c3167403c557c3c9776022a972d1","src/test/json/v2/get_error_code.json":"e90b702fd97bceb4f62dcb8228f75ff5ce930290355dca94eefd7192f7f57009","src/test/json/v2/get_error_code_with_errors.json":"6cb6038366eb3835684421c41be0b2b30ae8ce79a7ed51a85f4f52f70da9df16","src/test/json/v2/get_miner_info.json":"55d2af984833a692f502188ae4df4e41bdc10386b47f921c896a452ef1de9062","src/test/json/v2/get_psu.json":"b43086b65897061521d1f6611e200ef372a1724f9ea1876e347c03d5fb19b8f2","src/test/json/v2/get_version.json":"b17e3a81603b43186b2e15745e6822b6c82b3c6f5928b22f84e683d7728dbfcd","src/test/json/v2/mod.rs":"c847205d076323bbd9698e393d241b08f3cf75d32aae86f7058cf8748266b935","src/test/json/v2/pools.json":"926d34e8dae774473ebfec83d4a38e77ca73231708f07683763e212be7af0580","src/test/json/v2/status.json":"fc268cd23864ef99e84813dbf8eb916b2e6f339351a0ee5dab217cbe02569fc3","src/test/json/v2/summary.json":"4e4c01b986e2960893f58d0f1ea4dce23b8ef88db4985348f7f0183eb4818478","src/test/json/v3/get_device_info.json":"83ac22ea9a11adbceb4c963db80aa62d9a2aa50d019a372394dece817d924cda","src/test/json/v3/get_device_info_with_errors.json":"24cee4b7840e87e12147cbfddf6c361f3b378a15bb85330b339d3be9e17cdbd5","src/test/json/v3/get_miner_status_edevs.json":"2d831c06113f555e0988df994c2e602a053a4aea603dded0db8f0f80e191ca5a","src/test/json/v3/get_miner_status_pools.json":"cd65c2efd3a5ce80b57aae46c420298a34ca06df7ac7f8c36fd556217703d242","src/test/json/v3/get_miner_status_summary.json":"799a94ba13ef54aed0f81a3d041d6c1fa263d4183754b384c69ca12d85a8d3ba","src/test/json/v3/mod.rs":"7ea3a8ff1b81c7a5b0f44f7c12dda880a9aeac5b0e6b56ac4fff4f4a7cbfe451","src/test/mod.rs":"ed52c3d613eabc4a0346bb38bcfdf7a94933d61e368d3c9094821edeab92f81b"},"package":"c85da6325b62f061327dc5f7605dd3721c823a9e8a2cfd6a356363dfbc84d66e"}
+13 -3
View File
@@ -637,11 +637,21 @@ impl SetFaultLight for WhatsMinerV2 {
impl SetPowerLimit for WhatsMinerV2 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let parameters = Some(json!({"power_limit": limit.as_watts().to_string()}));
let data = self
match self
.rpc
.send_command("adjust_power_limit", true, parameters)
.await;
Ok(data.is_ok())
.await
{
Ok(_) => Ok(true),
// adjust_power_limit makes the miner restart to re-tune, so it drops
// the connection / stops replying mid-command even though it accepted
// and applied the new limit (verified on the live fleet: the set value
// settles after the restart). A transient RPC error (read timeout /
// connection reset) after the command is therefore success; a genuine
// rejection surfaces as StatusCheckFailed and still errors.
Err(e) if is_expected_write_error(&e) => Ok(true),
Err(e) => Err(e),
}
}
fn supports_set_power_limit(&self) -> bool {
true
+23 -7
View File
@@ -669,12 +669,21 @@ impl SetFaultLight for WhatsMinerV3 {
#[async_trait]
impl SetPowerLimit for WhatsMinerV3 {
async fn set_power_limit(&self, limit: Power) -> anyhow::Result<bool> {
let data = self
// WhatsMinerOS wants a BARE INTEGER watt value; a float ("3000.0")
// trips the firmware's "invalid json" parser (round-9 #4).
let watts = limit.as_watts().round() as u64;
match self
.rpc
.send_command("set.miner.power_limit", true, Some(json!(limit.as_watts())))
.await;
Ok(data.is_ok())
.send_command("set.miner.power_limit", true, Some(json!(watts)))
.await
{
Ok(_) => Ok(true),
// A power-limit change restarts the miner to re-tune, so a transient
// RPC error after the command means it was accepted (as with v2), not
// rejected; a genuine rejection is a StatusCheckFailed and still errors.
Err(e) if is_expected_write_error(&e) => Ok(true),
Err(e) => Err(e),
}
}
fn supports_set_power_limit(&self) -> bool {
true
@@ -806,8 +815,15 @@ impl HasDefaultAuth for WhatsMinerV3 {
impl HasAuth for WhatsMinerV3 {
fn set_auth(&mut self, auth: MinerAuth) {
// WhatsMiner V3 username is always "super", V2 is always "admin"
self.rpc.set_auth(MinerAuth::new("super", auth.password()));
// WhatsMiner V3 username is always "super", V2 is always "admin".
// The V3 privileged token authenticates against the "super" ACCOUNT,
// whose password is a separate v3 credential (factory default "super")
// -- NOT the web/admin password carried by `auth`. Pairing account
// "super" with the web password made every v3 privileged write fail with
// "invalid json or password is wrong" (round-9 #4, confirmed on the live
// fleet). Keep the super-account default password here; the web password
// still drives the v2 (admin) path below.
self.rpc.set_auth(MinerAuth::new("super", "super"));
self.v2_rpc
.set_auth(MinerAuth::new("admin", auth.password()));
}