use serde::{Deserialize, Serialize};
use super::fingerprint::HardwareFingerprint;
use crate::broker::node_identity::NodeKey;
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct CpuMetrics {
pub gflops_f32: f64,
pub gflops_f64: f64,
pub gflops_f32_1t: f64,
pub mem_bw_gbps: f64,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct DiskMetrics {
pub write_mbps: f64,
pub read_mbps: f64,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct NetMetrics {
pub hub_rtt_ms: Option<f64>,
pub peer_rtt_ms_p50: Option<f64>,
pub mbps: Option<f64>,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct GpuMetrics {
pub vendor: String,
pub model: String,
pub uuid: String,
pub tflops_f32: f64,
pub tflops_f16: f64,
pub mem_bw_gbps: f64,
pub vram_bytes: u64,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct BenchReport {
pub suite: String,
pub zc_version: String,
pub zc_git: Option<String>,
pub node_pubkey: String,
pub fingerprint: HardwareFingerprint,
pub fingerprint_sha256: String,
pub measured_at: String,
pub duration_ms: u64,
pub partial: bool,
pub cpu: Option<CpuMetrics>,
pub disk: Option<DiskMetrics>,
pub net: Option<NetMetrics>,
pub gpus: Vec<GpuMetrics>,
pub skipped: Vec<String>,
pub cpu_units: f64,
pub gpu_units: Option<f64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub numa_mem: Vec<super::fingerprint::NumaNodeMem>,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct SignedReport {
pub report_json: String,
pub signature: String,
}
pub fn sign(report: &BenchReport, key: &NodeKey) -> SignedReport {
let report_json = serde_json::to_string(report).expect("report serialises");
SignedReport {
signature: key.sign(report_json.as_bytes()),
report_json,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::broker::node_identity::{verify_sig, NodeKey};
fn sample(key: &NodeKey) -> BenchReport {
BenchReport {
suite: crate::bench_node::SUITE.into(),
zc_version: "0.0.35".into(),
zc_git: Some("abc1234".into()),
node_pubkey: key.public_b64(),
fingerprint: crate::bench_node::fingerprint::HardwareFingerprint {
cpu_model: "x86_64".into(),
physical_cores: 8,
logical_cores: 16,
ram_bytes: 1 << 35,
gpus: vec![],
},
fingerprint_sha256: "0".repeat(64),
measured_at: "2026-10-03T00:00:00Z".into(),
duration_ms: 1000,
partial: false,
cpu: Some(CpuMetrics {
gflops_f32: 800.0,
gflops_f64: 400.0,
gflops_f32_1t: 60.0,
mem_bw_gbps: 40.0,
}),
disk: None,
net: None,
gpus: vec![],
skipped: vec!["gpu: no driver".into()],
cpu_units: 8.0,
gpu_units: None,
numa_mem: vec![],
}
}
#[test]
fn signature_verifies_over_the_exact_report_json_bytes() {
let key = NodeKey::generate();
let s = sign(&sample(&key), &key);
assert!(verify_sig(
&key.public_b64(),
s.report_json.as_bytes(),
&s.signature
));
}
#[test]
fn any_byte_change_breaks_the_signature() {
let key = NodeKey::generate();
let s = sign(&sample(&key), &key);
let tampered = s.report_json.replace("800", "900");
assert_ne!(tampered, s.report_json);
assert!(!verify_sig(
&key.public_b64(),
tampered.as_bytes(),
&s.signature
));
}
#[test]
fn report_json_round_trips() {
let key = NodeKey::generate();
let r = sample(&key);
let back: BenchReport = serde_json::from_str(&sign(&r, &key).report_json).unwrap();
assert_eq!(back, r);
}
}