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, 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<&crate::hub_allocation::HubAllocation>,
presence: 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.to_payload());
}
if let Some(p) = presence {
body.insert("presence".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(),
presence(node_pubkey, agent_dir.as_deref()),
);
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);
}
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()
}
fn fetch_roster_body(api_url: &str, api_key: &str) -> Result<String, 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()));
}
resp.into_body().read_to_string().map_err(|e| e.to_string())
}
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)>;
pub fn fetch_roster_full(
api_url: &str,
api_key: &str,
) -> Result<(RosterEntries, RosterEndpoints), String> {
let body = fetch_roster_body(api_url, api_key)?;
Ok((parse_roster(&body), parse_endpoints(&body)))
}
#[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)
}
pub fn obtain_voucher(
api_url: &str,
api_key: &str,
budget_credits: f64,
) -> Result<(String, String), String> {
let endpoint = format!("{}/api/broker/voucher", base(api_url));
let payload = serde_json::json!({ "budget_credits": budget_credits }).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())?;
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))
}
pub fn redeem_voucher(
api_url: &str,
api_key: &str,
task_nonce: &str,
actual_cost: f64,
) -> Result<bool, 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())?;
if resp.status().as_u16() != 200 {
return Err(format!("redeem_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())?;
Ok(v.get("redeemed").and_then(|r| r.as_bool()).unwrap_or(false))
}
#[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()),
))
.unwrap();
assert_eq!(body["presence"], p);
assert_eq!(body["node_pubkey"], pk.as_str());
}
#[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).unwrap();
let req = h.join().unwrap();
assert!(req.starts_with("POST /api/broker/voucher"));
assert!(req.contains("budget_credits"));
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());
}
}