main.rs (21448B)
1 // SPDX-License-Identifier: GPL-3.0-only 2 // Public fixture recipes and API readback follow Radroots Lib revision 3 // 189c49b74b4bafc142b00b76b296477931139e72's food_availability_conformance.rs 4 // (MIT OR Apache-2.0). This tool never signs or receives private keys. 5 #![forbid(unsafe_code)] 6 7 use radroots_blossom::{BlobDescriptor, BlobUrl, MediaType, Sha256}; 8 use radroots_event::envelope::EventEnvelope; 9 use radroots_event::food::availability::{ 10 FoodAvailabilityDetails, FoodAvailabilityDetailsParts, FoodAvailabilityError, 11 FoodAvailabilityImage, FoodAvailabilityStatus, FoodContent, FoodCurrency, FoodIdentifier, 12 FoodImageDimensions, FoodPrice, FoodPublishedAt, FoodQuantity, FoodText, FoodUnit, 13 }; 14 use radroots_event::listing::classified::ClassifiedListingPartition; 15 use radroots_event::media::AuthoredImage; 16 use radroots_event::wire::Nip01EventWire; 17 use radroots_event_codec::admission::food_availability::{ 18 RadrootsFoodAvailabilityAdmissionOutcome, validate_food_availability_revision, 19 verify_and_admit_food_availability_event, 20 }; 21 use radroots_event_codec::decode::food_availability::{ 22 RadrootsFoodAvailabilityProjectionOutcome, RadrootsInboundFoodAvailabilityProjection, 23 project_verified_food_availability_event, 24 }; 25 use radroots_event_codec::encode::food_availability::{ 26 RadrootsFoodAvailabilityEncodeError, authored_food_availability_build_tags, 27 authored_food_availability_to_wire_parts, 28 }; 29 use radroots_event_codec::verify::{RadrootsSignatureVerifiedEvent, verify_nip01_event}; 30 use serde::Deserialize; 31 use serde_json::{Value, json}; 32 use std::{collections::BTreeSet, fs, path::Path}; 33 34 const REVISION: &str = "189c49b74b4bafc142b00b76b296477931139e72"; 35 const SOURCE: &str = include_str!("../../source_profile.v1.json"); 36 const SOURCE_SHA256: &str = "dede1eb1f682ecd548e8cd3ccb251d298762e504e2588a73528e5f7a5b9eff21"; 37 38 #[derive(Deserialize)] 39 #[serde(deny_unknown_fields)] 40 struct Details { 41 content: Value, 42 identifier: String, 43 title: String, 44 summary: String, 45 published_at: u64, 46 location: String, 47 price: Price, 48 quantity: Option<Quantity>, 49 status: String, 50 images: Vec<Image>, 51 } 52 #[derive(Deserialize)] 53 #[serde(deny_unknown_fields)] 54 struct Price { 55 amount: String, 56 currency: String, 57 unit: String, 58 } 59 #[derive(Deserialize)] 60 #[serde(deny_unknown_fields)] 61 struct Quantity { 62 amount: String, 63 unit: String, 64 } 65 #[derive(Deserialize)] 66 #[serde(deny_unknown_fields)] 67 struct Image { 68 bytes_utf8: String, 69 url: String, 70 media_type: String, 71 uploaded_at: u64, 72 dimensions: String, 73 } 74 75 fn text(recipe: &Value) -> String { 76 if let Some(value) = recipe.get("value").and_then(Value::as_str) { 77 assert_eq!(recipe.as_object().unwrap().len(), 1); 78 value.to_owned() 79 } else { 80 assert_eq!(recipe.as_object().unwrap().len(), 2); 81 let character = recipe["repeat"].as_str().unwrap(); 82 assert_eq!(character.chars().count(), 1); 83 let count = usize::try_from(recipe["count"].as_u64().unwrap()).unwrap(); 84 assert!(count <= 262_144, "fixture recipe exceeds tooling bound"); 85 character.repeat(count) 86 } 87 } 88 89 fn details(input: &Value) -> FoodAvailabilityDetails { 90 let input: Details = serde_json::from_value(input.clone()).unwrap(); 91 let images = input 92 .images 93 .iter() 94 .map(|image| { 95 let bytes = image.bytes_utf8.as_bytes(); 96 let media_type = MediaType::parse(&image.media_type).unwrap(); 97 let verified = BlobDescriptor::new( 98 BlobUrl::parse(&image.url).unwrap(), 99 Sha256::digest(bytes), 100 u64::try_from(bytes.len()).unwrap(), 101 media_type.clone(), 102 image.uploaded_at, 103 ) 104 .unwrap() 105 .approve_reference() 106 .unwrap() 107 .verify_bytes(bytes, &media_type) 108 .unwrap(); 109 FoodAvailabilityImage::new( 110 AuthoredImage::try_from_verified_descriptor(verified).unwrap(), 111 FoodImageDimensions::parse(&image.dimensions).unwrap(), 112 ) 113 }) 114 .collect(); 115 FoodAvailabilityDetails::new(FoodAvailabilityDetailsParts { 116 content: FoodContent::new(text(&input.content)).unwrap(), 117 identifier: FoodIdentifier::parse(&input.identifier).unwrap(), 118 title: FoodText::new(input.title).unwrap(), 119 summary: FoodText::new(input.summary).unwrap(), 120 published_at: FoodPublishedAt::new(input.published_at).unwrap(), 121 location: FoodText::new(input.location).unwrap(), 122 price: FoodPrice::new( 123 input.price.amount, 124 FoodCurrency::parse(&input.price.currency).unwrap(), 125 FoodUnit::parse(&input.price.unit).unwrap(), 126 ) 127 .unwrap(), 128 quantity: input.quantity.map(|quantity| { 129 FoodQuantity::new(quantity.amount, FoodUnit::parse(&quantity.unit).unwrap()).unwrap() 130 }), 131 status: FoodAvailabilityStatus::parse(&input.status).unwrap(), 132 images, 133 }) 134 .unwrap() 135 } 136 137 fn envelope(value: &Value) -> EventEnvelope { 138 let raw = serde_json::to_string(value).unwrap(); 139 let wire = Nip01EventWire::parse_json(&raw).unwrap(); 140 wire.verify_id().unwrap(); 141 let event = wire.into_envelope().unwrap(); 142 // Check every signed field after the real wire parser, before admission. 143 assert_eq!(event.id_hex(), value["id"].as_str().unwrap()); 144 assert_eq!(event.author().to_hex(), value["pubkey"].as_str().unwrap()); 145 assert_eq!( 146 event.created_at_u64(), 147 value["created_at"].as_u64().unwrap() 148 ); 149 assert_eq!(u64::from(event.kind_u32()), value["kind"].as_u64().unwrap()); 150 assert_eq!(json!(event.tags_as_vec()), value["tags"]); 151 assert_eq!(event.content(), value["content"].as_str().unwrap()); 152 event 153 } 154 155 fn verified(value: &Value) -> RadrootsSignatureVerifiedEvent { 156 verify_nip01_event(envelope(value)).unwrap() 157 } 158 159 fn partition(value: ClassifiedListingPartition) -> &'static str { 160 match value { 161 ClassifiedListingPartition::FocusedFoodAvailability => "focused_food_availability", 162 ClassifiedListingPartition::OperationalListing => "operational_listing", 163 ClassifiedListingPartition::GenericNip99 => "generic_nip99", 164 ClassifiedListingPartition::Ambiguous => "ambiguous", 165 } 166 } 167 168 fn projection(value: &RadrootsInboundFoodAvailabilityProjection) -> Value { 169 let images: Vec<_> = value 170 .images() 171 .iter() 172 .map(|image| { 173 let dimensions = image 174 .dimensions() 175 .map(|size| json!({"width":size.width(),"height":size.height()})); 176 json!({ 177 "raw_tag":image.raw_tag(),"url":image.url(),"dimensions":dimensions, 178 "diagnostics":image.diagnostics().iter().map(|d|d.code()).collect::<Vec<_>>(), 179 "qualifies":image.qualifies() 180 }) 181 }) 182 .collect(); 183 json!({ 184 "content":value.content().as_str(),"identifier":value.identifier().as_str(), 185 "title":value.title().as_str(),"summary":value.summary().as_str(), 186 "published_at":value.published_at().as_u64(),"location":value.location().as_str(), 187 "price":{"amount":value.price().amount(),"currency":value.price().currency().as_str(),"unit":value.price().unit().as_str()}, 188 "quantity":value.quantity().map(|q|json!({"amount":q.amount(),"unit":q.unit().as_str()})), 189 "status":value.status().as_str(),"images":images, 190 "diagnostics":value.diagnostics().iter().map(|d|d.code()).collect::<Vec<_>>() 191 }) 192 } 193 194 fn authored_error(error: &RadrootsFoodAvailabilityEncodeError) -> Value { 195 match error { 196 RadrootsFoodAvailabilityEncodeError::Domain(FoodAvailabilityError::PublishedAtFuture { 197 published_at, 198 created_at, 199 }) => { 200 json!({"code":error.code(),"message":error.to_string(),"published_at":published_at,"created_at":created_at}) 201 } 202 RadrootsFoodAvailabilityEncodeError::EventWireTooLarge { max, actual } => { 203 json!({"code":error.code(),"message":error.to_string(),"max":max,"actual":actual}) 204 } 205 _ => json!({"code":error.code(),"message":error.to_string()}), 206 } 207 } 208 209 fn actual(vector: &Value) -> Value { 210 let kind = vector["kind"].as_str().unwrap(); 211 let input = &vector["input"]; 212 match kind { 213 "food_availability.build_authored_draft.valid" 214 | "food_availability.build_authored_draft.invalid" => { 215 let details = details(&input["details"]); 216 let created_at = input["created_at"].as_u64().unwrap(); 217 match authored_food_availability_to_wire_parts(&details, created_at) { 218 Ok(wire) => { 219 assert_eq!( 220 wire.tags, 221 authored_food_availability_build_tags(&details, created_at).unwrap() 222 ); 223 if vector["expected"]["wire_parts"] 224 .get("content_length") 225 .is_some() 226 { 227 json!({"wire_parts":{"kind":wire.kind,"content_length":wire.content.len(),"tags":wire.tags}}) 228 } else { 229 json!({"wire_parts":{"kind":wire.kind,"content":wire.content,"tags":wire.tags}}) 230 } 231 } 232 Err(error) => json!({"error":authored_error(&error)}), 233 } 234 } 235 "food_availability.project_verified_event.valid" 236 | "food_availability.project_verified_event.invalid" => { 237 let event = verified(&input["event"]); 238 match project_verified_food_availability_event(&event) { 239 Ok(RadrootsFoodAvailabilityProjectionOutcome::Focused(value)) 240 if vector["expected"].get("projection").is_some() => 241 { 242 json!({"outcome":"focused","event_id":event.event().id_hex(),"projection":projection(&value)}) 243 } 244 Ok(RadrootsFoodAvailabilityProjectionOutcome::Focused(value)) => { 245 json!({"outcome":"focused","event_id":event.event().id_hex(),"image_count":value.images().len(),"diagnostics":value.diagnostics().iter().map(|d|d.code()).collect::<Vec<_>>(),"first_raw_tag":value.images().first().unwrap().raw_tag(),"last_raw_tag":value.images().last().unwrap().raw_tag()}) 246 } 247 Ok(RadrootsFoodAvailabilityProjectionOutcome::Excluded(value)) => { 248 json!({"outcome":"excluded","event_id":event.event().id_hex(),"partition":partition(value)}) 249 } 250 Ok(_) => panic!("unqualified projection outcome"), 251 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}), 252 } 253 } 254 "food_availability.verify_and_admit_event.valid" 255 | "food_availability.verify_and_admit_event.invalid" => { 256 match verify_and_admit_food_availability_event(envelope(&input["event"])) { 257 Ok(RadrootsFoodAvailabilityAdmissionOutcome::Admitted(event)) => { 258 json!({"outcome":"admitted","event_id":event.event().id_hex(),"projection":projection(event.projection())}) 259 } 260 Ok(RadrootsFoodAvailabilityAdmissionOutcome::Excluded(event)) => { 261 json!({"outcome":"excluded","event_id":event.event().id_hex(),"partition":partition(event.partition())}) 262 } 263 Ok(_) => panic!("unqualified admission outcome"), 264 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}), 265 } 266 } 267 "food_availability.validate_revision.valid" 268 | "food_availability.validate_revision.invalid" => { 269 let previous = verified(&input["previous"]); 270 let current = verified(&input["current"]); 271 match validate_food_availability_revision(&previous, ¤t) { 272 Ok(()) => json!({"result":"accepted","current_event_id":current.event().id_hex()}), 273 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}), 274 } 275 } 276 _ => panic!("unqualified vector kind {kind}"), 277 } 278 } 279 280 fn reject_private_fields(value: &Value) { 281 match value { 282 Value::Object(fields) => { 283 for (key, value) in fields { 284 let key = key.to_ascii_lowercase(); 285 assert!( 286 !key.contains("secret") 287 && !key.contains("private_key") 288 && !key.contains("privkey") 289 ); 290 reject_private_fields(value); 291 } 292 } 293 Value::Array(values) => values.iter().for_each(reject_private_fields), 294 _ => (), 295 } 296 } 297 298 fn generate() -> Value { 299 assert_eq!(Sha256::digest(SOURCE.as_bytes()).to_hex(), SOURCE_SHA256); 300 let source: Value = serde_json::from_str(SOURCE).unwrap(); 301 reject_private_fields(&source); 302 let vectors = source["vectors"].as_array().unwrap(); 303 assert_eq!(vectors.len(), 40); 304 let mut ids = BTreeSet::new(); 305 let rows: Vec<_> = vectors.iter().map(|vector| { 306 let id = vector["id"].as_str().unwrap(); 307 assert!(ids.insert(id)); 308 let result = actual(vector); 309 assert_eq!(result, vector["expected"], "public Rust oracle drift: {id}"); 310 let mut signed_wires = serde_json::Map::new(); 311 for field in ["event", "previous", "current"] { 312 if let Some(event) = vector["input"].get(field) { 313 let raw = serde_json::to_string(event).unwrap(); 314 let wire = Nip01EventWire::parse_json(&raw).unwrap(); 315 wire.verify_id().unwrap(); 316 // Preserve exact parsed signature bytes even for the invalid-signature control. 317 assert_eq!(wire.sig, event["sig"].as_str().unwrap()); 318 signed_wires.insert(field.to_owned(), Value::String(raw)); 319 } 320 } 321 let unsigned_wire_parts = if vector["kind"].as_str().unwrap().starts_with("food_availability.build_authored_draft.") { 322 let details = details(&vector["input"]["details"]); 323 authored_food_availability_to_wire_parts(&details, vector["input"]["created_at"].as_u64().unwrap()) 324 .ok().map(|wire| json!({"kind":wire.kind,"content":wire.content,"tags":wire.tags})) 325 } else { 326 None 327 }; 328 json!({"id":id,"kind":vector["kind"],"input":vector["input"],"expected":result,"signed_wires":signed_wires,"unsigned_wire_parts":unsigned_wire_parts}) 329 }).collect(); 330 json!({ 331 "schema_version":1,"repository":"https://github.com/radrootslabs/lib", 332 "revision":REVISION,"source_path":"contracts/conformance/vectors/food_availability/profile.v1.json", 333 "source_sha256":SOURCE_SHA256,"contract_version":source["contract_version"], 334 "suite":source["suite"],"key_policy":"keyless verification of public signed fixtures; unsigned authoring only", 335 "vectors":rows 336 }) 337 } 338 339 fn encoded() -> String { 340 serde_json::to_string_pretty(&generate()).unwrap() + "\n" 341 } 342 343 #[derive(Deserialize)] 344 #[serde(deny_unknown_fields)] 345 struct WebTemplate { 346 id: String, 347 created_at: u64, 348 wire_parts: WebParts, 349 summary: String, 350 } 351 #[derive(Deserialize)] 352 #[serde(deny_unknown_fields)] 353 struct WebParts { 354 kind: u32, 355 content: String, 356 tags: Vec<Vec<String>>, 357 } 358 359 fn consume_template(template: &WebTemplate) -> Result<Value, String> { 360 if template.id.is_empty() 361 || template.id.len() > 128 362 || template.created_at > 9_007_199_254_740_991 363 || template.wire_parts.kind != 30402 364 || template.wire_parts.content.len() > 16 * 1024 365 || template.wire_parts.tags.len() > 9 366 { 367 return Err("unsupported bounded website template".into()); 368 } 369 let value = |name: &str| -> Result<&str, String> { 370 let tags = template 371 .wire_parts 372 .tags 373 .iter() 374 .filter(|tag| tag.first().is_some_and(|key| key == name)) 375 .collect::<Vec<_>>(); 376 match tags.as_slice() { 377 [tag] if tag.len() == 2 => Ok(tag[1].as_str()), 378 _ => Err("invalid website singleton tag".into()), 379 } 380 }; 381 let price_tags = template 382 .wire_parts 383 .tags 384 .iter() 385 .filter(|tag| tag.first().is_some_and(|key| key == "price")) 386 .collect::<Vec<_>>(); 387 let price = match price_tags.as_slice() { 388 [tag] if tag.len() == 3 => *tag, 389 _ => return Err("invalid website price tag".into()), 390 }; 391 let quantity_tags = template 392 .wire_parts 393 .tags 394 .iter() 395 .filter(|tag| tag.first().is_some_and(|key| key == "radroots:quantity")) 396 .collect::<Vec<_>>(); 397 let quantity = match quantity_tags.as_slice() { 398 [] => None, 399 [tag] if tag.len() == 3 => Some( 400 FoodQuantity::new( 401 &tag[1], 402 FoodUnit::parse(&tag[2]).map_err(|error| error.to_string())?, 403 ) 404 .map_err(|error| error.to_string())?, 405 ), 406 _ => return Err("invalid website quantity tag".into()), 407 }; 408 if value("summary")? != template.summary { 409 return Err("website review summary differs from public template".into()); 410 } 411 // Actual pinned public constructors and codec consume the website fields. 412 // No synthetic signature, signer, native runtime or private key is involved. 413 let details = FoodAvailabilityDetails::new(FoodAvailabilityDetailsParts { 414 content: FoodContent::new(&template.wire_parts.content) 415 .map_err(|error| error.to_string())?, 416 identifier: FoodIdentifier::parse(value("d")?).map_err(|error| error.to_string())?, 417 title: FoodText::new(value("title")?).map_err(|error| error.to_string())?, 418 summary: FoodText::new(value("summary")?).map_err(|error| error.to_string())?, 419 published_at: FoodPublishedAt::parse(value("published_at")?) 420 .map_err(|error| error.to_string())?, 421 location: FoodText::new(value("location")?).map_err(|error| error.to_string())?, 422 price: FoodPrice::new( 423 &price[1], 424 FoodCurrency::parse(&price[2]).map_err(|error| error.to_string())?, 425 FoodUnit::parse(value("radroots:price_unit")?).map_err(|error| error.to_string())?, 426 ) 427 .map_err(|error| error.to_string())?, 428 quantity, 429 status: FoodAvailabilityStatus::parse(value("status")?) 430 .map_err(|error| error.to_string())?, 431 images: Vec::new(), 432 }) 433 .map_err(|error| error.to_string())?; 434 let actual = authored_food_availability_to_wire_parts(&details, template.created_at) 435 .map_err(|error| error.to_string())?; 436 if actual.kind != template.wire_parts.kind 437 || actual.content != template.wire_parts.content 438 || actual.tags != template.wire_parts.tags 439 { 440 return Err("website wire parts differ from actual pinned Rust codec".into()); 441 } 442 Ok( 443 json!({"id":template.id,"result":"accepted","wire_parts":{"kind":actual.kind,"content":actual.content,"tags":actual.tags}}), 444 ) 445 } 446 447 fn consume_templates(path: &Path) -> Value { 448 let metadata = fs::symlink_metadata(path).expect("website input metadata"); 449 assert!(metadata.file_type().is_file() && metadata.len() <= 1024 * 1024); 450 let raw = fs::read(path).expect("website input read"); 451 assert_eq!(u64::try_from(raw.len()).unwrap(), metadata.len()); 452 let templates: Vec<WebTemplate> = 453 serde_json::from_slice(&raw).expect("website template schema"); 454 assert!(!templates.is_empty() && templates.len() <= 32); 455 let results = templates 456 .iter() 457 .map(|template| { 458 consume_template(template) 459 .unwrap_or_else(|error| panic!("website template rejected: {error}")) 460 }) 461 .collect::<Vec<_>>(); 462 json!({"revision":REVISION,"source":"actual_public_food_constructors_and_unsigned_codec","signing":"NOT_RUN_NO_KEYS","templates":results}) 463 } 464 465 fn main() { 466 let args: Vec<_> = std::env::args().skip(1).collect(); 467 match args.as_slice() { 468 [mode] if mode == "--emit" => print!("{}", encoded()), 469 [mode] if mode == "--check" => { 470 let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../corpus.v1.json"); 471 let expected = fs::read_to_string(path).unwrap(); 472 assert!(expected.len() <= 1024 * 1024); 473 assert_eq!(encoded(), expected, "checked corpus is stale"); 474 println!("PASS40 pinned public Rust vectors and exact generated bytes; no signing"); 475 } 476 [mode, path] if mode == "--consume-web" => { 477 println!( 478 "{}", 479 serde_json::to_string_pretty(&consume_templates(Path::new(path))).unwrap() 480 ); 481 } 482 _ => panic!("expected --emit, --check or --consume-web <bounded-json-file>"), 483 } 484 } 485 486 #[cfg(test)] 487 mod tests { 488 use super::*; 489 490 #[test] 491 fn checked_corpus_matches_actual_pinned_rust_readback() { 492 let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../corpus.v1.json"); 493 assert_eq!(encoded(), fs::read_to_string(path).unwrap()); 494 assert_eq!( 495 encoded(), 496 encoded(), 497 "repeated generation must be byte-identical" 498 ); 499 } 500 }