profile.rs (17071B)
1 //! Profile and account event models. 2 3 pub mod edit; 4 5 #[cfg(not(feature = "std"))] 6 use alloc::string::String; 7 use core::{fmt, str::FromStr}; 8 9 use crate::media::AuthoredImage; 10 11 pub const RADROOTS_PROFILE_TYPE_TAG_KEY: &str = "t"; 12 pub const RADROOTS_PROFILE_TYPE_TAG_INDIVIDUAL: &str = "radroots:type:individual"; 13 pub const RADROOTS_PROFILE_TYPE_TAG_FARM: &str = "radroots:type:farm"; 14 pub const RADROOTS_PROFILE_TYPE_TAG_COOP: &str = "radroots:type:coop"; 15 pub const RADROOTS_PROFILE_TYPE_TAG_ANY: &str = "radroots:type:any"; 16 pub const RADROOTS_PROFILE_TYPE_TAG_RADROOTSD: &str = "radroots:type:radrootsd"; 17 pub const RADROOTS_PROFILE_METADATA_MAX_CONTENT_BYTES: usize = 18 crate::wire::v1::DEFAULT_CONTENT_MAX_BYTES; 19 20 #[cfg_attr(all(test, feature = "std"), derive(dto_bindgen::Dto))] 21 #[cfg_attr(all(test, feature = "std"), dto(export))] 22 #[cfg_attr( 23 any(feature = "serde", test), 24 derive(serde::Serialize, serde::Deserialize) 25 )] 26 #[cfg_attr(any(feature = "serde", test), serde(rename_all = "snake_case"))] 27 #[derive(Clone, Debug, PartialEq, Eq, Copy)] 28 pub enum ProfileType { 29 #[cfg_attr(any(feature = "serde", test), serde(rename = "individual"))] 30 Individual, 31 #[cfg_attr(any(feature = "serde", test), serde(rename = "farm"))] 32 Farm, 33 #[cfg_attr(any(feature = "serde", test), serde(rename = "coop"))] 34 Coop, 35 #[cfg_attr(any(feature = "serde", test), serde(rename = "any"))] 36 Any, 37 #[cfg_attr(any(feature = "serde", test), serde(rename = "radrootsd"))] 38 Radrootsd, 39 } 40 41 pub fn radroots_profile_type_tag_value(profile_type: ProfileType) -> &'static str { 42 match profile_type { 43 ProfileType::Individual => RADROOTS_PROFILE_TYPE_TAG_INDIVIDUAL, 44 ProfileType::Farm => RADROOTS_PROFILE_TYPE_TAG_FARM, 45 ProfileType::Coop => RADROOTS_PROFILE_TYPE_TAG_COOP, 46 ProfileType::Any => RADROOTS_PROFILE_TYPE_TAG_ANY, 47 ProfileType::Radrootsd => RADROOTS_PROFILE_TYPE_TAG_RADROOTSD, 48 } 49 } 50 51 pub fn radroots_profile_type_from_tag_value(value: &str) -> Option<ProfileType> { 52 match value { 53 RADROOTS_PROFILE_TYPE_TAG_INDIVIDUAL => Some(ProfileType::Individual), 54 RADROOTS_PROFILE_TYPE_TAG_FARM => Some(ProfileType::Farm), 55 RADROOTS_PROFILE_TYPE_TAG_COOP => Some(ProfileType::Coop), 56 RADROOTS_PROFILE_TYPE_TAG_ANY => Some(ProfileType::Any), 57 RADROOTS_PROFILE_TYPE_TAG_RADROOTSD => Some(ProfileType::Radrootsd), 58 _ => None, 59 } 60 } 61 62 #[non_exhaustive] 63 #[derive(Clone, Debug, PartialEq, Eq)] 64 pub enum Nip05IdentifierError { 65 MissingSeparator, 66 MultipleSeparators, 67 InvalidLocalPart, 68 InvalidDomain, 69 } 70 71 impl Nip05IdentifierError { 72 pub const fn code(&self) -> &'static str { 73 match self { 74 Self::MissingSeparator => "missing_separator", 75 Self::MultipleSeparators => "multiple_separators", 76 Self::InvalidLocalPart => "invalid_local_part", 77 Self::InvalidDomain => "invalid_domain", 78 } 79 } 80 } 81 82 impl fmt::Display for Nip05IdentifierError { 83 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 84 match self { 85 Self::MissingSeparator => f.write_str("NIP-05 identifier must contain one @ separator"), 86 Self::MultipleSeparators => { 87 f.write_str("NIP-05 identifier must not contain multiple @ separators") 88 } 89 Self::InvalidLocalPart => f.write_str("NIP-05 identifier local part is invalid"), 90 Self::InvalidDomain => f.write_str("NIP-05 identifier domain is invalid"), 91 } 92 } 93 } 94 95 #[cfg(feature = "std")] 96 impl std::error::Error for Nip05IdentifierError {} 97 98 /// A syntax-checked NIP-05 internet identifier. 99 /// 100 /// The DNS domain is canonicalized to lowercase. This type performs no network 101 /// resolution and makes no identity-verification claim. 102 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] 103 pub struct Nip05Identifier(String); 104 105 impl Nip05Identifier { 106 pub fn parse(value: &str) -> Result<Self, Nip05IdentifierError> { 107 let Some((local_part, domain)) = value.split_once('@') else { 108 return Err(Nip05IdentifierError::MissingSeparator); 109 }; 110 if domain.contains('@') { 111 return Err(Nip05IdentifierError::MultipleSeparators); 112 } 113 if local_part.is_empty() 114 || !local_part.bytes().all(|byte| { 115 byte.is_ascii_lowercase() 116 || byte.is_ascii_digit() 117 || matches!(byte, b'-' | b'_' | b'.') 118 }) 119 { 120 return Err(Nip05IdentifierError::InvalidLocalPart); 121 } 122 let domain = domain.to_ascii_lowercase(); 123 if !valid_nip05_domain(&domain) { 124 return Err(Nip05IdentifierError::InvalidDomain); 125 } 126 let mut canonical = String::with_capacity(value.len()); 127 canonical.push_str(local_part); 128 canonical.push('@'); 129 canonical.push_str(&domain); 130 Ok(Self(canonical)) 131 } 132 133 pub fn as_str(&self) -> &str { 134 &self.0 135 } 136 137 pub fn local_part(&self) -> &str { 138 self.0 139 .split_once('@') 140 .expect("validated NIP-05 identifiers always contain one separator") 141 .0 142 } 143 144 pub fn domain(&self) -> &str { 145 self.0 146 .split_once('@') 147 .expect("validated NIP-05 identifiers always contain one separator") 148 .1 149 } 150 } 151 152 impl fmt::Display for Nip05Identifier { 153 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 154 f.write_str(self.as_str()) 155 } 156 } 157 158 impl FromStr for Nip05Identifier { 159 type Err = Nip05IdentifierError; 160 161 fn from_str(value: &str) -> Result<Self, Self::Err> { 162 Self::parse(value) 163 } 164 } 165 166 fn valid_nip05_domain(domain: &str) -> bool { 167 !domain.is_empty() 168 && domain.len() <= 253 169 && domain.split('.').all(|label| { 170 !label.is_empty() 171 && label.len() <= 63 172 && label 173 .bytes() 174 .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'-') 175 && label 176 .as_bytes() 177 .first() 178 .is_some_and(u8::is_ascii_alphanumeric) 179 && label 180 .as_bytes() 181 .last() 182 .is_some_and(u8::is_ascii_alphanumeric) 183 }) 184 } 185 186 #[non_exhaustive] 187 #[derive(Clone, Debug, PartialEq, Eq)] 188 pub enum AuthoredProfileError { 189 InvalidName, 190 } 191 192 impl AuthoredProfileError { 193 pub const fn code(&self) -> &'static str { 194 match self { 195 Self::InvalidName => "invalid_name", 196 } 197 } 198 } 199 200 impl fmt::Display for AuthoredProfileError { 201 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 202 match self { 203 Self::InvalidName => { 204 f.write_str("authored Profile name must be non-whitespace and control-free") 205 } 206 } 207 } 208 } 209 210 #[cfg(feature = "std")] 211 impl std::error::Error for AuthoredProfileError {} 212 213 /// Metadata accepted by the strict authored kind-0 Profile operation. 214 /// 215 /// A non-whitespace, control-free name is required. Media values can only enter 216 /// through image-only, byte-verified Blossom descriptors. That state proves 217 /// descriptor/byte agreement, not successful network upload. 218 /// 219 /// This model represents a complete kind-0 replacement snapshot, not a patch. 220 /// Omitting an existing field removes it from the authored replacement. 221 /// 222 /// ```compile_fail 223 /// let _: radroots_event::profile::AuthoredProfile = 224 /// serde_json::from_str(r#"{"name":"alice"}"#).unwrap(); 225 /// ``` 226 #[derive(Clone, Debug, PartialEq, Eq)] 227 pub struct AuthoredProfile { 228 name: String, 229 display_name: Option<String>, 230 about: Option<String>, 231 picture: Option<AuthoredImage>, 232 banner: Option<AuthoredImage>, 233 nip05: Option<Nip05Identifier>, 234 bot: Option<bool>, 235 } 236 237 impl AuthoredProfile { 238 pub fn new(name: impl Into<String>) -> Result<Self, AuthoredProfileError> { 239 let name = name.into(); 240 if name.trim().is_empty() || name.chars().any(char::is_control) { 241 return Err(AuthoredProfileError::InvalidName); 242 } 243 Ok(Self { 244 name, 245 display_name: None, 246 about: None, 247 picture: None, 248 banner: None, 249 nip05: None, 250 bot: None, 251 }) 252 } 253 254 #[must_use] 255 pub fn with_display_name(mut self, value: impl Into<String>) -> Self { 256 self.display_name = Some(value.into()); 257 self 258 } 259 260 #[must_use] 261 pub fn with_about(mut self, value: impl Into<String>) -> Self { 262 self.about = Some(value.into()); 263 self 264 } 265 266 #[must_use] 267 pub fn with_picture(mut self, value: AuthoredImage) -> Self { 268 self.picture = Some(value); 269 self 270 } 271 272 #[must_use] 273 pub fn with_banner(mut self, value: AuthoredImage) -> Self { 274 self.banner = Some(value); 275 self 276 } 277 278 #[must_use] 279 pub fn with_nip05(mut self, value: Nip05Identifier) -> Self { 280 self.nip05 = Some(value); 281 self 282 } 283 284 #[must_use] 285 pub const fn with_bot(mut self, value: bool) -> Self { 286 self.bot = Some(value); 287 self 288 } 289 290 pub fn name(&self) -> &str { 291 &self.name 292 } 293 294 pub fn display_name(&self) -> Option<&str> { 295 self.display_name.as_deref() 296 } 297 298 pub fn about(&self) -> Option<&str> { 299 self.about.as_deref() 300 } 301 302 pub fn picture(&self) -> Option<&AuthoredImage> { 303 self.picture.as_ref() 304 } 305 306 pub fn banner(&self) -> Option<&AuthoredImage> { 307 self.banner.as_ref() 308 } 309 310 pub fn nip05(&self) -> Option<&Nip05Identifier> { 311 self.nip05.as_ref() 312 } 313 314 pub const fn bot(&self) -> Option<bool> { 315 self.bot 316 } 317 } 318 319 #[cfg(test)] 320 #[cfg_attr(coverage_nightly, coverage(off))] 321 mod tests { 322 use super::*; 323 use radroots_blossom::{BlobDescriptor, BlobUrl, ByteVerifiedDescriptor, MediaType, Sha256}; 324 325 #[test] 326 fn maps_profile_type_to_tag_value() { 327 assert_eq!( 328 radroots_profile_type_tag_value(ProfileType::Individual), 329 RADROOTS_PROFILE_TYPE_TAG_INDIVIDUAL 330 ); 331 assert_eq!( 332 radroots_profile_type_tag_value(ProfileType::Farm), 333 RADROOTS_PROFILE_TYPE_TAG_FARM 334 ); 335 assert_eq!( 336 radroots_profile_type_tag_value(ProfileType::Coop), 337 RADROOTS_PROFILE_TYPE_TAG_COOP 338 ); 339 assert_eq!( 340 radroots_profile_type_tag_value(ProfileType::Any), 341 RADROOTS_PROFILE_TYPE_TAG_ANY 342 ); 343 assert_eq!( 344 radroots_profile_type_tag_value(ProfileType::Radrootsd), 345 RADROOTS_PROFILE_TYPE_TAG_RADROOTSD 346 ); 347 } 348 349 #[test] 350 fn maps_tag_value_to_profile_type() { 351 assert_eq!( 352 radroots_profile_type_from_tag_value(RADROOTS_PROFILE_TYPE_TAG_INDIVIDUAL), 353 Some(ProfileType::Individual) 354 ); 355 assert_eq!( 356 radroots_profile_type_from_tag_value(RADROOTS_PROFILE_TYPE_TAG_FARM), 357 Some(ProfileType::Farm) 358 ); 359 assert_eq!( 360 radroots_profile_type_from_tag_value(RADROOTS_PROFILE_TYPE_TAG_COOP), 361 Some(ProfileType::Coop) 362 ); 363 assert_eq!( 364 radroots_profile_type_from_tag_value(RADROOTS_PROFILE_TYPE_TAG_ANY), 365 Some(ProfileType::Any) 366 ); 367 assert_eq!( 368 radroots_profile_type_from_tag_value(RADROOTS_PROFILE_TYPE_TAG_RADROOTSD), 369 Some(ProfileType::Radrootsd) 370 ); 371 assert_eq!(radroots_profile_type_from_tag_value("unknown"), None); 372 } 373 374 #[test] 375 fn nip05_identifier_accepts_the_pinned_nip05_syntax_without_claiming_trust() { 376 for (value, canonical) in [ 377 ("alice@example.com", "alice@example.com"), 378 ("_@example.com", "_@example.com"), 379 ( 380 "farm.stand-1@markets.example", 381 "farm.stand-1@markets.example", 382 ), 383 ("alice@farm2.example", "alice@farm2.example"), 384 ("alice@xn--bcher-kva.example", "alice@xn--bcher-kva.example"), 385 ("alice@Example.COM", "alice@example.com"), 386 ] { 387 let identifier = Nip05Identifier::parse(value).unwrap(); 388 assert_eq!(identifier.as_str(), canonical); 389 assert_eq!(identifier.to_string(), canonical); 390 assert_eq!(canonical.parse::<Nip05Identifier>().unwrap(), identifier); 391 } 392 393 let identifier = Nip05Identifier::parse("alice@example.com").unwrap(); 394 assert_eq!(identifier.local_part(), "alice"); 395 assert_eq!(identifier.domain(), "example.com"); 396 } 397 398 #[test] 399 fn nip05_identifier_rejects_noncanonical_or_ambiguous_syntax() { 400 let cases = [ 401 ("alice", Nip05IdentifierError::MissingSeparator), 402 ( 403 "alice@example.com@other.example", 404 Nip05IdentifierError::MultipleSeparators, 405 ), 406 ("@example.com", Nip05IdentifierError::InvalidLocalPart), 407 ("Alice@example.com", Nip05IdentifierError::InvalidLocalPart), 408 ( 409 "alice+farm@example.com", 410 Nip05IdentifierError::InvalidLocalPart, 411 ), 412 ("alice@", Nip05IdentifierError::InvalidDomain), 413 ("alice@-example.com", Nip05IdentifierError::InvalidDomain), 414 ("alice@example-.com", Nip05IdentifierError::InvalidDomain), 415 ("alice@example..com", Nip05IdentifierError::InvalidDomain), 416 ("alice@example.com.", Nip05IdentifierError::InvalidDomain), 417 ("alice@example_com", Nip05IdentifierError::InvalidDomain), 418 ]; 419 420 for (value, expected) in cases { 421 let error = Nip05Identifier::parse(value).unwrap_err(); 422 assert_eq!(error, expected, "{value}"); 423 assert!(!error.code().is_empty()); 424 assert!(!error.to_string().is_empty()); 425 } 426 427 let long_label = "a".repeat(64); 428 assert_eq!( 429 Nip05Identifier::parse(&format!("alice@{long_label}.example")), 430 Err(Nip05IdentifierError::InvalidDomain) 431 ); 432 let long_domain = (0..43).map(|_| "aaaaa").collect::<Vec<_>>().join("."); 433 assert!(long_domain.len() > 253); 434 assert_eq!( 435 Nip05Identifier::parse(&format!("alice@{long_domain}")), 436 Err(Nip05IdentifierError::InvalidDomain) 437 ); 438 } 439 440 #[test] 441 fn authored_profile_requires_name_and_image_only_verified_media() { 442 let media = AuthoredImage::try_from(verified_descriptor("image/webp", "webp")).unwrap(); 443 let profile = AuthoredProfile::new("alice") 444 .unwrap() 445 .with_display_name("Alice") 446 .with_about("Victoria grower") 447 .with_picture(media.clone()) 448 .with_banner(media) 449 .with_nip05(Nip05Identifier::parse("alice@example.com").unwrap()) 450 .with_bot(false); 451 452 assert_eq!(profile.name(), "alice"); 453 assert_eq!(profile.display_name(), Some("Alice")); 454 assert_eq!(profile.about(), Some("Victoria grower")); 455 assert_eq!( 456 profile.nip05().map(Nip05Identifier::as_str), 457 Some("alice@example.com") 458 ); 459 assert_eq!(profile.bot(), Some(false)); 460 assert_eq!( 461 profile 462 .picture() 463 .map(|value| value.descriptor().url().as_str()), 464 Some( 465 "https://media.example/2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824.webp" 466 ) 467 ); 468 assert_eq!( 469 profile 470 .banner() 471 .map(|value| value.descriptor().url().as_str()), 472 profile 473 .picture() 474 .map(|value| value.descriptor().url().as_str()) 475 ); 476 477 let error = AuthoredImage::try_from(verified_descriptor("text/plain", "txt")).unwrap_err(); 478 assert_eq!(error, crate::media::AuthoredImageError::MediaTypeNotImage); 479 assert_eq!(error.code(), "media_type_not_image"); 480 assert!(!error.to_string().is_empty()); 481 482 for invalid_name in ["", " ", "alice\n"] { 483 let error = AuthoredProfile::new(invalid_name).unwrap_err(); 484 assert_eq!(error, AuthoredProfileError::InvalidName); 485 assert_eq!(error.code(), "invalid_name"); 486 assert!(!error.to_string().is_empty()); 487 } 488 } 489 490 fn verified_descriptor(media_type: &str, extension: &str) -> ByteVerifiedDescriptor { 491 let bytes = b"hello"; 492 let hash = Sha256::digest(bytes); 493 let media_type = MediaType::parse(media_type).unwrap(); 494 BlobDescriptor::new( 495 BlobUrl::parse(&format!("https://media.example/{hash}.{extension}")).unwrap(), 496 hash, 497 bytes.len() as u64, 498 media_type.clone(), 499 1_784_347_200, 500 ) 501 .unwrap() 502 .approve_reference() 503 .unwrap() 504 .verify_bytes(bytes, &media_type) 505 .unwrap() 506 } 507 } 508 #[path = "account.rs"] 509 pub mod account;