lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

private_rumor.rs (5132B)


      1 #![cfg(feature = "private_rumor")]
      2 use radroots_domain::PublicKey;
      3 use radroots_protocol::{
      4     nip01::{EventFields, UnsignedEvent},
      5     private_rumor::{DecodedRumor, RumorWireError},
      6     profile,
      7 };
      8 use serde_json::{Value, json};
      9 
     10 fn author() -> PublicKey {
     11     PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798").unwrap()
     12 }
     13 fn wire(kind: u32, tags: &[Vec<String>], content: &str) -> UnsignedEvent {
     14     UnsignedEvent::encode(
     15         &EventFields {
     16             author: author(),
     17             created_at: 450,
     18             kind,
     19             tags,
     20             content,
     21         },
     22         profile::UNSIGNED_RUMOR_MAX_BYTES,
     23     )
     24     .unwrap()
     25 }
     26 fn error(value: &Value) -> RumorWireError {
     27     DecodedRumor::decode(&serde_json::to_vec(value).unwrap()).unwrap_err()
     28 }
     29 
     30 #[test]
     31 fn identity_checked_unknown_data_preserves_unicode_tags_without_interpreting_them() {
     32     let tags = vec![
     33         vec!["p".into(), "future participant representation".into()],
     34         vec!["x".into(), "東京 🥕\n\\\"".into()],
     35     ];
     36     let encoded = wire(65535, &tags, "e\u{301} and é remain distinct\n🧅");
     37     let value = DecodedRumor::decode(encoded.json().as_bytes()).unwrap();
     38     assert_eq!(value.event_id().into_bytes(), encoded.event_id());
     39     assert_eq!(value.author(), author());
     40     assert_eq!(value.created_at(), 450);
     41     assert_eq!(value.kind(), 65535);
     42     assert!(value.has_tags());
     43     assert_eq!(
     44         value.protected_content(),
     45         "e\u{301} and é remain distinct\n🧅"
     46     );
     47     assert!(
     48         value.retained_bytes()
     49             >= std::mem::size_of::<DecodedRumor>() + value.protected_content().len()
     50     );
     51     assert_eq!(format!("{value:?}"), "DecodedRumor(<redacted>)");
     52 }
     53 
     54 #[test]
     55 fn every_unsigned_field_is_required_closed_canonical_and_duplicate_safe() {
     56     let encoded = wire(8890, &[], "{}");
     57     let value: Value = serde_json::from_str(encoded.json()).unwrap();
     58     for key in ["id", "pubkey", "created_at", "kind", "tags", "content"] {
     59         let mut missing = value.clone();
     60         missing.as_object_mut().unwrap().remove(key);
     61         assert_eq!(error(&missing), RumorWireError::InvalidInput, "{key}");
     62         let duplicate = format!(
     63             "{{{}:{},{}",
     64             serde_json::to_string(key).unwrap(),
     65             value[key],
     66             &encoded.json()[1..]
     67         );
     68         assert_eq!(
     69             DecodedRumor::decode(duplicate.as_bytes()).unwrap_err(),
     70             RumorWireError::InvalidInput,
     71             "{key}"
     72         );
     73     }
     74     for (key, replacement) in [
     75         ("kind", json!(65536)),
     76         ("kind", json!(-1)),
     77         ("kind", json!(1.5)),
     78         ("created_at", json!(253402300800_u64)),
     79         ("created_at", json!("450")),
     80         ("pubkey", json!(author().to_hex().to_uppercase())),
     81         ("id", json!(value["id"].as_str().unwrap().to_uppercase())),
     82         ("tags", json!({})),
     83         ("content", json!({})),
     84     ] {
     85         let mut changed = value.clone();
     86         changed[key] = replacement;
     87         assert_eq!(error(&changed), RumorWireError::InvalidInput, "{key}");
     88     }
     89     let mut extra = value.clone();
     90     extra["future"] = json!(true);
     91     assert_eq!(error(&extra), RumorWireError::InvalidInput);
     92     assert_eq!(
     93         error(&json!(
     94             value.as_object().unwrap().values().collect::<Vec<_>>()
     95         )),
     96         RumorWireError::InvalidInput
     97     );
     98 }
     99 
    100 #[test]
    101 fn private_tag_shapes_and_original_identity_are_checked_before_returning_data() {
    102     let original = wire(8890, &[], "{}");
    103     let value: Value = serde_json::from_str(original.json()).unwrap();
    104     for tags in [
    105         json!([[]]),
    106         json!([[""]]),
    107         json!([["\n", "x"]]),
    108         json!([["x", 1]]),
    109         json!(["tag"]),
    110     ] {
    111         let mut changed = value.clone();
    112         changed["tags"] = tags;
    113         assert_eq!(error(&changed), RumorWireError::InvalidInput);
    114     }
    115     for key in ["content", "id"] {
    116         let mut changed = value.clone();
    117         changed[key] = if key == "id" {
    118             json!("00".repeat(32))
    119         } else {
    120             json!("changed")
    121         };
    122         assert_eq!(error(&changed), RumorWireError::IdentityMismatch);
    123     }
    124     assert_eq!(
    125         RumorWireError::IdentityMismatch.to_string(),
    126         "rumor identity mismatch"
    127     );
    128 }
    129 
    130 #[test]
    131 fn decoded_content_byte_budget_and_complete_frame_budget_remain_independent() {
    132     let exact = wire(8890, &[], &"é".repeat(8192));
    133     let decoded = DecodedRumor::decode(exact.json().as_bytes()).unwrap();
    134     assert_eq!(decoded.protected_content().len(), 16384);
    135     let extra = wire(8890, &[], &("é".repeat(8192) + "a"));
    136     assert_eq!(
    137         DecodedRumor::decode(extra.json().as_bytes()).unwrap_err(),
    138         RumorWireError::LimitExceeded
    139     );
    140     let generic = wire(65535, &[], &"é".repeat(8193));
    141     assert!(DecodedRumor::decode(generic.json().as_bytes()).is_ok());
    142     assert_eq!(
    143         DecodedRumor::decode(&vec![b' '; 24577]).unwrap_err(),
    144         RumorWireError::LimitExceeded
    145     );
    146     let nested = format!("{{\"x\":{}0{}}}", "[".repeat(16), "]".repeat(16));
    147     assert!(DecodedRumor::decode(nested.as_bytes()).is_err());
    148 }