Files
alkane-toolkit/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
T
noahandClaude Opus 5.5 9b440a46e3 Show hashboards and SHA-256 for VNish models asic-rs does not know
VNish reports the 88-chip S19 as "Antminer S19 (88)", which asic-rs parses
to an Unknown model with no hardware table. The VNish backends sized the
board list from that table, so all three live chains were dropped and the
Health column drew no hashboard icons for hashing miners; the same model also
got an Unknown hash algorithm. Size boards from the chains the miner reports
when the table is missing, and infer the algorithm from the Antminer family
letter (helper shared with the stock backend). asic-rs patch 0034.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:32:28 -06:00

1714 lines
56 KiB
Rust

use std::{collections::HashMap, fmt::Display, net::IpAddr, str::FromStr, time::Duration};
use anyhow;
use asic_rs_core::{
config::{
collector::{ConfigCollector, ConfigExtractor, ConfigField, ConfigLocation},
fan::FanConfig,
pools::{PoolConfig, PoolGroupConfig},
tuning::TuningConfig,
},
data::{
board::{BoardData, MinerControlBoard},
collector::{
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
},
command::MinerCommand,
device::{DeviceInfo, HashAlgorithm},
fan::FanData,
firmware::FirmwareImage,
hashrate::{HashRate, HashRateUnit},
message::{MessageSeverity, MinerMessage},
miner::{MiningMode, TuningTarget},
pool::{PoolData, PoolGroupData, PoolURL},
share::{ShareSummary, parse_cgminer_share_summary},
},
traits::{miner::*, model::MinerModel},
};
use asic_rs_makes_antminer::hardware::AntMinerControlBoard;
use async_trait::async_trait;
use macaddr::MacAddr;
use measurements::{AngularVelocity, Frequency, Power, Temperature};
use rpc::AntMinerRPCAPI;
use semver::Version;
use serde_json::{Value, json};
use web::AntMinerWebAPI;
use self::firmware::resolve_firmware_image;
use crate::firmware::AntMinerStockFirmware;
mod firmware;
mod rpc;
pub(crate) mod web;
#[derive(Debug)]
pub struct AntMinerV2020 {
pub ip: IpAddr,
pub rpc: AntMinerRPCAPI,
pub web: AntMinerWebAPI,
pub device_info: DeviceInfo,
}
#[allow(dead_code)]
enum MinerMode {
Sleep,
Low,
Normal,
High,
}
impl Display for MinerMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let s = match self {
MinerMode::Sleep => "1",
MinerMode::Low => "3",
MinerMode::High => "2",
_ => "0",
};
f.write_str(s)
}
}
impl MinerMode {
fn as_web_value(&self) -> u8 {
match self {
MinerMode::Sleep => 1,
MinerMode::Low => 3,
MinerMode::Normal => 0,
MinerMode::High => 2,
}
}
}
fn miner_mode_config_key(miner_conf: &Value) -> Option<&'static str> {
if miner_conf.get("miner-mode").is_some() {
Some("miner-mode")
} else if miner_conf.get("bitmain-work-mode").is_some() {
Some("bitmain-work-mode")
} else {
None
}
}
fn browser_miner_conf_payload(miner_conf: &Value) -> serde_json::Map<String, Value> {
let mut payload = serde_json::Map::new();
payload.insert(
"bitmain-fan-ctrl".to_string(),
miner_conf
.get("bitmain-fan-ctrl")
.cloned()
.unwrap_or(Value::Bool(false)),
);
payload.insert(
"bitmain-fan-pwm".to_string(),
miner_conf
.get("bitmain-fan-pwm")
.cloned()
.unwrap_or(Value::String("100".to_string())),
);
if let Some(mode_key) = miner_mode_config_key(miner_conf)
&& let Some(mode) = miner_conf.get(mode_key)
{
payload.insert(mode_key.to_string(), mode.clone());
}
payload.insert(
"freq-level".to_string(),
miner_conf
.get("freq-level")
.or_else(|| miner_conf.get("bitmain-freq-level"))
.cloned()
.unwrap_or(Value::String("100".to_string())),
);
payload.insert(
"pools".to_string(),
miner_conf
.get("pools")
.cloned()
.unwrap_or_else(|| Value::Array(Vec::new())),
);
payload
}
fn miner_conf_with_pools(miner_conf: &Value, pools: Vec<Value>) -> Value {
let mut payload = browser_miner_conf_payload(miner_conf);
payload.insert("pools".to_string(), Value::Array(pools));
Value::Object(payload)
}
fn miner_conf_with_miner_mode(miner_conf: &Value, mode: MinerMode) -> Option<Value> {
miner_mode_config_key(miner_conf)?;
let mut payload = browser_miner_conf_payload(miner_conf);
let mode = Value::from(mode.as_web_value());
payload.insert("miner-mode".to_string(), mode.clone());
payload.insert("bitmain-work-mode".to_string(), mode);
Some(Value::Object(payload))
}
fn miner_mode_from_value(mode: &Value) -> Option<MiningMode> {
let mode = mode
.as_str()
.map(str::to_owned)
.or_else(|| mode.as_i64().map(|mode| mode.to_string()))?;
match mode.as_str() {
"0" => Some(MiningMode::Normal),
"2" => Some(MiningMode::High),
"3" => Some(MiningMode::Low),
_ => None,
}
}
fn miner_conf_mining_mode(miner_conf: &Value) -> Option<MiningMode> {
["miner-mode", "bitmain-work-mode"]
.iter()
.filter_map(|key| miner_conf.get(key))
.find_map(miner_mode_from_value)
}
fn bool_from_value(value: &Value) -> Option<bool> {
value.as_bool().or_else(|| {
value.as_str().and_then(|s| match s {
"1" => Some(true),
"0" => Some(false),
_ if s.eq_ignore_ascii_case("true") => Some(true),
_ if s.eq_ignore_ascii_case("false") => Some(false),
_ => None,
})
})
}
fn u64_from_value(value: &Value) -> Option<u64> {
value
.as_u64()
.or_else(|| value.as_str().and_then(|s| s.parse::<u64>().ok()))
}
fn miner_conf_with_fan_config(miner_conf: &Value, config: FanConfig) -> Value {
let mut payload = browser_miner_conf_payload(miner_conf);
match config {
FanConfig::Auto { .. } => {
payload.insert("bitmain-fan-ctrl".to_string(), Value::Bool(false));
}
FanConfig::Manual { fan_speed } => {
payload.insert("bitmain-fan-ctrl".to_string(), Value::Bool(true));
payload.insert(
"bitmain-fan-pwm".to_string(),
Value::String(fan_speed.min(100).to_string()),
);
}
}
Value::Object(payload)
}
use asic_rs_makes_antminer::models::infer_antminer_algo;
impl AntMinerV2020 {
pub fn new(ip: IpAddr, model: impl MinerModel) -> Self {
let auth = Self::default_auth();
// asic-rs maps a model string to its algorithm through a fixed alias
// table; a model that is not in the table (a Z15J, a not-yet-added
// S-series, ...) resolves to HashAlgorithm::Unknown, which then leaves the
// miner's hashrate un-bucketed ("unknown hashrate", round 13 #5). When the
// table can't place the model, infer the algorithm from its Antminer
// family letter for the lines that are single-algorithm end to end.
let algo = match model.hash_algorithm() {
HashAlgorithm::Unknown => infer_antminer_algo(&model.to_string()),
known => known,
};
AntMinerV2020 {
ip,
rpc: AntMinerRPCAPI::new(ip),
web: AntMinerWebAPI::new(ip, auth),
device_info: DeviceInfo::new(model, AntMinerStockFirmware::default(), algo),
}
}
/// Read a numeric field that some firmware generations emit as a JSON
/// number and others as a quoted string.
fn parse_f64_field(value: &Value) -> Option<f64> {
value
.as_f64()
.or_else(|| value.as_str().and_then(|s| s.trim().parse::<f64>().ok()))
}
fn parse_temp_string(temp_str: &str) -> Option<Temperature> {
let temps: Vec<f64> = temp_str
.split('-')
.filter_map(|s| s.parse().ok())
.filter(|&temp| temp > 0.0)
.collect();
if !temps.is_empty() {
let avg = temps.iter().sum::<f64>() / temps.len() as f64;
Some(Temperature::from_celsius(avg))
} else {
None
}
}
fn _calculate_average_temp_s21_hyd(chain: &Value) -> Option<Temperature> {
let mut temps = Vec::new();
if let Some(temp_pic) = chain.get("temp_pic").and_then(|v| v.as_array()) {
for i in 1..=3 {
if let Some(temp) = temp_pic.get(i).and_then(|v| v.as_f64())
&& temp != 0.0
{
temps.push(temp);
}
}
}
if let Some(temp_pcb) = chain.get("temp_pcb").and_then(|v| v.as_array()) {
if let Some(temp) = temp_pcb.get(1).and_then(|v| v.as_f64())
&& temp != 0.0
{
temps.push(temp);
}
if let Some(temp) = temp_pcb.get(3).and_then(|v| v.as_f64())
&& temp != 0.0
{
temps.push(temp);
}
}
if !temps.is_empty() {
let avg = temps.iter().sum::<f64>() / temps.len() as f64;
Some(Temperature::from_celsius(avg))
} else {
None
}
}
fn _calculate_average_temp_pcb(chain: &Value) -> Option<Temperature> {
if let Some(temp_pcb) = chain.get("temp_pcb").and_then(|v| v.as_array()) {
let temps: Vec<f64> = temp_pcb
.iter()
.filter_map(|v| v.as_f64())
.filter(|&temp| temp != 0.0)
.collect();
if !temps.is_empty() {
let avg = temps.iter().sum::<f64>() / temps.len() as f64;
Some(Temperature::from_celsius(avg))
} else {
None
}
} else {
None
}
}
fn _calculate_average_temp_chip(chain: &Value) -> Option<Temperature> {
if let Some(temp_chip) = chain.get("temp_chip").and_then(|v| v.as_array()) {
let temps: Vec<f64> = temp_chip
.iter()
.filter_map(|v| v.as_f64())
.filter(|&temp| temp != 0.0)
.collect();
if !temps.is_empty() {
let avg = temps.iter().sum::<f64>() / temps.len() as f64;
Some(Temperature::from_celsius(avg))
} else {
None
}
} else {
None
}
}
}
#[async_trait]
impl APIClient for AntMinerV2020 {
async fn get_api_result(&self, command: &MinerCommand) -> anyhow::Result<Value> {
match command {
MinerCommand::RPC { .. } => self.rpc.get_api_result(command).await,
MinerCommand::WebAPI { .. } => self.web.get_api_result(command).await,
_ => Err(anyhow::anyhow!("Unsupported command type for Antminer API")),
}
}
}
impl GetConfigsLocations for AntMinerV2020 {
fn get_configs_locations(&self, data_field: ConfigField) -> Vec<ConfigLocation> {
const WEB_GET_MINER_CONF: MinerCommand = MinerCommand::WebAPI {
command: "get_miner_conf",
parameters: None,
};
match data_field {
ConfigField::Pools => vec![(
WEB_GET_MINER_CONF,
ConfigExtractor {
func: get_by_pointer,
key: Some("/pools"),
tag: None,
},
)],
ConfigField::Tuning | ConfigField::Fan => vec![(
WEB_GET_MINER_CONF,
ConfigExtractor {
func: get_by_pointer,
key: Some(""),
tag: None,
},
)],
_ => vec![],
}
}
}
impl CollectConfigs for AntMinerV2020 {
fn get_config_collector(&self) -> ConfigCollector<'_> {
ConfigCollector::new(self)
}
}
impl GetDataLocations for AntMinerV2020 {
fn get_locations(&self, data_field: DataField) -> Vec<DataLocation> {
const RPC_VERSION: MinerCommand = MinerCommand::RPC {
command: "version",
parameters: None,
};
const RPC_STATS: MinerCommand = MinerCommand::RPC {
command: "stats",
parameters: None,
};
const RPC_SUMMARY: MinerCommand = MinerCommand::RPC {
command: "summary",
parameters: None,
};
const RPC_POOLS: MinerCommand = MinerCommand::RPC {
command: "pools",
parameters: None,
};
const WEB_SYSTEM_INFO: MinerCommand = MinerCommand::WebAPI {
command: "get_system_info",
parameters: None,
};
const WEB_BLINK_STATUS: MinerCommand = MinerCommand::WebAPI {
command: "get_blink_status",
parameters: None,
};
const WEB_MINER_CONF: MinerCommand = MinerCommand::WebAPI {
command: "get_miner_conf",
parameters: None,
};
const WEB_SUMMARY: MinerCommand = MinerCommand::WebAPI {
command: "summary",
parameters: None,
};
const WEB_MINER_TYPE: MinerCommand = MinerCommand::WebAPI {
command: "miner_type",
parameters: None,
};
match data_field {
DataField::Mac => vec![(
WEB_SYSTEM_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/macaddr"),
tag: None,
},
)],
DataField::ApiVersion => vec![(
RPC_VERSION,
DataExtractor {
func: get_by_pointer,
key: Some("/VERSION/0/API"),
tag: None,
},
)],
DataField::FirmwareVersion => vec![(
WEB_SYSTEM_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/system_filesystem_version"),
tag: None,
},
)],
DataField::Hostname => vec![(
WEB_SYSTEM_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/hostname"),
tag: None,
},
)],
// Prefer the explicit control-board subtype from miner_type.cgi, but
// carry the kernel build string from get_system_info.cgi too: older
// models (e.g. Z15/Z15J) have no miner_type.cgi, and their kernel
// string ("...-xilinx-...") names the control board we can actually
// read instead of guessing from the model (round 12 #10).
DataField::ControlBoardVersion => vec![
(
WEB_MINER_TYPE,
DataExtractor {
func: get_by_pointer,
key: Some("/subtype"),
tag: Some("subtype"),
},
),
(
WEB_SYSTEM_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/system_kernel_version"),
tag: Some("kernel"),
},
),
],
// cgminer names its summary keys after the unit they are in —
// `GHS 5s` on SHA-256 models, `MHS 5s` on Scrypt ones — so keep
// the whole entry and let the parse pick the key that is present.
DataField::Hashrate => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
// cgminer summary "Best Share" (all-time). RPC_SUMMARY is already
// fetched, so this adds no round-trip (round 19 #10).
DataField::BestShare => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/Best Share"),
tag: None,
},
)],
// Cumulative share stats from cgminer summary (round 19 #10, T2);
// RPC_SUMMARY already fetched.
DataField::ShareSummary => vec![(
RPC_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0"),
tag: None,
},
)],
// `total_rateideal`, by contrast, says nothing about its own
// scale, so carry STATS' `rate_unit` alongside it.
DataField::ExpectedHashrate => vec![
(
RPC_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/STATS/1/total_rateideal"),
tag: Some("hashrate"),
},
),
(
RPC_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/STATS/1/rate_unit"),
tag: Some("unit"),
},
),
],
DataField::Fans => vec![(
RPC_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/STATS/1"),
tag: None,
},
)],
DataField::Hashboards => vec![(
RPC_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/STATS/1"),
tag: None,
},
)],
DataField::LightFlashing => vec![(
WEB_BLINK_STATUS,
DataExtractor {
func: get_by_pointer,
key: Some("/blink"),
tag: None,
},
)],
DataField::IsMining => vec![(
WEB_MINER_CONF,
DataExtractor {
func: get_by_pointer,
key: Some("/bitmain-work-mode"),
tag: None,
},
)],
DataField::Uptime => vec![(
RPC_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/STATS/1/Elapsed"),
tag: None,
},
)],
DataField::Pools => vec![(
RPC_POOLS,
DataExtractor {
func: get_by_pointer,
key: Some("/POOLS"),
tag: None,
},
)],
DataField::Wattage => {
// Not a `const` because `json!` is not const-evaluable.
let rpc_new_stats = MinerCommand::RPC {
command: "stats",
parameters: Some(json!({ "new_api": true })),
};
vec![
(
RPC_STATS,
DataExtractor {
func: get_by_pointer,
key: Some("/STATS/1"),
tag: None,
},
),
(
rpc_new_stats,
DataExtractor {
func: get_by_pointer,
key: Some("/STATS/0"),
tag: None,
},
),
]
}
DataField::SerialNumber => vec![
(
WEB_SYSTEM_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/serial_no"), // Cant find on 2022 firmware, does exist on 2025 firmware for XP
tag: None,
},
),
(
WEB_SYSTEM_INFO,
DataExtractor {
func: get_by_pointer,
key: Some("/serinum"), // exist on 2025 firmware for s21
tag: None,
},
),
],
DataField::Messages => vec![(
WEB_SUMMARY,
DataExtractor {
func: get_by_pointer,
key: Some("/SUMMARY/0/status"),
tag: None,
},
)],
DataField::TuningTarget => vec![(
WEB_MINER_CONF,
DataExtractor {
func: get_by_pointer,
key: Some(""),
tag: None,
},
)],
_ => vec![],
}
}
}
impl GetIP for AntMinerV2020 {
fn get_ip(&self) -> IpAddr {
self.ip
}
}
impl GetDeviceInfo for AntMinerV2020 {
fn get_device_info(&self) -> DeviceInfo {
self.device_info.clone()
}
}
impl CollectData for AntMinerV2020 {
fn get_collector(&self) -> DataCollector<'_> {
DataCollector::new(self)
}
}
impl GetMAC for AntMinerV2020 {
fn parse_mac(&self, data: &HashMap<DataField, Value>) -> Option<MacAddr> {
data.extract::<String>(DataField::Mac)
.and_then(|s| MacAddr::from_str(&s).ok())
}
}
impl GetHostname for AntMinerV2020 {
fn parse_hostname(&self, data: &HashMap<DataField, Value>) -> Option<String> {
data.extract::<String>(DataField::Hostname)
}
}
impl GetApiVersion for AntMinerV2020 {
fn parse_api_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
data.extract::<String>(DataField::ApiVersion)
}
}
impl GetFirmwareVersion for AntMinerV2020 {
fn parse_firmware_version(&self, data: &HashMap<DataField, Value>) -> Option<String> {
data.extract::<String>(DataField::FirmwareVersion)
}
}
impl GetHashboards for AntMinerV2020 {
fn parse_hashboards(&self, data: &HashMap<DataField, Value>) -> Vec<BoardData> {
let mut hashboards: Vec<BoardData> =
(0..self.device_info.hardware.board_count().unwrap_or(0))
.map(|idx| {
BoardData::new(idx, self.device_info.hardware.chips_for_board(idx as usize))
})
.collect();
let Some(stats_data) = data.get(&DataField::Hashboards).and_then(|v| v.as_object()) else {
return hashboards;
};
let unit = stats_data
.get("rate_unit")
.and_then(|v| v.as_str())
.and_then(|s| HashRateUnit::from_str(s).ok())
.unwrap_or(HashRateUnit::GigaHash);
let algo = self.device_info.algo;
for board in hashboards.iter_mut() {
let idx = board.position + 1;
board.hashrate = stats_data
.get(&format!("chain_rate{idx}"))
.and_then(Self::parse_f64_field)
.map(|r| {
HashRate {
value: r,
unit,
algo,
}
.as_unit(HashRateUnit::default())
});
// `temp_pcb{idx}` on older generations; newer ones split the
// reading into inlet/outlet pairs and omit the combined key.
board.board_temperature = stats_data
.get(&format!("temp_pcb{idx}"))
.and_then(|v| v.as_str())
.and_then(Self::parse_temp_string)
.or_else(|| {
stats_data
.get(&format!("temp_out_pcb_{idx}"))
.and_then(Self::parse_f64_field)
.filter(|&t| t > 0.0)
.map(Temperature::from_celsius)
});
board.working_chips = stats_data
.get(&format!("chain_acn{idx}"))
.and_then(|v| v.as_u64())
.map(|u| u as u16);
board.frequency = stats_data
.get(&format!("freq{idx}"))
.and_then(|v| v.as_u64())
.map(|f| Frequency::from_megahertz(f as f64));
let has_hashrate = board
.hashrate
.as_ref()
.map(|h| h.value > 0.0)
.unwrap_or(false);
let has_chips = board.working_chips.map(|chips| chips > 0).unwrap_or(false);
board.active = Some(has_hashrate || has_chips);
}
hashboards
}
}
impl GetHashrate for AntMinerV2020 {
fn parse_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
let summary = data.get(&DataField::Hashrate)?.as_object()?;
// cgminer names its rate keys `<unit> <window>` — `GHS 5s` on SHA-256
// models, `MHS 5s` on Scrypt ones — so the key states its own unit.
// Prefer the 5-second window and fall back to the average.
let (value, unit) = ["5s", "av"].into_iter().find_map(|window| {
summary.iter().find_map(|(key, raw)| {
let (unit, key_window) = key.split_once(' ')?;
if key_window != window {
return None;
}
Some((
Self::parse_f64_field(raw)?,
HashRateUnit::from_str(unit).ok()?,
))
})
})?;
// 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,
unit,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default()),
)
}
}
impl GetExpectedHashrate for AntMinerV2020 {
fn parse_expected_hashrate(&self, data: &HashMap<DataField, Value>) -> Option<HashRate> {
let field = data.get(&DataField::ExpectedHashrate);
let value = field?
.pointer("/hashrate")
.and_then(Self::parse_f64_field)?;
// Equihash miners (Z15/Z15J) report `total_rateideal` as a Sol/s count in
// the same (mislabelled) scale as the realtime "GHS" rate, so reinterpret
// it as the base Hash unit -- matching parse_hashrate. Without this,
// expected reads ~1e6x larger than realtime and the realtime figure looks
// absent next to it (round 12 #10).
let is_equihash = self.device_info.algo == HashAlgorithm::Equihash
|| self
.device_info
.model
.to_string()
.to_ascii_uppercase()
.contains("Z15");
let unit = if is_equihash {
HashRateUnit::Hash
} else {
// `total_rateideal` does not name its own scale, so take it from
// STATS' `rate_unit` (`"GH"` / `"MH"`).
field
.and_then(|v| v.pointer("/unit"))
.and_then(|v| v.as_str())
.and_then(|s| HashRateUnit::from_str(s).ok())
.unwrap_or(HashRateUnit::GigaHash)
};
Some(
HashRate {
value,
unit,
algo: self.device_info.algo,
}
.as_unit(HashRateUnit::default()),
)
}
}
impl GetFans for AntMinerV2020 {
fn parse_fans(&self, data: &HashMap<DataField, Value>) -> Vec<FanData> {
let mut fans: Vec<FanData> = Vec::new();
if let Some(stats_data) = data.get(&DataField::Fans) {
// Some models report their fans in higher fan slots and leave the low
// ones at 0 -- the Z15, for example, has fan_num=2 but reports its two
// fans in fan3/fan4 with fan1/fan2 = 0. So scan a generous range of
// slots and collect the non-zero readings rather than only reading
// fan1..hardware.fans (which missed the Z15 entirely). The collected
// fans are renumbered 0.. in the order found (round 14 #12).
let mut pos: i16 = 0;
for i in 1..=16 {
if let Some(fan_speed) =
stats_data.get(format!("fan{}", i)).and_then(|v| v.as_f64())
&& fan_speed > 0.0
{
fans.push(FanData {
position: pos,
rpm: Some(AngularVelocity::from_rpm(fan_speed)),
});
pos += 1;
}
}
}
fans
}
}
impl GetLightFlashing for AntMinerV2020 {
fn parse_light_flashing(&self, data: &HashMap<DataField, Value>) -> Option<bool> {
data.extract::<bool>(DataField::LightFlashing).or_else(|| {
data.extract::<String>(DataField::LightFlashing)
.map(|s| s.to_lowercase() == "true" || s == "1")
})
}
}
impl GetUptime for AntMinerV2020 {
fn parse_uptime(&self, data: &HashMap<DataField, Value>) -> Option<Duration> {
data.extract_map::<u64, _>(DataField::Uptime, Duration::from_secs)
}
}
impl GetBestShare for AntMinerV2020 {
fn parse_best_share(&self, data: &HashMap<DataField, Value>) -> Option<f64> {
// cgminer summary "Best Share" (all-time); guard against a 0 placeholder
// (round 19 #10).
data.extract::<f64>(DataField::BestShare).filter(|&v| v > 0.0)
}
fn parse_share_summary(&self, data: &HashMap<DataField, Value>) -> Option<ShareSummary> {
data.get(&DataField::ShareSummary)
.and_then(parse_cgminer_share_summary)
}
}
impl GetSessionBestShare for AntMinerV2020 {}
impl GetOperatingState for AntMinerV2020 {}
impl GetIsMining for AntMinerV2020 {
fn parse_is_mining(&self, data: &HashMap<DataField, Value>) -> bool {
data.extract::<String>(DataField::IsMining)
.map(|status| {
let status_lower = status.to_lowercase();
status_lower != "stopped"
&& status_lower != "idle"
&& status_lower != "sleep"
&& status_lower != "1"
})
.unwrap_or(true)
}
}
impl GetPools for AntMinerV2020 {
fn parse_pools(&self, data: &HashMap<DataField, Value>) -> Vec<PoolGroupData> {
let Some(pools_data) = data.get(&DataField::Pools) else {
return vec![];
};
let Some(pools_array) = pools_data.as_array() else {
return vec![PoolGroupData {
name: String::new(),
quota: 1,
pools: vec![],
}];
};
let mut rpc_pools: Vec<PoolData> = Vec::with_capacity(pools_array.len());
for (idx, pool_info) in pools_array.iter().enumerate() {
let url = pool_info
.get("URL")
.and_then(|v| v.as_str())
.map(|s| PoolURL::from(s.to_string()));
let accepted_shares = pool_info.get("Accepted").and_then(|v| v.as_u64());
let rejected_shares = pool_info.get("Rejected").and_then(|v| v.as_u64());
let active = pool_info.get("Stratum Active").and_then(|v| v.as_bool());
let alive = pool_info
.get("Status")
.and_then(|v| v.as_str())
.map(|s| s == "Alive");
let user = pool_info
.get("User")
.and_then(|v| v.as_str())
.map(String::from);
rpc_pools.push(PoolData {
position: Some(idx as u16),
url,
accepted_shares,
rejected_shares,
active,
alive,
user,
});
}
vec![PoolGroupData {
name: String::new(),
quota: 1,
pools: rpc_pools,
}]
}
}
impl GetSerialNumber for AntMinerV2020 {
fn parse_serial_number(&self, data: &HashMap<DataField, Value>) -> Option<String> {
data.extract::<String>(DataField::SerialNumber)
}
}
impl GetControlBoardVersion for AntMinerV2020 {
fn parse_control_board_version(
&self,
data: &HashMap<DataField, Value>,
) -> Option<MinerControlBoard> {
let field = data.get(&DataField::ControlBoardVersion)?;
// Explicit control-board subtype (miner_type.cgi) wins when present.
let subtype = field
.pointer("/subtype")
.and_then(|v| v.as_str())
.unwrap_or("");
if !subtype.is_empty() {
return match subtype {
s if s.to_uppercase().contains("AML") => Some(AntMinerControlBoard::AMLogic.into()),
_ => AntMinerControlBoard::parse(subtype.split('_').next().unwrap_or(subtype))
.map(|cb| cb.into()),
};
}
// No subtype (older models): read the control board from the kernel build
// string instead of guessing from the model (round 12 #10). Bitmain names
// the SoC in the kernel version, e.g. "Linux 4.6.0-xilinx-..." (Z15) or an
// AMLogic/Meson kernel on newer AMLogic boards.
let kernel = field
.pointer("/kernel")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_ascii_lowercase();
if kernel.contains("xilinx") || kernel.contains("zynq") {
Some(AntMinerControlBoard::Xilinx.into())
} else if kernel.contains("aml") || kernel.contains("meson") {
Some(AntMinerControlBoard::AMLogic.into())
} else {
None
}
}
}
impl GetWattage for AntMinerV2020 {
fn parse_wattage(&self, data: &HashMap<DataField, Value>) -> Option<Power> {
if let Some(stats_data) = data.get(&DataField::Wattage) {
if let Some(chain_power) = stats_data.get("chain_power")
&& let Some(power_str) = chain_power.as_str()
{
// Parse "3250 W" format
if let Some(watt_part) = power_str.split_whitespace().next()
&& let Ok(watts) = watt_part.parse::<f64>()
{
return Some(Power::from_watts(watts));
}
}
if let Some(power) = stats_data
.get("power")
.or_else(|| stats_data.get("Power"))
// Same firmware version spells this differently per model: the
// L9 reports `power`, the L11 `watt`.
.or_else(|| stats_data.get("watt"))
.and_then(|v| v.as_f64())
{
return Some(Power::from_watts(power));
}
}
None
}
}
impl GetTuningTarget for AntMinerV2020 {
fn parse_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
data.get(&DataField::TuningTarget)
.and_then(miner_conf_mining_mode)
.map(TuningTarget::MiningMode)
}
}
impl GetScaledTuningTarget for AntMinerV2020 {
fn parse_scaled_tuning_target(&self, data: &HashMap<DataField, Value>) -> Option<TuningTarget> {
self.parse_tuning_target(data)
}
}
impl GetFluidTemperature for AntMinerV2020 {
fn parse_fluid_temperature(&self, data: &HashMap<DataField, Value>) -> Option<Temperature> {
// For S21+ Hyd models, use inlet/outlet temperature average
if self.device_info.model.to_string().contains("S21+ Hyd")
&& let Some(hashboards_data) = data.get(&DataField::Hashboards)
&& let Some(chains) = hashboards_data.as_array()
{
let mut temps = Vec::new();
for chain in chains {
if let Some(temp_pcb) = chain.get("temp_pcb").and_then(|v| v.as_array()) {
// Inlet temp (index 0) and outlet temp (index 2)
if let Some(inlet) = temp_pcb.first().and_then(|v| v.as_f64())
&& inlet != 0.0
{
temps.push(inlet);
}
if let Some(outlet) = temp_pcb.get(2).and_then(|v| v.as_f64())
&& outlet != 0.0
{
temps.push(outlet);
}
}
}
if !temps.is_empty() {
let avg = temps.iter().sum::<f64>() / temps.len() as f64;
return Some(Temperature::from_celsius(avg));
}
}
None
}
}
impl GetPsuFans for AntMinerV2020 {}
impl GetTuningCapabilities for AntMinerV2020 {}
impl SupportsTimezoneConfig for AntMinerV2020 {}
impl GetMessages for AntMinerV2020 {
fn parse_messages(&self, data: &HashMap<DataField, Value>) -> Vec<MinerMessage> {
let mut messages = Vec::new();
if let Some(status_data) = data.get(&DataField::Messages)
&& let Some(status_array) = status_data.as_array()
{
for (idx, item) in status_array.iter().enumerate() {
if let Some(status) = item.get("status").and_then(|v| v.as_str())
&& status != "s"
{
// 's' means success/ok
let message_text = item
.get("msg")
.and_then(|v| v.as_str())
.unwrap_or("Unknown error")
.to_string();
let severity = match status.to_lowercase().as_str() {
"e" => MessageSeverity::Error,
"w" => MessageSeverity::Warning,
_ => MessageSeverity::Info,
};
messages.push(MinerMessage::new(0, idx as u64, message_text, severity));
}
}
}
messages
}
}
#[async_trait]
impl SetFaultLight for AntMinerV2020 {
fn supports_set_fault_light(&self) -> bool {
true
}
async fn set_fault_light(&self, fault: bool) -> anyhow::Result<bool> {
// `blink()` fires the toggle then reads the state back as `{"isBlinking":
// bool}` (the legacy CGI's own HTTP status is unreliable). Report success
// only when the observed locate-LED state matches what was requested.
let observed = self
.web
.blink(fault)
.await?
.get("isBlinking")
.and_then(serde_json::Value::as_bool);
Ok(observed == Some(fault))
}
}
#[async_trait]
impl SetPowerLimit for AntMinerV2020 {
fn supports_set_power_limit(&self) -> bool {
false
}
}
#[async_trait]
impl SupportsPoolsConfig for AntMinerV2020 {
fn parse_pools_config(
&self,
data: &HashMap<ConfigField, Value>,
) -> anyhow::Result<Vec<PoolGroupConfig>> {
let Some(pools_data) = data.get(&ConfigField::Pools) else {
return Ok(vec![]);
};
let Some(pools_array) = pools_data.as_array() else {
return Ok(vec![PoolGroupConfig {
name: String::new(),
quota: 1,
pools: vec![],
}]);
};
let mut pools: Vec<PoolConfig> = Vec::with_capacity(pools_array.len());
for pool in pools_array {
let Some(url) = pool.get("url").and_then(|v| v.as_str()) else {
continue;
};
if url.is_empty() {
continue;
}
let username = pool
.get("user")
.and_then(|v| v.as_str())
.map(String::from)
.unwrap_or_default();
let password = pool
.get("pass")
.and_then(|v| v.as_str())
.map(String::from)
.unwrap_or_default();
pools.push(PoolConfig {
url: PoolURL::from(url.to_string()),
username,
password,
});
}
pools.truncate(3);
Ok(vec![PoolGroupConfig {
name: String::new(),
quota: 1,
pools,
}])
}
async fn set_pools_config(&self, config: Vec<PoolGroupConfig>) -> anyhow::Result<bool> {
let mut pools: Vec<Value> = config
.into_iter()
.flat_map(|group| group.pools.into_iter())
.map(|pool| {
json!({
"url": pool.url.to_string(),
"user": pool.username,
"pass": pool.password,
})
})
.collect();
pools.truncate(3);
let miner_conf = self.web.get_miner_conf().await?;
let miner_conf = miner_conf_with_pools(&miner_conf, pools);
Ok(self.web.set_miner_conf(miner_conf).await.is_ok())
}
fn supports_pools_config(&self) -> bool {
true
}
}
#[async_trait]
impl Restart for AntMinerV2020 {
fn supports_restart(&self) -> bool {
true
}
async fn restart(&self) -> anyhow::Result<bool> {
Ok(self.web.reboot().await.is_ok())
}
}
#[async_trait]
impl Pause for AntMinerV2020 {
fn supports_pause(&self) -> bool {
true
}
#[allow(unused_variables)]
async fn pause(&self, at_time: Option<Duration>) -> anyhow::Result<bool> {
let pre = self.web.get_miner_conf().await?;
let Some(miner_conf) = miner_conf_with_miner_mode(&pre, MinerMode::Sleep) else {
return Ok(false);
};
let response = self.web.set_miner_conf(miner_conf).await?;
if response.get("stats").and_then(Value::as_str) != Some("success") {
return Ok(false);
}
// set_miner_conf.cgi writes the config before starting a miner
// reload/restart in the background; an immediate follow-up read can
// race the device becoming temporarily unavailable.
Ok(true)
}
}
#[async_trait]
impl Resume for AntMinerV2020 {
fn supports_resume(&self) -> bool {
true
}
#[allow(unused_variables)]
async fn resume(&self, at_time: Option<Duration>) -> anyhow::Result<bool> {
let pre = self.web.get_miner_conf().await?;
let Some(miner_conf) = miner_conf_with_miner_mode(&pre, MinerMode::Normal) else {
return Ok(false);
};
let response = self.web.set_miner_conf(miner_conf).await?;
if response.get("stats").and_then(Value::as_str) != Some("success") {
return Ok(false);
}
Ok(true)
}
}
#[async_trait]
impl ChangePassword for AntMinerV2020 {
async fn change_password(&mut self, password: &str) -> anyhow::Result<bool> {
let original_auth = self.web.auth();
let new_auth = MinerAuth::new(original_auth.username().to_string(), password);
let result = self.web.change_password(password).await;
match result {
Ok(false) => Ok(false),
Ok(true) => {
self.set_auth(new_auth);
if self.web.get_miner_conf().await.is_ok() {
Ok(true)
} else {
self.set_auth(original_auth);
Ok(false)
}
}
Err(err) => {
self.set_auth(new_auth);
if self.web.get_miner_conf().await.is_ok() {
Ok(true)
} else {
self.set_auth(original_auth);
Err(err)
}
}
}
}
fn supports_change_password(&self) -> bool {
true
}
}
#[async_trait]
impl ReadLogs for AntMinerV2020 {
async fn read_logs(&self) -> anyhow::Result<String> {
self.web.read_logs().await
}
fn supports_read_logs(&self) -> bool {
true
}
}
#[async_trait]
impl FactoryReset for AntMinerV2020 {
async fn factory_reset(&self) -> anyhow::Result<bool> {
self.web.factory_reset().await
}
fn supports_factory_reset(&self) -> bool {
true
}
}
#[async_trait]
impl SupportsScalingConfig for AntMinerV2020 {
fn supports_scaling_config(&self) -> bool {
false
}
}
#[async_trait]
impl UpgradeFirmware for AntMinerV2020 {
async fn prepare_firmware(&self, image: FirmwareImage) -> anyhow::Result<FirmwareImage> {
let miner = self.get_miner_type_info().await?;
resolve_firmware_image(image, &miner).await
}
fn supports_prepare_firmware(&self) -> bool {
true
}
async fn upgrade_firmware(&self, image: FirmwareImage) -> anyhow::Result<bool> {
let image = self.prepare_firmware(image).await?;
self.web.upgrade_firmware(image).await?;
Ok(true)
}
fn supports_upgrade_firmware(&self) -> bool {
true
}
}
impl HasDefaultAuth for AntMinerV2020 {
fn default_auth() -> MinerAuth {
MinerAuth::new("root", "root")
}
}
impl HasAuth for AntMinerV2020 {
fn set_auth(&mut self, auth: MinerAuth) {
self.web.set_auth(auth);
}
}
impl Validate for AntMinerV2020 {
type Firmware = AntMinerStockFirmware;
fn validate(version: Option<&semver::Version>) -> bool {
version.is_some_and(|v| *v < Version::new(2023, 7, 0))
}
}
#[async_trait]
impl SupportsTuningConfig for AntMinerV2020 {
async fn set_tuning_config(
&self,
config: TuningConfig,
_scaling_config: Option<asic_rs_core::config::scaling::ScalingConfig>,
) -> anyhow::Result<bool> {
let mode = match config.target {
TuningTarget::Manual { .. } => {
anyhow::bail!("Manual tuning target is not supported on Antminer stock firmware")
}
TuningTarget::MiningMode(MiningMode::Low) => MinerMode::Low,
TuningTarget::MiningMode(MiningMode::Normal) => MinerMode::Normal,
TuningTarget::MiningMode(MiningMode::High) => MinerMode::High,
TuningTarget::Power(_) => {
anyhow::bail!("Power tuning target is not supported on Antminer stock firmware")
}
TuningTarget::HashRate(_) => {
anyhow::bail!("Hashrate tuning target is not supported on Antminer stock firmware")
}
TuningTarget::Preset(_) => {
anyhow::bail!("Preset tuning target is not supported on Antminer stock firmware")
}
};
let pre = self.web.get_miner_conf().await?;
let Some(miner_conf) = miner_conf_with_miner_mode(&pre, mode) else {
anyhow::bail!("No Antminer mining mode field found in miner config")
};
self.web.set_miner_conf(miner_conf).await?;
Ok(true)
}
fn parse_tuning_config(
&self,
data: &HashMap<ConfigField, Value>,
) -> anyhow::Result<TuningConfig> {
data.get(&ConfigField::Tuning)
.and_then(miner_conf_mining_mode)
.map(|mode| TuningConfig::new(TuningTarget::MiningMode(mode)))
.ok_or_else(|| anyhow::anyhow!("No Antminer mining mode found in tuning config"))
}
fn supports_tuning_config(&self) -> bool {
true
}
}
#[async_trait]
impl SupportsFanConfig for AntMinerV2020 {
async fn set_fan_config(&self, config: FanConfig) -> anyhow::Result<bool> {
let pre = self.web.get_miner_conf().await?;
self.web
.set_miner_conf(miner_conf_with_fan_config(&pre, config))
.await?;
Ok(true)
}
fn parse_fan_config(&self, data: &HashMap<ConfigField, Value>) -> anyhow::Result<FanConfig> {
let fan = data
.get(&ConfigField::Fan)
.ok_or_else(|| anyhow::anyhow!("No fan config data"))?;
let manual = fan
.get("bitmain-fan-ctrl")
.and_then(bool_from_value)
.unwrap_or(false);
let fan_speed = fan
.get("bitmain-fan-pwm")
.and_then(u64_from_value)
.unwrap_or(100);
if manual {
Ok(FanConfig::manual(fan_speed))
} else {
Ok(FanConfig::auto(0.0, Some(fan_speed)))
}
}
fn supports_fan_config(&self) -> bool {
true
}
}
impl SupportsTemperatureConfig for AntMinerV2020 {}
impl GetTuningPercent for AntMinerV2020 {}
impl SetTuningPercent for AntMinerV2020 {}
impl SupportsPresets for AntMinerV2020 {}
#[cfg(test)]
mod tests {
use asic_rs_core::data::device::HashAlgorithm;
use std::sync::Arc;
use anyhow::{self, Context};
use asic_rs_core::test::{api::MockAPIClient, util::get_miner};
use asic_rs_makes_antminer::models::AntMinerModel;
use super::*;
use crate::test::json::v2020::{
AM_DEVS, AM_POOLS, AM_STATS, AM_SUMMARY, AM_SYSTEM_INFO, AM_VERSION,
};
#[test]
fn unknown_models_infer_algo_from_family_letter() {
// Round 13 #5: a model outside asic-rs' alias table must still resolve a
// sensible algorithm from its Antminer family letter instead of Unknown.
assert_eq!(infer_antminer_algo("ANTMINER Z15J"), HashAlgorithm::Equihash);
assert_eq!(infer_antminer_algo("Z9"), HashAlgorithm::Equihash);
assert_eq!(infer_antminer_algo("ANTMINER L15"), HashAlgorithm::Scrypt);
assert_eq!(infer_antminer_algo("ANTMINER S23"), HashAlgorithm::SHA256);
assert_eq!(infer_antminer_algo("ANTMINER T23"), HashAlgorithm::SHA256);
// Ambiguous / unrelated families stay Unknown (K-series spans three
// algorithms; a bare unknown string has no family).
assert_eq!(infer_antminer_algo("ANTMINER KS7"), HashAlgorithm::Unknown);
assert_eq!(infer_antminer_algo("WHATSMINER M30"), HashAlgorithm::Unknown);
}
#[test]
fn set_miner_conf_payload_matches_cgi_contract_for_pause_resume() {
let pre = json!({
"pools": [
{"url": "stratum+tcp://pool1.example:3333", "user": "worker.1", "pass": "x"},
{"url": "stratum+tcp://pool2.example:3333", "user": "worker.2", "pass": "x"},
{"url": "stratum+tcp://pool3.example:3333", "user": "worker.3", "pass": "x"}
],
"bitmain-fan-ctrl": true,
"bitmain-fan-pwm": "70",
"bitmain-work-mode": "0",
"bitmain-freq-level": "100",
"api-listen": true
});
assert_eq!(
miner_conf_with_miner_mode(&pre, MinerMode::Sleep).unwrap(),
json!({
"pools": [
{"url": "stratum+tcp://pool1.example:3333", "user": "worker.1", "pass": "x"},
{"url": "stratum+tcp://pool2.example:3333", "user": "worker.2", "pass": "x"},
{"url": "stratum+tcp://pool3.example:3333", "user": "worker.3", "pass": "x"}
],
"bitmain-fan-ctrl": true,
"bitmain-fan-pwm": "70",
"freq-level": "100",
"miner-mode": 1,
"bitmain-work-mode": 1
})
);
assert_eq!(
miner_conf_with_miner_mode(&pre, MinerMode::Normal).unwrap()["miner-mode"],
json!(0)
);
}
/// An L9 is a Scrypt miner reporting in MH/s. Before this was wired up it
/// came back as a SHA-256 miner and every figure was read as GH/s, putting
/// the hashrate out by a factor of 1000.
#[tokio::test]
async fn scrypt_model_is_read_in_the_unit_it_reports() {
let miner = AntMinerV2020::new(IpAddr::from([127, 0, 0, 1]), AntMinerModel::L9);
let mut results = HashMap::new();
results.insert(
MinerCommand::RPC {
command: "summary",
parameters: None,
},
json!({ "SUMMARY": [{ "MHS 5s": 16200.0, "MHS av": 16150.0 }] }),
);
results.insert(
MinerCommand::RPC {
command: "stats",
parameters: None,
},
json!({
"STATS": [
{},
{
"rate_unit": "MH",
"total_rateideal": 16000.0,
"chain_rate1": 5400.0,
"chain_rate2": 5400.0,
"chain_rate3": 5400.0
}
]
}),
);
let mock_api = MockAPIClient::new(results);
let mut collector = DataCollector::new_with_client(&miner, &mock_api);
let miner_data = miner.parse_data(collector.collect_all().await);
let hashrate = miner_data.hashrate.expect("hashrate");
assert_eq!(hashrate.algo, HashAlgorithm::Scrypt);
assert_mega_hash(hashrate, 16200.0);
let expected = miner_data.expected_hashrate.expect("expected hashrate");
assert_eq!(expected.algo, HashAlgorithm::Scrypt);
assert_mega_hash(expected, 16000.0);
let board = miner_data.hashboards[0].hashrate.clone().expect("board 0");
assert_eq!(board.algo, HashAlgorithm::Scrypt);
assert_mega_hash(board, 5400.0);
}
#[track_caller]
fn assert_mega_hash(hashrate: HashRate, expected: f64) {
let value = hashrate.as_unit(HashRateUnit::MegaHash).value;
assert!(
(value - expected).abs() < 1e-6,
"expected {expected} MH/s, got {value}"
);
}
#[tokio::test]
async fn test_antminer() {
let miner = AntMinerV2020::new(IpAddr::from([127, 0, 0, 1]), AntMinerModel::S19Pro);
let mut results = HashMap::new();
let stats_cmd = MinerCommand::RPC {
command: "stats",
parameters: None,
};
let version_cmd = MinerCommand::RPC {
command: "version",
parameters: None,
};
let summary_cmd = MinerCommand::RPC {
command: "summary",
parameters: None,
};
let system_info_cmd = MinerCommand::WebAPI {
command: "get_system_info",
parameters: None,
};
let devs_cmd = MinerCommand::RPC {
command: "devs",
parameters: None,
};
let pools_cmd = MinerCommand::RPC {
command: "pools",
parameters: None,
};
results.insert(stats_cmd, Value::from_str(AM_STATS).unwrap());
results.insert(version_cmd, Value::from_str(AM_VERSION).unwrap());
results.insert(summary_cmd, Value::from_str(AM_SUMMARY).unwrap());
results.insert(system_info_cmd, Value::from_str(AM_SYSTEM_INFO).unwrap());
results.insert(devs_cmd, Value::from_str(AM_DEVS).unwrap());
results.insert(pools_cmd, Value::from_str(AM_POOLS).unwrap());
let mock_api = MockAPIClient::new(results);
let mut collector = DataCollector::new_with_client(&miner, &mock_api);
let data = collector.collect_all().await;
let miner_data = miner.parse_data(data);
assert_eq!(miner_data.ip.to_string(), "127.0.0.1".to_owned());
assert_eq!(
miner_data.firmware_version.as_deref(),
Some("FR-1.12(251009-S21)")
);
assert_eq!(miner_data.hashboards.len(), 3);
assert_eq!(miner_data.light_flashing, None);
assert_eq!(miner_data.fans.len(), 4);
assert_eq!(
miner_data.expected_hashrate.unwrap(),
HashRate {
value: 110.0,
unit: HashRateUnit::TeraHash,
algo: HashAlgorithm::SHA256,
}
);
assert_eq!(
miner_data.hashrate.unwrap(),
HashRate {
value: 110.56689,
unit: HashRateUnit::TeraHash,
algo: HashAlgorithm::SHA256,
}
);
// Cumulative share stats from cgminer summary (round 19 #10, T2).
let shares = miner_data.share_summary.expect("share summary");
assert_eq!(shares.difficulty_accepted, Some(1305083904.0));
assert_eq!(shares.difficulty_rejected, Some(2490368.0));
assert_eq!(shares.stale_shares, Some(1));
assert_eq!(shares.found_blocks, Some(0));
}
#[tokio::test]
#[ignore = "requires live miner; set MINER_IP"]
async fn parse_data_live_test_auto_detect() -> anyhow::Result<()> {
let ip_str = std::env::var("MINER_IP").context("MINER_IP is not set")?;
let ip =
IpAddr::from_str(&ip_str).with_context(|| format!("invalid MINER_IP: {ip_str}"))?;
let miner = get_miner(ip, Arc::new(AntMinerStockFirmware::default()))
.await?
.context("no miner detected at MINER_IP")?;
let miner_data = miner.get_data().await;
let mut miner_data_print = miner_data.clone();
for hashboard in &mut miner_data_print.hashboards {
hashboard.chips.clear();
}
println!("data {}", serde_json::to_string_pretty(&miner_data_print)?);
println!(
"pools {}",
serde_json::to_string_pretty(&miner.get_pools_config().await?)?
);
assert_eq!(miner_data.ip, ip);
assert!(miner_data.timestamp > 0);
assert!(!miner_data.schema_version.is_empty());
Ok(())
}
}