use crate::canonical::{compute_capsule_id, JcsError};
use serde_json::{json, Map, Value};
pub const RECORD_TYPE_PADDING: &str = "padding";
pub const PADDING_CONTENT_TYPE: &str = "application/json";
pub const PADDING_EPISTEMIC_TYPE: &str = "producer_claim";
pub const STORE_NONCE_FIELD: &str = "store_nonce";
pub fn fresh_store_nonce() -> String {
use rand_core::RngCore;
let mut bytes = [0u8; 32];
rand_core::OsRng.fill_bytes(&mut bytes);
hex::encode(bytes)
}
pub fn is_padding(record: &Value) -> bool {
record.get("record_type").and_then(Value::as_str) == Some(RECORD_TYPE_PADDING)
}
pub fn check_padding_shape(record: &Value) -> Result<(), String> {
let obj = record
.as_object()
.ok_or_else(|| "padding record is not a JSON object".to_string())?;
const ALLOWED: &[&str] = &[
"capsule_id",
"record_type",
"epistemic_type",
STORE_NONCE_FIELD,
"signature",
"key_id",
];
if let Some(extra) = obj.keys().find(|k| !ALLOWED.contains(&k.as_str())) {
return Err(format!(
"padding record carries {extra:?}; its only content is the store nonce"
));
}
let nonce_ok = obj
.get(STORE_NONCE_FIELD)
.and_then(Value::as_str)
.is_some_and(|n| {
n.len() == 64
&& n.bytes()
.all(|b| b.is_ascii_hexdigit() && !b.is_ascii_uppercase())
});
if !nonce_ok {
return Err("padding record's store_nonce is not 64 lowercase hex".to_string());
}
Ok(())
}
pub fn build_padding_record() -> Result<Value, JcsError> {
let mut body = Map::new();
body.insert("record_type".into(), json!(RECORD_TYPE_PADDING));
body.insert("epistemic_type".into(), json!(PADDING_EPISTEMIC_TYPE));
body.insert(STORE_NONCE_FIELD.into(), json!(fresh_store_nonce()));
let capsule_id = compute_capsule_id(&Value::Object(body.clone()))?;
let mut record = Map::new();
record.insert("capsule_id".into(), json!(capsule_id));
record.extend(body);
Ok(Value::Object(record))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn padding_record_is_well_formed_and_unique() {
let a = build_padding_record().unwrap();
let b = build_padding_record().unwrap();
assert!(is_padding(&a));
check_padding_shape(&a).unwrap();
assert_ne!(a["capsule_id"], b["capsule_id"], "fresh nonce per record");
assert_eq!(
compute_capsule_id(&a).unwrap(),
a["capsule_id"].as_str().unwrap()
);
let mut members: Vec<&str> = a.as_object().unwrap().keys().map(String::as_str).collect();
members.sort_unstable();
assert_eq!(
members,
[
"capsule_id",
"epistemic_type",
"record_type",
STORE_NONCE_FIELD
]
);
}
#[test]
fn shape_check_refuses_links_and_content() {
let mut rec = build_padding_record().unwrap();
rec["chain"] = json!({"parent_capsule_id": "a".repeat(64), "relation": "follows"});
assert!(check_padding_shape(&rec).is_err());
let mut rec = build_padding_record().unwrap();
rec[STORE_NONCE_FIELD] = json!("short");
assert!(check_padding_shape(&rec).is_err());
}
#[test]
fn ordinary_records_are_not_padding() {
assert!(!is_padding(&json!({"capsule_id": "a".repeat(64)})));
assert!(!is_padding(&json!({"record_type": "close"})));
}
#[test]
fn store_nonces_are_64_lowercase_hex_and_fresh() {
let a = fresh_store_nonce();
assert_eq!(a.len(), 64);
assert!(a.bytes().all(|b| matches!(b, b'0'..=b'9' | b'a'..=b'f')));
assert_ne!(a, fresh_store_nonce());
}
}