use serde_json::Value;
use sha2::{Digest, Sha256};
pub fn canonical_json(value: &Value) -> String {
let mut out = String::new();
write_canonical(value, &mut out);
out
}
fn write_canonical(value: &Value, out: &mut String) {
match value {
Value::Object(map) => {
let mut entries: Vec<(&String, &Value)> = map.iter().collect();
entries.sort_by(|a, b| a.0.cmp(b.0));
out.push('{');
for (i, (key, item)) in entries.into_iter().enumerate() {
if i > 0 {
out.push(',');
}
out.push_str(&serde_json::to_string(key).expect("a string serializes"));
out.push(':');
write_canonical(item, out);
}
out.push('}');
}
Value::Array(items) => {
out.push('[');
for (i, item) in items.iter().enumerate() {
if i > 0 {
out.push(',');
}
write_canonical(item, out);
}
out.push(']');
}
scalar => out.push_str(&serde_json::to_string(scalar).expect("a scalar serializes")),
}
}
pub fn hash16(bytes: &[u8]) -> String {
Sha256::digest(bytes)[..8]
.iter()
.map(|b| format!("{b:02x}"))
.collect()
}
pub fn hash16_lines<'a>(hashes: impl IntoIterator<Item = &'a str>) -> String {
let mut text = String::new();
for h in hashes {
text.push_str(h);
text.push('\n');
}
hash16(text.as_bytes())
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn canonical_json_sorts_keys_and_drops_whitespace() {
let v = json!({"b": [3, {"z": 1, "a": null}], "a": "x\"y", "é": true, "Z": 1.5});
assert_eq!(
canonical_json(&v),
r#"{"Z":1.5,"a":"x\"y","b":[3,{"a":null,"z":1}],"é":true}"#
);
}
#[test]
fn canonical_json_ignores_insertion_order() {
let mut a = serde_json::Map::new();
a.insert("one".into(), json!(1));
a.insert("two".into(), json!({"y": 2, "x": 1}));
let mut b = serde_json::Map::new();
b.insert("two".into(), json!({"x": 1, "y": 2}));
b.insert("one".into(), json!(1));
assert_eq!(canonical_json(&Value::Object(a)), canonical_json(&Value::Object(b)));
}
#[test]
fn canonical_json_keeps_array_order() {
assert_ne!(canonical_json(&json!(["a", "b"])), canonical_json(&json!(["b", "a"])));
}
#[test]
fn hash16_is_the_sha256_prefix() {
assert_eq!(hash16(b""), "e3b0c44298fc1c14");
assert_eq!(hash16(b"abc"), "ba7816bf8f01cfea");
}
#[test]
fn hash16_lines_hashes_one_input_per_line() {
assert_eq!(hash16_lines(["ab", "cd"]), hash16(b"ab\ncd\n"));
assert_eq!(hash16_lines([]), hash16(b""));
}
}