use std::time::Duration;
fn base(api_url: &str) -> &str {
api_url.trim_end_matches('/')
}
#[cfg(test)]
fn register_payload(
node_pubkey: &str,
mesh_endpoint: Option<&str>,
runtime: Option<&crate::broker::deploy::RuntimeProbe>,
hub_allocation: Option<&crate::hub_allocation::HubAllocation>,
) -> String {
register_payload_with(
node_pubkey,
mesh_endpoint,
runtime,
hub_allocation.map(|a| a.to_payload()),
None,
None,
)
}
pub fn node_key_fp(node_pubkey_b64: &str) -> Option<String> {
use base64::Engine;
let raw = base64::engine::general_purpose::STANDARD
.decode(node_pubkey_b64.trim())
.ok()?;
let d = ring::digest::digest(&ring::digest::SHA256, &raw);
Some(hex::encode(&d.as_ref()[..8]))
}
pub fn presence(
node_pubkey_b64: &str,
agent_dir: Option<&std::path::Path>,
) -> Option<serde_json::Value> {
let fp = node_key_fp(node_pubkey_b64)?;
#[cfg(unix)]
let app = agent_dir
.and_then(|d| crate::agent::files::running_app(d, crate::agent::supervisor::is_alive));
#[cfg(not(unix))]
let app: Option<(String, String)> = agent_dir.and(None);
let (app, app_version) = match app {
Some((a, v)) => (Some(a), Some(v)),
None => (None, None),
};
Some(serde_json::json!({
"node_key_fp": fp,
"agent_version": env!("CARGO_PKG_VERSION"),
"app_version": app_version,
"app": app,
"os": std::env::consts::OS,
"arch": std::env::consts::ARCH,
}))
}
fn register_payload_with(
node_pubkey: &str,
mesh_endpoint: Option<&str>,
runtime: Option<&crate::broker::deploy::RuntimeProbe>,
hub_allocation: Option<serde_json::Value>,
presence: Option<serde_json::Value>,
policy: Option<serde_json::Value>,
) -> String {
let mut body = serde_json::Map::new();
body.insert("node_pubkey".to_string(), node_pubkey.into());
if let Some(ep) = mesh_endpoint {
body.insert("mesh_endpoint".to_string(), ep.into());
}
if let Some(probe) = runtime {
body.insert("deploy_runtime".to_string(), probe.available.into());
body.insert("deploy_runtime_detail".to_string(), probe.to_json());
}
if let Ok(v) = serde_json::to_value(crate::build_id::current()) {
body.insert("zc_build".to_string(), v);
}
if let Some(a) = hub_allocation {
body.insert("hub_allocation".to_string(), a);
}
if let Some(p) = presence {
body.insert("presence".to_string(), p);
}
if let Some(p) = policy {
body.insert("policy".to_string(), p);
}
serde_json::Value::Object(body).to_string()
}
pub fn register_node(
api_url: &str,
api_key: &str,
node_pubkey: &str,
mesh_endpoint: Option<&str>,
runtime: Option<&crate::broker::deploy::RuntimeProbe>,
) -> Result<(), String> {
let endpoint = format!("{}/api/broker/node/register", base(api_url));
let state_dir = crate::credentials::dir();
let hub_allocation = state_dir.as_deref().and_then(crate::hub_allocation::load);
let agent_dir = state_dir.as_deref().map(|d| d.join("agent"));
let payload = register_payload_with(
node_pubkey,
mesh_endpoint,
runtime,
hub_allocation
.as_ref()
.map(crate::hub_allocation::usage::payload_with_used),
presence(node_pubkey, agent_dir.as_deref()),
state_dir.as_deref().and_then(crate::policy::sync::payload),
);
let resp = ureq::post(&endpoint)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.header("X-Broker-Api-Key", api_key)
.header("Content-Type", "application/json")
.send(payload.as_str())
.map_err(|e| e.to_string())?;
let code = resp.status().as_u16();
if (200..300).contains(&code) {
let body = resp.into_body().read_to_string().unwrap_or_default();
apply_register_response(&body);
if let Some(dir) = state_dir.as_deref() {
crate::hub_allocation::apply_register_response(dir, &body);
crate::policy::sync::apply_reply_logged(dir, &body);
}
Ok(())
} else {
Err(format!("register_node HTTP {code}"))
}
}
pub fn apply_register_response(body: &str) {
crate::broker::placement::set_hub_default(parse_default_placement(body));
}
fn parse_default_placement(body: &str) -> Option<crate::broker::placement::Placement> {
let v: serde_json::Value = serde_json::from_str(body).ok()?;
match v.get("default_placement")? {
serde_json::Value::Null => None,
serde_json::Value::String(s) => match crate::broker::placement::Placement::parse(s) {
Ok(p) => Some(p),
Err(e) => {
eprintln!("warning: hub default_placement ignored: {e}");
None
}
},
other => {
eprintln!("warning: hub default_placement ignored: not a string: {other}");
None
}
}
}
pub fn parse_roster(body: &str) -> Vec<(String, bool)> {
let v: serde_json::Value = match serde_json::from_str(body) {
Ok(v) => v,
Err(_) => return Vec::new(),
};
v.as_array()
.map(|arr| {
arr.iter()
.filter_map(|e| {
let pk = e.get("node_pubkey")?.as_str()?.to_string();
let revoked = e.get("revoked").and_then(|r| r.as_bool()).unwrap_or(false);
Some((pk, revoked))
})
.collect()
})
.unwrap_or_default()
}
pub fn parse_endpoints(body: &str) -> Vec<(String, String)> {
let v: serde_json::Value = match serde_json::from_str(body) {
Ok(v) => v,
Err(_) => return Vec::new(),
};
v.as_array()
.map(|arr| {
arr.iter()
.filter_map(|e| {
let pk = e.get("node_pubkey")?.as_str()?.to_string();
let ep = e.get("mesh_endpoint")?.as_str()?.to_string();
Some((pk, ep))
})
.collect()
})
.unwrap_or_default()
}
pub const ROSTER_GENERATED_AT_HEADER: &str = "X-Roster-Generated-At";
pub fn parse_generated_at(v: &str) -> Option<u64> {
let v = v.trim();
if let Ok(n) = v.parse::<u64>() {
return Some(n);
}
if let Ok(f) = v.parse::<f64>() {
return (f.is_finite() && f >= 0.0).then_some(f as u64);
}
chrono::DateTime::parse_from_rfc3339(v)
.ok()
.and_then(|d| u64::try_from(d.timestamp()).ok())
}
fn fetch_roster_response(api_url: &str, api_key: &str) -> Result<(String, Option<u64>), String> {
let endpoint = format!("{}/api/broker/node/roster", base(api_url));
let resp = ureq::get(&endpoint)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.header("X-Broker-Api-Key", api_key)
.call()
.map_err(|e| e.to_string())?;
if resp.status().as_u16() != 200 {
return Err(format!("fetch_roster HTTP {}", resp.status().as_u16()));
}
let generated_at = resp
.headers()
.get(ROSTER_GENERATED_AT_HEADER)
.and_then(|v| v.to_str().ok())
.and_then(parse_generated_at);
let body = resp
.into_body()
.read_to_string()
.map_err(|e| e.to_string())?;
Ok((body, generated_at))
}
fn fetch_roster_body(api_url: &str, api_key: &str) -> Result<String, String> {
fetch_roster_response(api_url, api_key).map(|(b, _)| b)
}
pub fn parse_node_builds(body: &str) -> Vec<(String, crate::build_id::BuildId)> {
let Ok(v) = serde_json::from_str::<serde_json::Value>(body) else {
return Vec::new();
};
v.as_array()
.map(|arr| {
arr.iter()
.filter_map(|e| {
let pk = e.get("node_pubkey")?.as_str()?.to_string();
let build = match e.get("zc_build")? {
serde_json::Value::String(s) if !s.trim().is_empty() => {
crate::build_id::BuildId {
version: s.trim().to_string(),
..Default::default()
}
}
o @ serde_json::Value::Object(_) => {
serde_json::from_value::<crate::build_id::BuildId>(o.clone()).ok()?
}
_ => return None,
};
build.is_known().then_some((pk, build))
})
.collect()
})
.unwrap_or_default()
}
#[derive(Debug, Clone)]
pub struct RosterSnapshot {
pub entries: RosterEntries,
pub endpoints: RosterEndpoints,
pub generated_at: Option<u64>,
pub builds: Vec<(String, crate::build_id::BuildId)>,
}
impl RosterSnapshot {
pub fn freshness_at(&self, fetched_at: u64) -> u64 {
self.generated_at.map_or(fetched_at, |g| g.min(fetched_at))
}
}
pub fn fetch_roster_snapshot(api_url: &str, api_key: &str) -> Result<RosterSnapshot, String> {
let (body, generated_at) = fetch_roster_response(api_url, api_key)?;
Ok(RosterSnapshot {
entries: parse_roster(&body),
endpoints: parse_endpoints(&body),
generated_at,
builds: parse_node_builds(&body),
})
}
pub fn fetch_roster(api_url: &str, api_key: &str) -> Result<Vec<(String, bool)>, String> {
Ok(parse_roster(&fetch_roster_body(api_url, api_key)?))
}
pub type RosterEntries = Vec<(String, bool)>;
pub type RosterEndpoints = Vec<(String, String)>;
#[derive(Debug, Clone, PartialEq)]
pub struct OwnerMeshIps {
pub ips: Vec<std::net::IpAddr>,
pub complete: bool,
}
pub fn parse_owner_ips(body: &str) -> Option<OwnerMeshIps> {
let v: serde_json::Value = serde_json::from_str(body).ok()?;
let ips = v
.get("ips")?
.as_array()?
.iter()
.filter_map(|ip| ip.as_str()?.parse().ok())
.collect();
let complete = v.get("complete").and_then(|c| c.as_bool()).unwrap_or(false);
Some(OwnerMeshIps { ips, complete })
}
pub fn fetch_owner_ips(api_url: &str, api_key: &str) -> Result<OwnerMeshIps, String> {
let endpoint = format!("{}/api/broker/mesh/owner-ips", base(api_url));
let resp = ureq::get(&endpoint)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.header("X-Broker-Api-Key", api_key)
.call()
.map_err(|e| e.to_string())?;
let code = resp.status().as_u16();
if code != 200 {
return Err(format!("fetch_owner_ips HTTP {code}"));
}
let body = resp
.into_body()
.read_to_string()
.map_err(|e| e.to_string())?;
parse_owner_ips(&body).ok_or_else(|| "fetch_owner_ips: unexpected response body".to_string())
}
pub fn parse_voucher_pubkeys(body: &str) -> Result<Vec<String>, String> {
let v: serde_json::Value = serde_json::from_str(body).map_err(|e| e.to_string())?;
let mut keys: Vec<String> = Vec::new();
if let Some(arr) = v.get("pubkeys").and_then(|p| p.as_array()) {
for k in arr.iter().filter_map(|k| k.as_str()) {
if !k.is_empty() && !keys.iter().any(|e| e == k) {
keys.push(k.to_string());
}
}
}
if keys.is_empty() {
if let Some(k) = v
.get("pubkey")
.and_then(|p| p.as_str())
.filter(|k| !k.is_empty())
{
keys.push(k.to_string());
}
}
if keys.is_empty() {
return Err("voucher pubkey response missing `pubkey`/`pubkeys`".into());
}
Ok(keys)
}
pub fn fetch_voucher_pubkey(api_url: &str) -> Result<Vec<String>, String> {
let endpoint = format!("{}/api/broker/voucher/pubkey", base(api_url));
let resp = ureq::get(&endpoint)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.call()
.map_err(|e| e.to_string())?;
if resp.status().as_u16() != 200 {
return Err(format!(
"fetch_voucher_pubkey HTTP {}",
resp.status().as_u16()
));
}
let text = resp
.into_body()
.read_to_string()
.map_err(|e| e.to_string())?;
parse_voucher_pubkeys(&text)
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct VoucherBinding {
pub requester_node: Option<String>,
pub offer_hash: Option<String>,
}
fn voucher_payload(budget: f64, binding: &VoucherBinding) -> String {
let mut body = serde_json::Map::new();
body.insert("budget".to_string(), serde_json::json!(budget));
if let Some(n) = &binding.requester_node {
body.insert("requester_node".to_string(), n.clone().into());
}
if let Some(h) = &binding.offer_hash {
body.insert("offer_hash".to_string(), h.clone().into());
}
serde_json::Value::Object(body).to_string()
}
pub fn obtain_voucher(
api_url: &str,
api_key: &str,
budget: f64,
binding: &VoucherBinding,
) -> Result<(String, String), String> {
let endpoint = format!("{}/api/broker/voucher", base(api_url));
let payload = voucher_payload(budget, binding);
let resp = ureq::post(&endpoint)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.header("X-Broker-Api-Key", api_key)
.header("Content-Type", "application/json")
.send(payload.as_str())
.map_err(|e| e.to_string())?;
if resp.status().as_u16() != 200 {
return Err(format!("obtain_voucher HTTP {}", resp.status().as_u16()));
}
let text = resp
.into_body()
.read_to_string()
.map_err(|e| e.to_string())?;
let v: serde_json::Value = serde_json::from_str(&text).map_err(|e| e.to_string())?;
let signed_json = v
.get("signed_json")
.and_then(|s| s.as_str())
.ok_or("voucher response missing `signed_json`")?
.to_string();
let sig = v
.get("sig")
.and_then(|s| s.as_str())
.ok_or("voucher response missing `sig`")?
.to_string();
Ok((signed_json, sig))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RedeemOutcome {
Redeemed,
AlreadyRedeemed,
Refused,
}
pub fn redeem_voucher_outcome(
api_url: &str,
api_key: &str,
task_nonce: &str,
actual_cost: f64,
) -> Result<RedeemOutcome, String> {
let endpoint = format!("{}/api/broker/voucher/redeem", base(api_url));
let payload =
serde_json::json!({ "task_nonce": task_nonce, "actual_cost": actual_cost }).to_string();
let resp = ureq::post(&endpoint)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.header("X-Broker-Api-Key", api_key)
.header("Content-Type", "application/json")
.send(payload.as_str())
.map_err(|e| e.to_string())?;
let status = resp.status().as_u16();
if status == 409 {
return Ok(RedeemOutcome::Refused);
}
if status != 200 {
return Err(format!("redeem_voucher HTTP {status}"));
}
let text = resp
.into_body()
.read_to_string()
.map_err(|e| e.to_string())?;
parse_redeem_body(&text)
}
fn parse_redeem_body(text: &str) -> Result<RedeemOutcome, String> {
let v: serde_json::Value = serde_json::from_str(text).map_err(|e| e.to_string())?;
Ok(
if v.get("redeemed").and_then(|r| r.as_bool()).unwrap_or(false) {
RedeemOutcome::Redeemed
} else {
RedeemOutcome::AlreadyRedeemed
},
)
}
#[cfg(test)]
mod tests {
#[test]
fn register_response_default_placement_cases() {
use crate::broker::placement::{resolve, Placement};
apply_register_response(r#"{"default_placement":"best_price_mesh"}"#);
assert_eq!(resolve(None), (Placement::BestPriceMesh, "hub_default"));
assert_eq!(resolve(Some(Placement::MeshOnly)).0, Placement::MeshOnly);
apply_register_response(r#"{"default_placement":"mesh_only"}"#);
assert_eq!(resolve(None).0, Placement::MeshOnly);
apply_register_response(r#"{"default_placement":null}"#);
assert_eq!(resolve(None), (Placement::OwnFirst, "default"));
apply_register_response(r#"{"default_placement":"own_first"}"#);
assert_eq!(resolve(None), (Placement::OwnFirst, "hub_default"));
apply_register_response(r#"{"ok":true}"#);
assert_eq!(resolve(None), (Placement::OwnFirst, "default"));
apply_register_response(r#"{"default_placement":"mesh_only"}"#);
apply_register_response(r#"{"default_placement":"cheapest"}"#);
assert_eq!(resolve(None), (Placement::OwnFirst, "default"));
apply_register_response("not json");
assert_eq!(resolve(None), (Placement::OwnFirst, "default"));
}
use super::*;
#[cfg(unix)]
#[test]
fn register_payload_carries_presence_when_given_and_omits_it_otherwise() {
let none: serde_json::Value =
serde_json::from_str(&super::register_payload("PUBKEY", None, None, None)).unwrap();
assert!(none.get("presence").is_none());
let key = crate::broker::node_identity::NodeKey::generate();
let pk = key.public_b64();
let p = super::presence(&pk, None).unwrap();
assert_eq!(
p["node_key_fp"].as_str(),
Some(key.fingerprint().as_str()),
"the node's own fingerprint, as in zc://node-<fp>"
);
assert_eq!(p["agent_version"], env!("CARGO_PKG_VERSION"));
assert_eq!(p["os"], std::env::consts::OS);
assert_eq!(p["arch"], std::env::consts::ARCH);
assert!(p["app"].is_null() && p["app_version"].is_null());
assert!(super::presence("not base64!", None).is_none());
let d = std::env::temp_dir().join(format!("zc-presence-{}", std::process::id()));
std::fs::create_dir_all(&d).unwrap();
std::fs::write(
d.join(crate::agent::files::APP_FILE),
r#"{"v":1,"app":"desktop","app_version":"0.3.1"}"#,
)
.unwrap();
let p = super::presence(&pk, Some(&d)).unwrap();
assert_eq!(
(p["app"].as_str(), p["app_version"].as_str()),
(Some("desktop"), Some("0.3.1"))
);
let _ = std::fs::remove_dir_all(&d);
let body: serde_json::Value = serde_json::from_str(&super::register_payload_with(
&pk,
None,
None,
None,
Some(p.clone()),
None,
))
.unwrap();
assert_eq!(body["presence"], p);
assert_eq!(body["node_pubkey"], pk.as_str());
}
#[test]
fn register_payload_carries_the_policy_only_when_there_is_one() {
let pol = crate::policy::Policy {
revision: 7,
..Default::default()
}
.to_hub_json();
let with: serde_json::Value = serde_json::from_str(&super::register_payload_with(
"PUBKEY",
None,
None,
None,
None,
Some(pol.clone()),
))
.unwrap();
assert_eq!(with["policy"], pol);
assert_eq!(with["policy"]["revision"], 7);
let without: serde_json::Value =
serde_json::from_str(&super::register_payload("PUBKEY", None, None, None)).unwrap();
assert!(without.get("policy").is_none());
}
#[test]
fn register_payload_reports_which_zc_this_node_runs() {
let payload = super::register_payload("PUBKEY", None, None, None);
let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
let build = &v["zc_build"];
assert!(build.is_object(), "zc_build must be sent: {payload}");
assert_eq!(
build["version"],
serde_json::Value::String(crate::build_id::current().version.clone()),
"and must be THIS binary's version"
);
}
#[test]
fn register_payload_omits_mesh_endpoint_key_when_none() {
let payload = super::register_payload("PUBKEY", None, None, None);
let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
assert_eq!(v["node_pubkey"], "PUBKEY");
assert!(
v.get("mesh_endpoint").is_none(),
"mesh_endpoint key must be absent, not null: {payload}"
);
assert!(
!payload.contains("mesh_endpoint"),
"payload must not mention mesh_endpoint at all: {payload}"
);
}
#[test]
fn register_payload_includes_exact_mesh_endpoint_when_some() {
let payload = super::register_payload("PUBKEY", Some("10.13.13.6:9000"), None, None);
let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
assert_eq!(v["node_pubkey"], "PUBKEY");
assert_eq!(v["mesh_endpoint"], "10.13.13.6:9000");
}
fn ok_probe() -> crate::broker::deploy::RuntimeProbe {
use crate::broker::deploy::runtime::*;
classify_probe(
CliOutcome::Exited {
success: true,
stderr: String::new(),
},
&HostFacts {
socket_path: "/var/run/docker.sock".into(),
socket_exists: true,
containerd_socket: false,
},
"2026-10-20T00:00:00Z".into(),
)
}
fn denied_probe() -> crate::broker::deploy::RuntimeProbe {
use crate::broker::deploy::runtime::*;
classify_probe(
CliOutcome::Exited {
success: false,
stderr: "permission denied while trying to connect to the Docker daemon socket"
.into(),
},
&HostFacts {
socket_path: "/var/run/docker.sock".into(),
socket_exists: true,
containerd_socket: false,
},
"2026-10-20T00:00:00Z".into(),
)
}
#[test]
fn register_payload_reports_a_usable_deploy_runtime() {
let payload =
super::register_payload("PUBKEY", Some("10.13.13.6:9000"), Some(&ok_probe()), None);
let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
assert_eq!(v["node_pubkey"], "PUBKEY");
assert_eq!(v["mesh_endpoint"], "10.13.13.6:9000");
assert_eq!(v["deploy_runtime"], true);
assert_eq!(v["deploy_runtime_detail"]["available"], true);
assert_eq!(v["deploy_runtime_detail"]["runtime"], "docker");
assert!(v["deploy_runtime_detail"]["error"].is_null());
}
#[test]
fn register_payload_reports_a_missing_deploy_runtime_as_explicit_false() {
let payload = super::register_payload("PUBKEY", None, Some(&denied_probe()), None);
let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
assert_eq!(
v.get("deploy_runtime"),
Some(&serde_json::Value::Bool(false)),
"deploy_runtime=false must be sent explicitly: {payload}"
);
let d = &v["deploy_runtime_detail"];
assert_eq!(d["available"], false);
assert_eq!(d["error"], "permission_denied");
assert!(d["detail"]
.as_str()
.unwrap()
.contains("/var/run/docker.sock"));
assert!(d["checked_at"].as_str().is_some());
}
#[test]
fn register_payload_omits_deploy_runtime_when_unknown() {
let payload = super::register_payload("PUBKEY", None, None, None);
assert!(
!payload.contains("deploy_runtime"),
"payload must not mention deploy_runtime at all: {payload}"
);
}
#[test]
fn parse_roster_reads_pairs_and_defaults_revoked() {
let body = r#"[
{"node_pubkey":"AAA","revoked":true},
{"node_pubkey":"BBB"},
{"nope":1}
]"#;
let r = parse_roster(body);
assert_eq!(r.len(), 2);
assert_eq!(r[0], ("AAA".to_string(), true));
assert_eq!(r[1], ("BBB".to_string(), false));
}
#[test]
fn parse_roster_handles_garbage() {
assert!(parse_roster("not json").is_empty());
assert!(parse_roster("{}").is_empty());
}
#[test]
fn parses_endpoints_skipping_absent_and_null() {
let body = r#"[
{"node_pubkey":"A","revoked":false,"mesh_endpoint":"10.13.13.6:9000"},
{"node_pubkey":"B","revoked":false,"mesh_endpoint":null},
{"node_pubkey":"C","revoked":false}
]"#;
assert_eq!(
super::parse_endpoints(body),
vec![("A".to_string(), "10.13.13.6:9000".to_string())]
);
}
#[test]
fn parse_roster_still_reads_bodies_without_endpoints() {
let body = r#"[{"node_pubkey":"A","revoked":false}]"#;
assert_eq!(super::parse_roster(body), vec![("A".to_string(), false)]);
assert!(super::parse_endpoints(body).is_empty());
}
#[test]
fn parse_owner_ips_reads_addresses_and_completeness() {
let got =
parse_owner_ips(r#"{"ips":["10.13.13.22","10.13.13.5"],"complete":true}"#).unwrap();
let want: Vec<std::net::IpAddr> = vec![
"10.13.13.22".parse().unwrap(),
"10.13.13.5".parse().unwrap(),
];
assert_eq!(got.ips, want);
assert!(got.complete);
}
#[test]
fn parse_owner_ips_skips_entries_that_are_not_addresses() {
let got = parse_owner_ips(r#"{"ips":["10.13.13.22","zakuro0",7,null],"complete":false}"#)
.unwrap();
assert_eq!(got.ips.len(), 1);
assert!(!got.complete);
}
#[test]
fn parse_owner_ips_reads_a_missing_complete_as_incomplete() {
assert!(!parse_owner_ips(r#"{"ips":[]}"#).unwrap().complete);
}
#[test]
fn parse_owner_ips_rejects_bodies_without_an_ips_array() {
for body in ["not json", "{}", r#"{"ips":"10.13.13.22"}"#, "[]"] {
assert_eq!(parse_owner_ips(body), None, "{body}");
}
}
use std::io::{Read, Write};
use std::net::TcpListener;
fn mock_once(status: u16, body: &'static str) -> (std::thread::JoinHandle<String>, u16) {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let h = std::thread::spawn(move || {
let (mut s, _) = listener.accept().unwrap();
let mut raw = Vec::new();
let mut buf = [0u8; 2048];
loop {
let n = s.read(&mut buf).unwrap_or(0);
if n == 0 {
break;
}
raw.extend_from_slice(&buf[..n]);
let text = String::from_utf8_lossy(&raw);
if let Some(hdr_end) = text.find("\r\n\r\n") {
let want: usize = text
.lines()
.find_map(|l| {
l.to_ascii_lowercase()
.strip_prefix("content-length:")
.map(|v| v.trim().parse().unwrap_or(0))
})
.unwrap_or(0);
if raw.len() >= hdr_end + 4 + want {
break;
}
}
}
let req = String::from_utf8_lossy(&raw).to_string();
let resp = format!(
"HTTP/1.1 {status} X\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = s.write_all(resp.as_bytes());
req
});
(h, port)
}
#[test]
#[ignore = "network mock; run with --ignored"]
fn fetch_roster_parses_live_response() {
let (h, port) = mock_once(
200,
r#"[{"node_pubkey":"AAA","revoked":false},{"node_pubkey":"BBB","revoked":true}]"#,
);
let url = format!("http://127.0.0.1:{port}");
let roster = fetch_roster(&url, "zk_1_x").unwrap();
let req = h.join().unwrap();
assert!(req.starts_with("GET /api/broker/node/roster"));
assert!(req
.to_ascii_lowercase()
.contains("x-broker-api-key: zk_1_x"));
assert_eq!(roster.len(), 2);
assert_eq!(roster[1], ("BBB".to_string(), true));
}
#[test]
#[ignore = "network mock; run with --ignored"]
fn obtain_voucher_extracts_signed_json_and_sig() {
let (h, port) = mock_once(200, r#"{"signed_json":"{\"v\":1}","sig":"deadbeef"}"#);
let url = format!("http://127.0.0.1:{port}");
let (signed, sig) =
obtain_voucher(&url, "zk_1_x", 5.0, &VoucherBinding::default()).unwrap();
let req = h.join().unwrap();
assert!(req.starts_with("POST /api/broker/voucher"));
assert!(req.contains("budget"));
assert_eq!(signed, "{\"v\":1}");
assert_eq!(sig, "deadbeef");
}
#[test]
fn parse_voucher_pubkeys_single_key_shape() {
let keys = parse_voucher_pubkeys(r#"{"pubkey":"AAA"}"#).unwrap();
assert_eq!(keys, vec!["AAA".to_string()]);
}
#[test]
fn register_payload_carries_hub_allocation_after_zc_build() {
let a = crate::hub_allocation::HubAllocation {
enabled: true,
vram_gb: 8,
ram_gb: 16,
disk_gb: 50,
purpose: vec!["inference".into(), "warmup".into()],
};
let payload = super::register_payload("PUBKEY", None, None, Some(&a));
let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
assert_eq!(
v["hub_allocation"],
serde_json::json!({"enabled": true, "vram_gb": 8, "ram_gb": 16, "disk_gb": 50, "purpose": ["inference", "warmup"]})
);
}
#[test]
fn register_payload_sends_disabled_hub_allocation_and_omits_unset() {
let a = crate::hub_allocation::HubAllocation {
enabled: false,
vram_gb: 0,
ram_gb: 4,
disk_gb: 10,
purpose: vec!["inference".into()],
};
let v: serde_json::Value =
serde_json::from_str(&super::register_payload("PUBKEY", None, None, Some(&a))).unwrap();
assert_eq!(v["hub_allocation"]["enabled"], false);
let none = super::register_payload("PUBKEY", None, None, None);
assert!(!none.contains("hub_allocation"), "{none}");
}
#[test]
fn parse_voucher_pubkeys_set_shape_prefers_pubkeys() {
let keys =
parse_voucher_pubkeys(r#"{"pubkey":"AAA","pubkeys":["AAA","BBB","AAA"]}"#).unwrap();
assert_eq!(keys, vec!["AAA".to_string(), "BBB".to_string()]);
let keys = parse_voucher_pubkeys(r#"{"pubkey":"X","pubkeys":["AAA"]}"#).unwrap();
assert_eq!(keys, vec!["AAA".to_string()]);
}
#[test]
fn parse_voucher_pubkeys_empty_set_falls_back_and_missing_errors() {
let keys = parse_voucher_pubkeys(r#"{"pubkey":"AAA","pubkeys":[]}"#).unwrap();
assert_eq!(keys, vec!["AAA".to_string()]);
assert!(parse_voucher_pubkeys(r#"{}"#).is_err());
assert!(parse_voucher_pubkeys("not json").is_err());
}
#[test]
fn the_voucher_request_carries_the_binding_only_when_there_is_one() {
let plain: serde_json::Value =
serde_json::from_str(&voucher_payload(5.0, &VoucherBinding::default())).unwrap();
assert_eq!(
plain,
serde_json::json!({"budget": 5.0}),
"an old hub sees today's request"
);
let node_only: serde_json::Value = serde_json::from_str(&voucher_payload(
5.0,
&VoucherBinding {
requester_node: Some("0123456789abcdef".into()),
offer_hash: None,
},
))
.unwrap();
assert_eq!(
node_only,
serde_json::json!({"budget": 5.0, "requester_node": "0123456789abcdef"})
);
let both: serde_json::Value = serde_json::from_str(&voucher_payload(
5.0,
&VoucherBinding {
requester_node: Some("0123456789abcdef".into()),
offer_hash: Some("ab".repeat(32)),
},
))
.unwrap();
assert_eq!(both["offer_hash"], "ab".repeat(32));
assert_eq!(both["requester_node"], "0123456789abcdef");
}
#[test]
fn redeem_answers_are_read_as_redeemed_or_already_redeemed() {
assert_eq!(
parse_redeem_body(r#"{"redeemed":true,"commission":0.2}"#),
Ok(RedeemOutcome::Redeemed)
);
assert_eq!(
parse_redeem_body(r#"{"redeemed":false,"reason":"already_redeemed"}"#),
Ok(RedeemOutcome::AlreadyRedeemed)
);
assert_eq!(
parse_redeem_body(r#"{"redeemed":false,"commission":0.0}"#),
Ok(RedeemOutcome::AlreadyRedeemed)
);
assert!(parse_redeem_body("not json").is_err());
}
#[test]
fn the_rosters_generation_time_is_read_in_the_forms_a_hub_may_send() {
assert_eq!(parse_generated_at("1789000000"), Some(1_789_000_000));
assert_eq!(parse_generated_at(" 1789000000.75 "), Some(1_789_000_000));
assert_eq!(
parse_generated_at("2026-11-10T00:00:00Z"),
Some(1_794_268_800)
);
assert_eq!(
parse_generated_at("2026-11-10T09:00:00+09:00"),
Some(1_794_268_800)
);
for bad in ["", "yesterday", "-5", "NaN"] {
assert_eq!(parse_generated_at(bad), None, "{bad:?}");
}
}
#[test]
fn a_roster_ages_from_the_hubs_stamp_when_it_sends_one() {
let snap = |g| RosterSnapshot {
entries: vec![],
endpoints: vec![],
generated_at: g,
builds: vec![],
};
assert_eq!(
snap(None).freshness_at(1_000),
1_000,
"no header: the fetch time"
);
assert_eq!(snap(Some(400)).freshness_at(1_000), 400);
assert_eq!(
snap(Some(9_000)).freshness_at(1_000),
1_000,
"never younger than the fetch"
);
}
#[test]
fn node_builds_come_from_the_roster_when_the_hub_has_them() {
let body = r#"[
{"node_pubkey":"A","revoked":false,"zc_build":{"version":"0.0.47","git":"abc1234","binary_sha256":"ff00"}},
{"node_pubkey":"B","revoked":false,"zc_build":"0.0.46"},
{"node_pubkey":"C","revoked":false,"zc_build":null},
{"node_pubkey":"D","revoked":false},
{"node_pubkey":"E","revoked":false,"zc_build":{}}
]"#;
let got = parse_node_builds(body);
let keys: Vec<&str> = got.iter().map(|(k, _)| k.as_str()).collect();
assert_eq!(keys, vec!["A", "B"]);
assert_eq!(got[0].1.version, "0.0.47");
assert_eq!(got[0].1.git.as_deref(), Some("abc1234"));
assert_eq!(got[1].1.version, "0.0.46");
assert!(parse_node_builds("not json").is_empty());
}
#[test]
fn a_roster_fetch_reads_the_generation_header_and_the_builds() {
use std::io::{Read, Write};
let l = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let url = format!("http://127.0.0.1:{}", l.local_addr().unwrap().port());
let h = std::thread::spawn(move || {
let (mut c, _) = l.accept().unwrap();
let mut raw = Vec::new();
let mut buf = [0u8; 2048];
while !raw.windows(4).any(|w| w == b"\r\n\r\n") {
match c.read(&mut buf) {
Ok(0) | Err(_) => break,
Ok(n) => raw.extend_from_slice(&buf[..n]),
}
}
let body = r#"[{"node_pubkey":"AAA","revoked":false,"mesh_endpoint":"10.0.0.1:9000","zc_build":{"version":"0.0.47"}}]"#;
let resp = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nX-Roster-Generated-At: 1789000000\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = c.write_all(resp.as_bytes());
});
let snap = fetch_roster_snapshot(&url, "zk_1_x").unwrap();
h.join().unwrap();
assert_eq!(snap.generated_at, Some(1_789_000_000));
assert_eq!(snap.entries, vec![("AAA".to_string(), false)]);
assert_eq!(
snap.endpoints,
vec![("AAA".to_string(), "10.0.0.1:9000".to_string())]
);
assert_eq!(snap.builds[0].1.version, "0.0.47");
}
}