zc2 0.0.47

P2P compute broker with yen-denominated billing, WAL, and broker mesh support
//! The signed `zc bench node` report.
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>,
    /// MemTotal per NUMA node (Linux). Additive: absent when unknown.
    #[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,
}

/// Signs the exact bytes of the serialised report; verifiers check those bytes.
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);
    }
}