lib

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

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;