app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

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, &current) {
    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 }