mod.rs (17427B)
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 33 #[derive(Deserialize)] 34 #[serde(deny_unknown_fields)] 35 struct Details { 36 content: Value, 37 identifier: String, 38 title: String, 39 summary: String, 40 published_at: u64, 41 location: String, 42 price: Price, 43 quantity: Option<Quantity>, 44 status: String, 45 images: Vec<Image>, 46 } 47 #[derive(Deserialize)] 48 #[serde(deny_unknown_fields)] 49 struct Price { 50 amount: String, 51 currency: String, 52 unit: String, 53 } 54 #[derive(Deserialize)] 55 #[serde(deny_unknown_fields)] 56 struct Quantity { 57 amount: String, 58 unit: String, 59 } 60 #[derive(Deserialize)] 61 #[serde(deny_unknown_fields)] 62 struct Image { 63 bytes_utf8: String, 64 url: String, 65 media_type: String, 66 uploaded_at: u64, 67 dimensions: String, 68 } 69 70 fn text(recipe: &Value) -> String { 71 if let Some(value) = recipe.get("value").and_then(Value::as_str) { 72 assert_eq!(recipe.as_object().unwrap().len(), 1); 73 value.to_owned() 74 } else { 75 assert_eq!(recipe.as_object().unwrap().len(), 2); 76 let character = recipe["repeat"].as_str().unwrap(); 77 assert_eq!(character.chars().count(), 1); 78 let count = usize::try_from(recipe["count"].as_u64().unwrap()).unwrap(); 79 assert!(count <= 262_144, "fixture recipe exceeds tooling bound"); 80 character.repeat(count) 81 } 82 } 83 84 fn details(input: &Value) -> FoodAvailabilityDetails { 85 let input: Details = serde_json::from_value(input.clone()).unwrap(); 86 let images = input 87 .images 88 .iter() 89 .map(|image| { 90 let bytes = image.bytes_utf8.as_bytes(); 91 let media_type = MediaType::parse(&image.media_type).unwrap(); 92 let verified = BlobDescriptor::new( 93 BlobUrl::parse(&image.url).unwrap(), 94 Sha256::digest(bytes), 95 u64::try_from(bytes.len()).unwrap(), 96 media_type.clone(), 97 image.uploaded_at, 98 ) 99 .unwrap() 100 .approve_reference() 101 .unwrap() 102 .verify_bytes(bytes, &media_type) 103 .unwrap(); 104 FoodAvailabilityImage::new( 105 AuthoredImage::try_from_verified_descriptor(verified).unwrap(), 106 FoodImageDimensions::parse(&image.dimensions).unwrap(), 107 ) 108 }) 109 .collect(); 110 FoodAvailabilityDetails::new(FoodAvailabilityDetailsParts { 111 content: FoodContent::new(text(&input.content)).unwrap(), 112 identifier: FoodIdentifier::parse(&input.identifier).unwrap(), 113 title: FoodText::new(input.title).unwrap(), 114 summary: FoodText::new(input.summary).unwrap(), 115 published_at: FoodPublishedAt::new(input.published_at).unwrap(), 116 location: FoodText::new(input.location).unwrap(), 117 price: FoodPrice::new( 118 input.price.amount, 119 FoodCurrency::parse(&input.price.currency).unwrap(), 120 FoodUnit::parse(&input.price.unit).unwrap(), 121 ) 122 .unwrap(), 123 quantity: input.quantity.map(|quantity| { 124 FoodQuantity::new(quantity.amount, FoodUnit::parse(&quantity.unit).unwrap()).unwrap() 125 }), 126 status: FoodAvailabilityStatus::parse(&input.status).unwrap(), 127 images, 128 }) 129 .unwrap() 130 } 131 132 fn envelope(value: &Value) -> EventEnvelope { 133 let raw = serde_json::to_string(value).unwrap(); 134 let wire = Nip01EventWire::parse_json(&raw).unwrap(); 135 wire.verify_id().unwrap(); 136 let event = wire.into_envelope().unwrap(); 137 // Check every signed field after the real wire parser, before admission. 138 assert_eq!(event.id_hex(), value["id"].as_str().unwrap()); 139 assert_eq!(event.author().to_hex(), value["pubkey"].as_str().unwrap()); 140 assert_eq!( 141 event.created_at_u64(), 142 value["created_at"].as_u64().unwrap() 143 ); 144 assert_eq!(u64::from(event.kind_u32()), value["kind"].as_u64().unwrap()); 145 assert_eq!(json!(event.tags_as_vec()), value["tags"]); 146 assert_eq!(event.content(), value["content"].as_str().unwrap()); 147 event 148 } 149 150 fn verified(value: &Value) -> RadrootsSignatureVerifiedEvent { 151 verify_nip01_event(envelope(value)).unwrap() 152 } 153 154 fn partition(value: ClassifiedListingPartition) -> &'static str { 155 match value { 156 ClassifiedListingPartition::FocusedFoodAvailability => "focused_food_availability", 157 ClassifiedListingPartition::OperationalListing => "operational_listing", 158 ClassifiedListingPartition::GenericNip99 => "generic_nip99", 159 ClassifiedListingPartition::Ambiguous => "ambiguous", 160 } 161 } 162 163 fn projection(value: &RadrootsInboundFoodAvailabilityProjection) -> Value { 164 let images: Vec<_> = value 165 .images() 166 .iter() 167 .map(|image| { 168 let dimensions = image 169 .dimensions() 170 .map(|size| json!({"width":size.width(),"height":size.height()})); 171 json!({ 172 "raw_tag":image.raw_tag(),"url":image.url(),"dimensions":dimensions, 173 "diagnostics":image.diagnostics().iter().map(|d|d.code()).collect::<Vec<_>>(), 174 "qualifies":image.qualifies() 175 }) 176 }) 177 .collect(); 178 json!({ 179 "content":value.content().as_str(),"identifier":value.identifier().as_str(), 180 "title":value.title().as_str(),"summary":value.summary().as_str(), 181 "published_at":value.published_at().as_u64(),"location":value.location().as_str(), 182 "price":{"amount":value.price().amount(),"currency":value.price().currency().as_str(),"unit":value.price().unit().as_str()}, 183 "quantity":value.quantity().map(|q|json!({"amount":q.amount(),"unit":q.unit().as_str()})), 184 "status":value.status().as_str(),"images":images, 185 "diagnostics":value.diagnostics().iter().map(|d|d.code()).collect::<Vec<_>>() 186 }) 187 } 188 189 fn authored_error(error: &RadrootsFoodAvailabilityEncodeError) -> Value { 190 match error { 191 RadrootsFoodAvailabilityEncodeError::Domain(FoodAvailabilityError::PublishedAtFuture { 192 published_at, 193 created_at, 194 }) => { 195 json!({"code":error.code(),"message":error.to_string(),"published_at":published_at,"created_at":created_at}) 196 } 197 RadrootsFoodAvailabilityEncodeError::EventWireTooLarge { max, actual } => { 198 json!({"code":error.code(),"message":error.to_string(),"max":max,"actual":actual}) 199 } 200 _ => json!({"code":error.code(),"message":error.to_string()}), 201 } 202 } 203 204 pub(super) fn actual(vector: &Value) -> Value { 205 let kind = vector["kind"].as_str().unwrap(); 206 let input = &vector["input"]; 207 match kind { 208 "food_availability.build_authored_draft.valid" 209 | "food_availability.build_authored_draft.invalid" => { 210 let details = details(&input["details"]); 211 let created_at = input["created_at"].as_u64().unwrap(); 212 match authored_food_availability_to_wire_parts(&details, created_at) { 213 Ok(wire) => { 214 assert_eq!( 215 wire.tags, 216 authored_food_availability_build_tags(&details, created_at).unwrap() 217 ); 218 if vector["expected"]["wire_parts"] 219 .get("content_length") 220 .is_some() 221 { 222 json!({"wire_parts":{"kind":wire.kind,"content_length":wire.content.len(),"tags":wire.tags}}) 223 } else { 224 json!({"wire_parts":{"kind":wire.kind,"content":wire.content,"tags":wire.tags}}) 225 } 226 } 227 Err(error) => json!({"error":authored_error(&error)}), 228 } 229 } 230 "food_availability.project_verified_event.valid" 231 | "food_availability.project_verified_event.invalid" => { 232 let event = verified(&input["event"]); 233 match project_verified_food_availability_event(&event) { 234 Ok(RadrootsFoodAvailabilityProjectionOutcome::Focused(value)) 235 if vector["expected"].get("projection").is_some() => 236 { 237 json!({"outcome":"focused","event_id":event.event().id_hex(),"projection":projection(&value)}) 238 } 239 Ok(RadrootsFoodAvailabilityProjectionOutcome::Focused(value)) => { 240 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()}) 241 } 242 Ok(RadrootsFoodAvailabilityProjectionOutcome::Excluded(value)) => { 243 json!({"outcome":"excluded","event_id":event.event().id_hex(),"partition":partition(value)}) 244 } 245 Ok(_) => panic!("unqualified projection outcome"), 246 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}), 247 } 248 } 249 "food_availability.verify_and_admit_event.valid" 250 | "food_availability.verify_and_admit_event.invalid" => { 251 match verify_and_admit_food_availability_event(envelope(&input["event"])) { 252 Ok(RadrootsFoodAvailabilityAdmissionOutcome::Admitted(event)) => { 253 json!({"outcome":"admitted","event_id":event.event().id_hex(),"projection":projection(event.projection())}) 254 } 255 Ok(RadrootsFoodAvailabilityAdmissionOutcome::Excluded(event)) => { 256 json!({"outcome":"excluded","event_id":event.event().id_hex(),"partition":partition(event.partition())}) 257 } 258 Ok(_) => panic!("unqualified admission outcome"), 259 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}), 260 } 261 } 262 "food_availability.validate_revision.valid" 263 | "food_availability.validate_revision.invalid" => { 264 let previous = verified(&input["previous"]); 265 let current = verified(&input["current"]); 266 match validate_food_availability_revision(&previous, ¤t) { 267 Ok(()) => json!({"result":"accepted","current_event_id":current.event().id_hex()}), 268 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}), 269 } 270 } 271 _ => panic!("unqualified vector kind {kind}"), 272 } 273 } 274 275 #[derive(Deserialize)] 276 #[serde(deny_unknown_fields)] 277 pub(super) struct WebTemplate { 278 id: String, 279 created_at: u64, 280 wire_parts: WebParts, 281 summary: String, 282 } 283 #[derive(Deserialize)] 284 #[serde(deny_unknown_fields)] 285 struct WebParts { 286 kind: u32, 287 content: String, 288 tags: Vec<Vec<String>>, 289 } 290 291 pub(super) fn consume_template(template: &WebTemplate) -> Result<Value, String> { 292 if template.id.is_empty() 293 || template.id.len() > 128 294 || template.created_at > 9_007_199_254_740_991 295 || template.wire_parts.kind != 30402 296 || template.wire_parts.content.len() > 16 * 1024 297 || template.wire_parts.tags.len() > 9 298 { 299 return Err("unsupported bounded website template".into()); 300 } 301 let value = |name: &str| -> Result<&str, String> { 302 let tags = template 303 .wire_parts 304 .tags 305 .iter() 306 .filter(|tag| tag.first().is_some_and(|key| key == name)) 307 .collect::<Vec<_>>(); 308 match tags.as_slice() { 309 [tag] if tag.len() == 2 => Ok(tag[1].as_str()), 310 _ => Err("invalid website singleton tag".into()), 311 } 312 }; 313 let price_tags = template 314 .wire_parts 315 .tags 316 .iter() 317 .filter(|tag| tag.first().is_some_and(|key| key == "price")) 318 .collect::<Vec<_>>(); 319 let price = match price_tags.as_slice() { 320 [tag] if tag.len() == 3 => *tag, 321 _ => return Err("invalid website price tag".into()), 322 }; 323 let quantity_tags = template 324 .wire_parts 325 .tags 326 .iter() 327 .filter(|tag| tag.first().is_some_and(|key| key == "radroots:quantity")) 328 .collect::<Vec<_>>(); 329 let quantity = match quantity_tags.as_slice() { 330 [] => None, 331 [tag] if tag.len() == 3 => Some( 332 FoodQuantity::new( 333 &tag[1], 334 FoodUnit::parse(&tag[2]).map_err(|error| error.to_string())?, 335 ) 336 .map_err(|error| error.to_string())?, 337 ), 338 _ => return Err("invalid website quantity tag".into()), 339 }; 340 if value("summary")? != template.summary { 341 return Err("website review summary differs from public template".into()); 342 } 343 // Actual pinned public constructors and codec consume the website fields. 344 // No synthetic signature, signer, native runtime or private key is involved. 345 let details = FoodAvailabilityDetails::new(FoodAvailabilityDetailsParts { 346 content: FoodContent::new(&template.wire_parts.content) 347 .map_err(|error| error.to_string())?, 348 identifier: FoodIdentifier::parse(value("d")?).map_err(|error| error.to_string())?, 349 title: FoodText::new(value("title")?).map_err(|error| error.to_string())?, 350 summary: FoodText::new(value("summary")?).map_err(|error| error.to_string())?, 351 published_at: FoodPublishedAt::parse(value("published_at")?) 352 .map_err(|error| error.to_string())?, 353 location: FoodText::new(value("location")?).map_err(|error| error.to_string())?, 354 price: FoodPrice::new( 355 &price[1], 356 FoodCurrency::parse(&price[2]).map_err(|error| error.to_string())?, 357 FoodUnit::parse(value("radroots:price_unit")?).map_err(|error| error.to_string())?, 358 ) 359 .map_err(|error| error.to_string())?, 360 quantity, 361 status: FoodAvailabilityStatus::parse(value("status")?) 362 .map_err(|error| error.to_string())?, 363 images: Vec::new(), 364 }) 365 .map_err(|error| error.to_string())?; 366 let actual = authored_food_availability_to_wire_parts(&details, template.created_at) 367 .map_err(|error| error.to_string())?; 368 if actual.kind != template.wire_parts.kind 369 || actual.content != template.wire_parts.content 370 || actual.tags != template.wire_parts.tags 371 { 372 return Err("website wire parts differ from actual pinned Rust codec".into()); 373 } 374 Ok( 375 json!({"id":template.id,"result":"accepted","wire_parts":{"kind":actual.kind,"content":actual.content,"tags":actual.tags}}), 376 ) 377 } 378 379 pub(super) fn boundary(row: &Value) -> Value { 380 let value = row["value"].as_str().unwrap(); 381 let (identifier, timestamp) = match row["kind"].as_str().unwrap() { 382 "timestamp" => match FoodPublishedAt::parse(value) { 383 Ok(timestamp) => ("boundary-id", timestamp.as_u64()), 384 Err(error) => return json!({"result":"rejected","code":error.code()}), 385 }, 386 "identifier" => (value, 1), 387 _ => panic!("unknown boundary kind"), 388 }; 389 let recipe = json!({ 390 "content":{"value":"Fresh food available locally."}, 391 "identifier":identifier,"title":"Fresh food","summary":"Fresh food available locally.", 392 "published_at":timestamp,"location":"Victoria", 393 "price":{"amount":"1","currency":"CAD","unit":"g"}, 394 "quantity":null,"status":"active","images":[] 395 }); 396 let wire = authored_food_availability_to_wire_parts(&details(&recipe), timestamp).unwrap(); 397 let tag = |name: &str| { 398 wire.tags 399 .iter() 400 .find(|tag| tag.first().is_some_and(|key| key == name)) 401 .unwrap()[1] 402 .clone() 403 }; 404 if row["kind"] == "identifier" { 405 json!({"result":"accepted","identifier":tag("d")}) 406 } else { 407 json!({"result":"accepted","timestamp":timestamp.to_string(),"encoded_published_at":tag("published_at")}) 408 } 409 }