lib

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

profile_complete_edit.rs (15814B)


      1 #![cfg(feature = "json")]
      2 
      3 use nostr::{EventBuilder, Keys, Kind, Timestamp};
      4 use radroots_blossom::{BlobDescriptor, BlobUrl, MediaType, Sha256};
      5 use radroots_event::{
      6     contract::{
      7         ContractId, ContractKey, RegistryVersion, all_event_contracts,
      8         registry_v8::{PROFILE_METADATA_EDIT_CONTRACT_ID, all_event_contracts_registry_v8},
      9     },
     10     envelope::{EventEnvelope, EventEnvelopeParts},
     11     media::AuthoredImage,
     12     profile::{
     13         AuthoredProfile, Nip05Identifier, RADROOTS_PROFILE_METADATA_MAX_CONTENT_BYTES,
     14         edit::{ProfileEdit, ProfileFieldChange as Change, ProfileMediaChange as Media},
     15     },
     16 };
     17 use radroots_event_codec::{
     18     admission::profile::{RadrootsAdmittedProfileEvent, verify_and_admit_profile_event},
     19     authoring::{AuthoredEventPlan, PLAN_WIRE_MAX_BYTES, PlanWireV1},
     20     encode::profile::ProfileEditError,
     21 };
     22 use serde_json::{Value, value::RawValue};
     23 use std::collections::BTreeMap;
     24 
     25 fn keys() -> Keys {
     26     Keys::parse("0101010101010101010101010101010101010101010101010101010101010101").unwrap()
     27 }
     28 
     29 fn envelope(content: &str, time: u64, tags: Vec<Vec<String>>, signer: &Keys) -> EventEnvelope {
     30     let event = EventBuilder::new(Kind::Metadata, content)
     31         .custom_created_at(Timestamp::from_secs(time))
     32         .tags(tags.into_iter().map(|tag| nostr::Tag::parse(tag).unwrap()))
     33         .sign_with_keys(signer)
     34         .unwrap();
     35     EventEnvelope::new(EventEnvelopeParts {
     36         id: event.id.to_hex(),
     37         author: event.pubkey.to_hex(),
     38         created_at: event.created_at.as_secs(),
     39         kind: 0,
     40         tags: event
     41             .tags
     42             .as_slice()
     43             .iter()
     44             .map(|tag| tag.as_slice().to_vec())
     45             .collect(),
     46         content: event.content,
     47         sig: event.sig.to_string(),
     48     })
     49     .unwrap()
     50 }
     51 
     52 fn admitted(content: &str, time: u64) -> RadrootsAdmittedProfileEvent {
     53     verify_and_admit_profile_event(envelope(content, time, vec![], &keys())).unwrap()
     54 }
     55 
     56 fn plan(
     57     baseline: &RadrootsAdmittedProfileEvent,
     58     edit: &ProfileEdit,
     59 ) -> Result<AuthoredEventPlan, ProfileEditError> {
     60     AuthoredEventPlan::from_profile_edit(
     61         baseline,
     62         baseline,
     63         edit,
     64         baseline.event().created_at_u64() + 1,
     65         keys().public_key().to_hex(),
     66     )
     67 }
     68 
     69 fn image(bytes: &[u8]) -> AuthoredImage {
     70     let hash = Sha256::digest(bytes);
     71     let media = MediaType::parse("image/webp").unwrap();
     72     AuthoredImage::try_from(
     73         BlobDescriptor::new(
     74             BlobUrl::parse(&format!("https://media.example/{hash}.webp")).unwrap(),
     75             hash,
     76             bytes.len() as u64,
     77             media.clone(),
     78             100,
     79         )
     80         .unwrap()
     81         .approve_reference()
     82         .unwrap()
     83         .verify_bytes(bytes, &media)
     84         .unwrap(),
     85     )
     86     .unwrap()
     87 }
     88 
     89 #[test]
     90 fn profile_complete_edit_display_only_preserves_all_untouched_metadata_and_signed_roundtrip() {
     91     let picture = image(b"picture");
     92     let banner = image(b"banner");
     93     let content = format!(
     94         r#"{{"name":"farm","display_name":"Old","about":"grows food","picture":"{}","banner":"{}","nip05":"farm@EXAMPLE.COM","bot":false,"website":"https://example.com","birthday":{{ "year":1900, "year":2000 }},"custom":900719925474099312345,"lud16":null}}"#,
     95         picture.descriptor().url(),
     96         banner.descriptor().url()
     97     );
     98     let base = admitted(&content, 100);
     99     let edit = ProfileEdit {
    100         display_name: Change::Set("New".into()),
    101         picture: Media::KeepVerified(picture),
    102         banner: Media::KeepVerified(banner),
    103         ..Default::default()
    104     };
    105     let candidate = plan(&base, &edit).unwrap();
    106     let before: BTreeMap<String, Box<RawValue>> = serde_json::from_str(&content).unwrap();
    107     let after: BTreeMap<String, Box<RawValue>> =
    108         serde_json::from_str(candidate.body().content()).unwrap();
    109     assert_eq!(before.len(), after.len());
    110     for (name, value) in before
    111         .iter()
    112         .filter(|(name, _)| name.as_str() != "display_name")
    113     {
    114         assert_eq!(value.get(), after[name].get(), "{name}");
    115     }
    116     assert_eq!(after["display_name"].get(), r#""New""#);
    117     assert_eq!(
    118         candidate.body().contract().registry_version(),
    119         RegistryVersion::V8
    120     );
    121     assert_eq!(
    122         candidate.body().contract().contract_id().as_str(),
    123         PROFILE_METADATA_EDIT_CONTRACT_ID
    124     );
    125     let wire = PlanWireV1::from_plan(&candidate).to_json().unwrap();
    126     let restored = PlanWireV1::from_json(&wire).unwrap();
    127     assert_eq!(restored.plan(), &candidate);
    128     let signed = verify_and_admit_profile_event(envelope(
    129         candidate.body().content(),
    130         candidate.created_at(),
    131         vec![],
    132         &keys(),
    133     ))
    134     .unwrap();
    135     assert_eq!(signed.event().id(), candidate.expected_event_id());
    136     assert_eq!(signed.metadata().display_name(), Some("New"));
    137     assert!(signed.metadata().residual_fields().contains_key("custom"));
    138     assert_eq!(
    139         signed.metadata().nip05().unwrap().as_str(),
    140         "farm@example.com"
    141     );
    142 }
    143 
    144 #[test]
    145 fn profile_complete_edit_sets_and_clears_each_typed_field_without_unknown_authoring() {
    146     let base = admitted(
    147         r#"{"name":"old","display_name":7,"about":null,"picture":false,"banner":[],"nip05":"invalid","bot":"wrong","unknown":{"x":1}}"#,
    148         100,
    149     );
    150     let edit = ProfileEdit {
    151         name: Change::Set("new".into()),
    152         display_name: Change::Set("Display".into()),
    153         about: Change::Set("About".into()),
    154         picture: Media::Set(image(b"picture")),
    155         banner: Media::Set(image(b"banner")),
    156         nip05: Change::Set(Nip05Identifier::parse("farmer@EXAMPLE.COM").unwrap()),
    157         bot: Change::Set(true),
    158     };
    159     let result: Value = serde_json::from_str(plan(&base, &edit).unwrap().body().content()).unwrap();
    160     assert_eq!(result["name"], "new");
    161     assert_eq!(result["display_name"], "Display");
    162     assert_eq!(result["about"], "About");
    163     assert_eq!(result["nip05"], "farmer@example.com");
    164     assert_eq!(result["bot"], true);
    165     assert!(
    166         result["picture"]
    167             .as_str()
    168             .unwrap()
    169             .starts_with("https://media.example/")
    170     );
    171     assert!(
    172         result["banner"]
    173             .as_str()
    174             .unwrap()
    175             .starts_with("https://media.example/")
    176     );
    177     let clear = ProfileEdit {
    178         name: Change::Clear,
    179         display_name: Change::Clear,
    180         about: Change::Clear,
    181         picture: Media::Clear,
    182         banner: Media::Clear,
    183         nip05: Change::Clear,
    184         bot: Change::Clear,
    185     };
    186     assert_eq!(
    187         plan(&base, &clear).unwrap().body().content(),
    188         r#"{"unknown":{"x":1}}"#
    189     );
    190     assert_eq!(
    191         plan(&base, &ProfileEdit::default())
    192             .unwrap()
    193             .body()
    194             .content(),
    195         r#"{"about":null,"banner":[],"bot":"wrong","display_name":7,"name":"old","nip05":"invalid","picture":false,"unknown":{"x":1}}"#
    196     );
    197     assert_eq!(ProfileEdit::default().name, Change::Keep);
    198 }
    199 
    200 #[test]
    201 fn profile_complete_edit_stale_foreign_tagged_and_nonadvancing_baselines_refuse() {
    202     let base = admitted(r#"{"name":"old"}"#, 100);
    203     let newer = admitted(r#"{"name":"new"}"#, 101);
    204     let edit = ProfileEdit::default();
    205     let author = keys().public_key().to_hex();
    206     assert_eq!(
    207         AuthoredEventPlan::from_profile_edit(&base, &newer, &edit, 102, &author).unwrap_err(),
    208         ProfileEditError::StaleBaseline
    209     );
    210     let equal_time = admitted(r#"{"name":"changed"}"#, 100);
    211     assert_eq!(
    212         AuthoredEventPlan::from_profile_edit(&base, &equal_time, &edit, 102, &author).unwrap_err(),
    213         ProfileEditError::StaleBaseline
    214     );
    215     for time in [99, 100] {
    216         assert_eq!(
    217             AuthoredEventPlan::from_profile_edit(&base, &base, &edit, time, &author).unwrap_err(),
    218             ProfileEditError::TimestampNotAdvancing
    219         );
    220     }
    221     for wrong in ["bad", &"ff".repeat(32)] {
    222         assert_eq!(
    223             AuthoredEventPlan::from_profile_edit(&base, &base, &edit, 102, wrong).unwrap_err(),
    224             ProfileEditError::AuthorMismatch
    225         );
    226     }
    227     let other =
    228         Keys::parse("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
    229     let foreign =
    230         verify_and_admit_profile_event(envelope(r#"{"name":"foreign"}"#, 100, vec![], &other))
    231             .unwrap();
    232     assert_eq!(
    233         AuthoredEventPlan::from_profile_edit(&base, &foreign, &edit, 102, &author).unwrap_err(),
    234         ProfileEditError::AuthorMismatch
    235     );
    236     assert_eq!(
    237         AuthoredEventPlan::from_profile_edit(&foreign, &base, &edit, 102, &author).unwrap_err(),
    238         ProfileEditError::AuthorMismatch
    239     );
    240     let tagged = verify_and_admit_profile_event(envelope(
    241         r#"{"name":"old"}"#,
    242         100,
    243         vec![vec!["x".into(), "keep".into()]],
    244         &keys(),
    245     ))
    246     .unwrap();
    247     assert_eq!(
    248         plan(&tagged, &edit).unwrap_err(),
    249         ProfileEditError::BaselineTagsUnsupported
    250     );
    251 }
    252 
    253 #[test]
    254 fn profile_complete_edit_kept_media_requires_exact_proof_or_explicit_clear() {
    255     let picture = image(b"picture");
    256     let base = admitted(
    257         &format!(r#"{{"picture":"{}"}}"#, picture.descriptor().url()),
    258         100,
    259     );
    260     assert_eq!(
    261         plan(&base, &ProfileEdit::default()).unwrap_err(),
    262         ProfileEditError::MediaVerificationRequired { field: "picture" }
    263     );
    264     let mismatch = ProfileEdit {
    265         picture: Media::KeepVerified(image(b"other")),
    266         ..Default::default()
    267     };
    268     assert_eq!(
    269         plan(&base, &mismatch).unwrap_err(),
    270         ProfileEditError::MediaVerificationMismatch { field: "picture" }
    271     );
    272     let empty = admitted("{}", 100);
    273     assert_eq!(
    274         plan(&empty, &mismatch).unwrap_err(),
    275         ProfileEditError::MediaVerificationMismatch { field: "picture" }
    276     );
    277     let unsupported = admitted(r#"{"picture":"https://legacy.example/photo"}"#, 100);
    278     assert_eq!(
    279         plan(&unsupported, &ProfileEdit::default())
    280             .unwrap_err()
    281             .code(),
    282         "profile_media_verification_required"
    283     );
    284     assert_eq!(
    285         plan(
    286             &unsupported,
    287             &ProfileEdit {
    288                 picture: Media::Clear,
    289                 ..Default::default()
    290             }
    291         )
    292         .unwrap()
    293         .body()
    294         .content(),
    295         "{}"
    296     );
    297     let malformed = admitted(r#"{"picture":{"url":"untrusted"}}"#, 100);
    298     assert_eq!(
    299         plan(&malformed, &ProfileEdit::default())
    300             .unwrap()
    301             .body()
    302             .content(),
    303         r#"{"picture":{"url":"untrusted"}}"#
    304     );
    305 }
    306 
    307 #[test]
    308 fn profile_complete_edit_content_and_durable_wire_bounds_are_exact() {
    309     let empty = admitted("{}", 100);
    310     let overhead = r#"{"about":""}"#.len();
    311     let max = RADROOTS_PROFILE_METADATA_MAX_CONTENT_BYTES;
    312     let exact = ProfileEdit {
    313         about: Change::Set("a".repeat(max - overhead)),
    314         ..Default::default()
    315     };
    316     let accepted = plan(&empty, &exact).unwrap();
    317     assert_eq!(accepted.body().content().len(), max);
    318     assert!(PlanWireV1::from_plan(&accepted).to_json().unwrap().len() <= PLAN_WIRE_MAX_BYTES);
    319     let over = ProfileEdit {
    320         about: Change::Set("a".repeat(max - overhead + 1)),
    321         ..Default::default()
    322     };
    323     assert_eq!(plan(&empty, &over).unwrap_err().code(), "content_too_large");
    324     let early = ProfileEdit {
    325         name: Change::Set("a".repeat(max + 1)),
    326         ..Default::default()
    327     };
    328     assert_eq!(
    329         plan(&empty, &early).unwrap_err(),
    330         ProfileEditError::ContentTooLarge {
    331             max,
    332             actual: max + 1
    333         }
    334     );
    335     for name in ["", " ", "bad\nname"] {
    336         assert_eq!(
    337             plan(
    338                 &empty,
    339                 &ProfileEdit {
    340                     name: Change::Set(name.into()),
    341                     ..Default::default()
    342                 }
    343             )
    344             .unwrap_err(),
    345             ProfileEditError::InvalidName
    346         );
    347     }
    348     // Valid input content can expand beyond the durable-wire bound when escaped again.
    349     let escaped = ProfileEdit {
    350         about: Change::Set("\"".repeat((max - overhead) / 2)),
    351         ..Default::default()
    352     };
    353     assert_eq!(
    354         plan(&empty, &escaped).unwrap_err().code(),
    355         "profile_durable_wire_too_large"
    356     );
    357 }
    358 
    359 #[test]
    360 fn profile_complete_edit_registry_is_explicit_and_v7_defaults_and_strict_wire_are_unchanged() {
    361     assert_eq!(RegistryVersion::CURRENT, RegistryVersion::V7);
    362     let inherited = all_event_contracts();
    363     let successor = all_event_contracts_registry_v8();
    364     assert_eq!(&successor[..inherited.len()], inherited);
    365     assert_eq!(successor.len(), inherited.len() + 1);
    366     assert_eq!(
    367         successor.last().unwrap().id,
    368         PROFILE_METADATA_EDIT_CONTRACT_ID
    369     );
    370     assert!(ContractKey::current(PROFILE_METADATA_EDIT_CONTRACT_ID).is_err());
    371     let key = ContractKey::new(
    372         RegistryVersion::V8,
    373         ContractId::parse(PROFILE_METADATA_EDIT_CONTRACT_ID).unwrap(),
    374     )
    375     .unwrap();
    376     assert_eq!(key.contract().kind, 0);
    377     assert_eq!(
    378         serde_json::from_slice::<ContractKey>(&serde_json::to_vec(&key).unwrap()).unwrap(),
    379         key
    380     );
    381     assert!(
    382         ContractKey::new(
    383             RegistryVersion::V8,
    384             ContractId::parse("radroots.profile.unknown.v1").unwrap()
    385         )
    386         .is_err()
    387     );
    388     let strict = AuthoredEventPlan::from_profile(
    389         &AuthoredProfile::new("farm").unwrap(),
    390         101,
    391         keys().public_key().to_hex(),
    392     )
    393     .unwrap();
    394     assert_eq!(
    395         strict.body().contract().registry_version(),
    396         RegistryVersion::V7
    397     );
    398     assert_eq!(strict.body().content(), r#"{"name":"farm"}"#);
    399     let baseline = admitted(r#"{"custom":true,"name":"farm"}"#, 100);
    400     let edit = plan(&baseline, &ProfileEdit::default()).unwrap();
    401     let mut forged: Value =
    402         serde_json::from_slice(&PlanWireV1::from_plan(&edit).to_json().unwrap()).unwrap();
    403     forged["contract_registry_version"] = Value::from(7);
    404     assert!(PlanWireV1::from_json(&serde_json::to_vec(&forged).unwrap()).is_err());
    405     forged["contract_id"] = Value::from("radroots.profile.metadata.v1");
    406     assert!(PlanWireV1::from_json(&serde_json::to_vec(&forged).unwrap()).is_err());
    407 }
    408 
    409 #[test]
    410 fn profile_complete_edit_historical_reconstruction_refuses_ambiguous_or_unsupported_shape() {
    411     use radroots_event_codec::authoring::PlanDecodeError;
    412     let baseline = admitted(r#"{"name":"farm","unknown":true}"#, 100);
    413     let candidate = plan(&baseline, &ProfileEdit::default()).unwrap();
    414     let original: Value =
    415         serde_json::from_slice(&PlanWireV1::from_plan(&candidate).to_json().unwrap()).unwrap();
    416     for (content, code) in [
    417         (
    418             r#"{"unknown":true,"name":"farm"}"#,
    419             "profile_edit_noncanonical",
    420         ),
    421         (r#"{"name":"farm","name":"other"}"#, "duplicate_field"),
    422         (
    423             r#"{"picture":"https://legacy.example/image"}"#,
    424             "profile_media_url_invalid",
    425         ),
    426         ("[]", "root_not_object"),
    427         ("broken", "invalid_json"),
    428     ] {
    429         let mut value = original.clone();
    430         value["content"] = Value::from(content);
    431         assert_eq!(
    432             PlanWireV1::from_json(&serde_json::to_vec(&value).unwrap()),
    433             Err(PlanDecodeError::HistoricalShape(code.into()))
    434         );
    435     }
    436     let mut tagged = original.clone();
    437     tagged["tags"] = serde_json::json!([["x", "extra"]]);
    438     assert_eq!(
    439         PlanWireV1::from_json(&serde_json::to_vec(&tagged).unwrap()),
    440         Err(PlanDecodeError::HistoricalShape(
    441             "profile_tags_forbidden".into()
    442         ))
    443     );
    444     let mut unsupported = original;
    445     unsupported["contract_registry_version"] = Value::from(9);
    446     assert!(PlanWireV1::from_json(&serde_json::to_vec(&unsupported).unwrap()).is_err());
    447 }