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 }