softchat/

account.rs

//! Private user metadata, contact backups, and addressable application data.

use std::collections::{BTreeMap, BTreeSet};

use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
use url::Url;

use crate::event::{RumorEvent, SignedEvent};
use crate::{
    LocalIdentity, Nip44EncryptedMessage, Nip44Payload, NostrEventDraft, NostrEventKind,
    NostrPublicKey, NostrRumor, NostrTag, SignedNostrEvent, SoftchatError,
};

/// Maximum contacts in one private backup.
pub const MAX_CONTACTS: usize = 10_000;
/// Maximum decrypted application-data JSON accepted by the shared layer.
pub const MAX_APP_DATA_JSON_BYTES: usize = 256 * 1024;

const METADATA_KEYS: [&str; 7] = [
    "name",
    "display_name",
    "about",
    "picture",
    "website",
    "banner",
    "bot",
];

/// Typed private user metadata with retained unknown JSON.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct UserMetadataView {
    /// Complete exact source rumor.
    pub rumor: RumorEvent,
    /// Optional short name.
    pub name: Option<String>,
    /// Optional display name.
    pub display_name: Option<String>,
    /// Optional profile description.
    pub about: Option<String>,
    /// Optional absolute HTTPS picture URL.
    pub picture: Option<String>,
    /// Optional absolute HTTPS website URL.
    pub website: Option<String>,
    /// Optional absolute HTTPS banner URL.
    pub banner: Option<String>,
    /// Optional bot marker.
    pub bot: Option<bool>,
    /// Compact JSON object containing every unknown field.
    pub unknown_json: String,
}

/// One canonical contact-backup entry.
#[derive(Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct Contact {
    /// Canonical contact public key.
    pub public_key: String,
    /// Optional relay hint represented as an empty string.
    pub relay_hint: String,
    /// Optional local name represented as an empty string.
    pub local_name: String,
}

/// Typed private kind-3 contact backup.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct FollowListView {
    /// Complete exact source rumor.
    pub rumor: RumorEvent,
    /// First occurrence of each public key, sorted by public key.
    pub contacts: Vec<Contact>,
    /// Whether duplicate received contacts were ignored for the typed view.
    pub contained_duplicates: bool,
}

/// Generic direct NIP-78 application data.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct ApplicationDataView {
    /// Complete verified signed event.
    pub event: SignedEvent,
    /// Addressable `d` identity.
    pub identifier: String,
    /// Opaque application-owned content.
    pub content: String,
}

/// Accepted Softchat kind-30079 contexts.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Enum))]
pub enum AppDataContext {
    /// Cross-device message read state.
    ReadState,
    /// Cross-device application settings.
    AppSettings,
}

impl AppDataContext {
    /// Return the exact `d`-tag value.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::ReadState => "read-state",
            Self::AppSettings => "app-settings",
        }
    }

    fn parse(value: &str) -> Result<Self, SoftchatError> {
        match value {
            "read-state" => Ok(Self::ReadState),
            "app-settings" => Ok(Self::AppSettings),
            _ => Err(SoftchatError::InvalidApplicationData),
        }
    }
}

/// Authenticated and self-decrypted Softchat kind-30079 data.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "native-bindings", derive(uniffi::Record))]
pub struct AppDataSyncView {
    /// Complete verified direct event.
    pub event: SignedEvent,
    /// Accepted application context.
    pub context: AppDataContext,
    /// Complete validated JSON, including unknown fields.
    pub json: String,
}

impl LocalIdentity {
    /// Create canonical private kind-0 user metadata.
    ///
    /// Unknown fields are supplied as a JSON object and retained unless they
    /// collide with the seven known fields.
    ///
    /// # Errors
    ///
    /// Returns [`SoftchatError::InvalidUserMetadata`] for malformed values.
    #[allow(clippy::too_many_arguments)]
    pub fn create_user_metadata(
        &self,
        created_at: u64,
        name: Option<String>,
        display_name: Option<String>,
        about: Option<String>,
        picture: Option<String>,
        website: Option<String>,
        banner: Option<String>,
        bot: Option<bool>,
        unknown_json: &str,
    ) -> Result<UserMetadataView, SoftchatError> {
        for value in [&picture, &website, &banner].into_iter().flatten() {
            validate_https(value).map_err(|_| SoftchatError::InvalidUserMetadata)?;
        }
        let mut object = parse_unknown_object(unknown_json)?;
        for key in METADATA_KEYS {
            if object.contains_key(key) {
                return Err(SoftchatError::InvalidUserMetadata);
            }
        }
        insert_optional(&mut object, "name", name);
        insert_optional(&mut object, "display_name", display_name);
        insert_optional(&mut object, "about", about);
        insert_optional(&mut object, "picture", picture);
        insert_optional(&mut object, "website", website);
        insert_optional(&mut object, "banner", banner);
        if let Some(value) = bot {
            object.insert("bot".to_owned(), Value::Bool(value));
        }
        let content =
            serde_json::to_string(&object).map_err(|_| SoftchatError::InvalidUserMetadata)?;
        if content.len() > MAX_APP_DATA_JSON_BYTES {
            return Err(SoftchatError::InvalidUserMetadata);
        }
        let rumor = self
            .create_rumor(
                NostrEventDraft::new(
                    created_at,
                    NostrEventKind::USER_METADATA,
                    Vec::new(),
                    content,
                )
                .map_err(|_| SoftchatError::InvalidUserMetadata)?,
            )
            .map_err(|_| SoftchatError::InvalidUserMetadata)?;
        parse_user_metadata(&rumor)
    }

    /// Create a canonical private author-copy kind-3 contact backup.
    ///
    /// # Errors
    ///
    /// Returns [`SoftchatError::InvalidContactList`] for duplicate contacts,
    /// malformed relay hints, or excessive list size.
    pub fn create_follow_list(
        &self,
        created_at: u64,
        contacts: Vec<Contact>,
    ) -> Result<FollowListView, SoftchatError> {
        if contacts.len() > MAX_CONTACTS {
            return Err(SoftchatError::InvalidContactList);
        }
        let mut canonical = contacts
            .into_iter()
            .map(validate_contact)
            .collect::<Result<Vec<_>, _>>()?;
        canonical.sort();
        let original_len = canonical.len();
        canonical.dedup_by(|left, right| left.public_key == right.public_key);
        if canonical.len() != original_len {
            return Err(SoftchatError::InvalidContactList);
        }
        let tags = canonical
            .iter()
            .map(|contact| {
                NostrTag::new(vec![
                    "p".to_owned(),
                    contact.public_key.clone(),
                    contact.relay_hint.clone(),
                    contact.local_name.clone(),
                ])
                .map_err(|_| SoftchatError::InvalidContactList)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let rumor = self
            .create_rumor(
                NostrEventDraft::new(created_at, NostrEventKind::FOLLOW_LIST, tags, "")
                    .map_err(|_| SoftchatError::InvalidContactList)?,
            )
            .map_err(|_| SoftchatError::InvalidContactList)?;
        parse_follow_list(&rumor)
    }

    /// Create a direct signed generic NIP-78 event.
    ///
    /// # Errors
    ///
    /// Returns [`SoftchatError::InvalidApplicationData`] for an empty
    /// identifier or an oversized event.
    pub fn create_application_data(
        &self,
        created_at: u64,
        identifier: String,
        content: String,
    ) -> Result<ApplicationDataView, SoftchatError> {
        validate_identifier(&identifier)?;
        let event = self
            .sign_event(
                NostrEventDraft::new(
                    created_at,
                    NostrEventKind::APPLICATION_DATA,
                    vec![NostrTag::new(vec!["d".to_owned(), identifier])?],
                    content,
                )
                .map_err(|_| SoftchatError::InvalidApplicationData)?,
            )
            .map_err(|_| SoftchatError::InvalidApplicationData)?;
        parse_application_data(&event)
    }

    /// Create direct signed, self-encrypted Softchat application data.
    ///
    /// # Errors
    ///
    /// Returns [`SoftchatError::InvalidApplicationData`] for invalid JSON,
    /// bounds, encryption, or signing failure.
    pub fn create_app_data_sync(
        &self,
        created_at: u64,
        context: AppDataContext,
        json: &str,
    ) -> Result<AppDataSyncView, SoftchatError> {
        let json = validate_json_object(json)?;
        let encrypted = self
            .encrypt_utf8(&self.public_key(), &json)
            .map_err(|_| SoftchatError::InvalidApplicationData)?;
        let event = self
            .sign_event(
                NostrEventDraft::new(
                    created_at,
                    NostrEventKind::APPLICATION_DATA_SYNC,
                    vec![NostrTag::new(vec!["d", context.as_str()])?],
                    encrypted.payload().as_str(),
                )
                .map_err(|_| SoftchatError::InvalidApplicationData)?,
            )
            .map_err(|_| SoftchatError::InvalidApplicationData)?;
        self.decrypt_app_data_sync(&event)
    }

    /// Validate and self-decrypt one kind-30079 event.
    ///
    /// # Errors
    ///
    /// Returns [`SoftchatError::InvalidApplicationData`] unless the event is
    /// authored by this identity and all encrypted JSON authenticates.
    pub fn decrypt_app_data_sync(
        &self,
        event: &SignedNostrEvent,
    ) -> Result<AppDataSyncView, SoftchatError> {
        if event.kind() != NostrEventKind::APPLICATION_DATA_SYNC
            || event.public_key() != self.public_key()
        {
            return Err(SoftchatError::InvalidApplicationData);
        }
        let identifier = exactly_one_d(event.tags())?;
        let context = AppDataContext::parse(&identifier)?;
        let encrypted = Nip44EncryptedMessage::new(
            self.public_key(),
            Nip44Payload::from_encoded(event.content())
                .map_err(|_| SoftchatError::InvalidApplicationData)?,
        );
        let json = self
            .decrypt_utf8(&encrypted)
            .map_err(|_| SoftchatError::InvalidApplicationData)?;
        let json = validate_json_object(&json)?;
        Ok(AppDataSyncView {
            event: SignedEvent::from(event),
            context,
            json,
        })
    }
}

/// Validate a binding-owned private user-metadata rumor.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_user_metadata(rumor: RumorEvent) -> Result<UserMetadataView, SoftchatError> {
    let rumor = NostrRumor::try_from(rumor).map_err(|_| SoftchatError::InvalidUserMetadata)?;
    parse_user_metadata(&rumor)
}

/// Select the deterministic latest private metadata rumor.
///
/// # Errors
///
/// All candidates must have the same author and valid kind-0 profile.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn latest_user_metadata(
    candidates: Vec<RumorEvent>,
) -> Result<UserMetadataView, SoftchatError> {
    let candidates = candidates
        .into_iter()
        .map(|candidate| {
            let rumor =
                NostrRumor::try_from(candidate).map_err(|_| SoftchatError::InvalidUserMetadata)?;
            let view = parse_user_metadata(&rumor)?;
            Ok((rumor.public_key(), rumor.created_at(), rumor.id(), view))
        })
        .collect::<Result<Vec<_>, SoftchatError>>()?;
    let author = candidates
        .first()
        .map(|(author, _, _, _)| author.clone())
        .ok_or(SoftchatError::InvalidUserMetadata)?;
    if candidates
        .iter()
        .any(|(candidate, _, _, _)| *candidate != author)
    {
        return Err(SoftchatError::InvalidUserMetadata);
    }
    candidates
        .into_iter()
        .max_by(|left, right| crate::replacement::compare(&left.1, &left.2, &right.1, &right.2))
        .map(|(_, _, _, view)| view)
        .ok_or(SoftchatError::InvalidUserMetadata)
}

/// Validate a binding-owned private contact-backup rumor.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_follow_list(rumor: RumorEvent) -> Result<FollowListView, SoftchatError> {
    let rumor = NostrRumor::try_from(rumor).map_err(|_| SoftchatError::InvalidContactList)?;
    parse_follow_list(&rumor)
}

/// Validate a direct generic NIP-78 event.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn classify_application_data(event: SignedEvent) -> Result<ApplicationDataView, SoftchatError> {
    let event =
        SignedNostrEvent::try_from(event).map_err(|_| SoftchatError::InvalidApplicationData)?;
    parse_application_data(&event)
}

/// Select the deterministic latest addressable application-data event.
///
/// # Errors
///
/// All events must share `(author, kind, d)`.
#[cfg_attr(feature = "native-bindings", uniffi::export)]
pub fn latest_application_data(
    candidates: Vec<SignedEvent>,
) -> Result<ApplicationDataView, SoftchatError> {
    let candidates = candidates
        .into_iter()
        .map(|candidate| {
            let event = SignedNostrEvent::try_from(candidate)
                .map_err(|_| SoftchatError::InvalidApplicationData)?;
            let view = parse_application_data(&event)?;
            Ok((
                event.public_key(),
                event.kind(),
                view.identifier.clone(),
                event.created_at(),
                event.id(),
                view,
            ))
        })
        .collect::<Result<Vec<_>, SoftchatError>>()?;
    let identity = candidates
        .first()
        .map(|(author, kind, identifier, _, _, _)| (author.clone(), *kind, identifier.clone()))
        .ok_or(SoftchatError::InvalidApplicationData)?;
    if candidates
        .iter()
        .any(|candidate| (candidate.0.clone(), candidate.1, candidate.2.clone()) != identity)
    {
        return Err(SoftchatError::InvalidApplicationData);
    }
    candidates
        .into_iter()
        .max_by(|left, right| crate::replacement::compare(&left.3, &left.4, &right.3, &right.4))
        .map(|(_, _, _, _, _, view)| view)
        .ok_or(SoftchatError::InvalidApplicationData)
}

fn parse_user_metadata(rumor: &NostrRumor) -> Result<UserMetadataView, SoftchatError> {
    if rumor.kind() != NostrEventKind::USER_METADATA || rumor.tags().len() != 0 {
        return Err(SoftchatError::InvalidUserMetadata);
    }
    if rumor.content().len() > MAX_APP_DATA_JSON_BYTES {
        return Err(SoftchatError::InvalidUserMetadata);
    }
    crate::json::reject_duplicate_keys(rumor.content())
        .map_err(|_| SoftchatError::InvalidUserMetadata)?;
    let mut object: Map<String, Value> =
        serde_json::from_str(rumor.content()).map_err(|_| SoftchatError::InvalidUserMetadata)?;
    let name = take_string(&mut object, "name")?;
    let display_name = take_string(&mut object, "display_name")?;
    let about = take_string(&mut object, "about")?;
    let picture = take_string(&mut object, "picture")?;
    let website = take_string(&mut object, "website")?;
    let banner = take_string(&mut object, "banner")?;
    for value in [&picture, &website, &banner].into_iter().flatten() {
        validate_https(value).map_err(|_| SoftchatError::InvalidUserMetadata)?;
    }
    let bot = match object.remove("bot") {
        Some(Value::Bool(value)) => Some(value),
        Some(_) => return Err(SoftchatError::InvalidUserMetadata),
        None => None,
    };
    let unknown_json =
        serde_json::to_string(&object).map_err(|_| SoftchatError::InvalidUserMetadata)?;
    Ok(UserMetadataView {
        rumor: RumorEvent::from(rumor),
        name,
        display_name,
        about,
        picture,
        website,
        banner,
        bot,
        unknown_json,
    })
}

fn parse_follow_list(rumor: &NostrRumor) -> Result<FollowListView, SoftchatError> {
    if rumor.kind() != NostrEventKind::FOLLOW_LIST
        || !rumor.content().is_empty()
        || rumor.tags().len() > MAX_CONTACTS
    {
        return Err(SoftchatError::InvalidContactList);
    }
    let mut contacts = BTreeMap::new();
    let mut seen = BTreeSet::new();
    let mut contained_duplicates = false;
    for tag in rumor.tags() {
        if tag.first().map(String::as_str) != Some("p") {
            continue;
        }
        let contact = validate_contact(Contact {
            public_key: tag
                .get(1)
                .cloned()
                .ok_or(SoftchatError::InvalidContactList)?,
            relay_hint: tag.get(2).cloned().unwrap_or_default(),
            local_name: tag.get(3).cloned().unwrap_or_default(),
        })?;
        if !seen.insert(contact.public_key.clone()) {
            contained_duplicates = true;
            continue;
        }
        contacts.insert(contact.public_key.clone(), contact);
    }
    Ok(FollowListView {
        rumor: RumorEvent::from(rumor),
        contacts: contacts.into_values().collect(),
        contained_duplicates,
    })
}

fn parse_application_data(event: &SignedNostrEvent) -> Result<ApplicationDataView, SoftchatError> {
    if event.kind() != NostrEventKind::APPLICATION_DATA {
        return Err(SoftchatError::InvalidApplicationData);
    }
    let identifier = exactly_one_d(event.tags())?;
    validate_identifier(&identifier)?;
    Ok(ApplicationDataView {
        event: SignedEvent::from(event),
        identifier,
        content: event.content().to_owned(),
    })
}

fn exactly_one_d<'a>(tags: impl Iterator<Item = &'a [String]>) -> Result<String, SoftchatError> {
    let identifiers = tags
        .filter(|tag| tag.first().map(String::as_str) == Some("d"))
        .map(|tag| {
            tag.get(1)
                .cloned()
                .ok_or(SoftchatError::InvalidApplicationData)
        })
        .collect::<Result<Vec<_>, _>>()?;
    match identifiers.as_slice() {
        [identifier] => Ok(identifier.clone()),
        _ => Err(SoftchatError::InvalidApplicationData),
    }
}

fn parse_unknown_object(json: &str) -> Result<Map<String, Value>, SoftchatError> {
    if json.len() > MAX_APP_DATA_JSON_BYTES {
        return Err(SoftchatError::InvalidUserMetadata);
    }
    serde_json::from_str(json).map_err(|_| SoftchatError::InvalidUserMetadata)
}

fn validate_json_object(json: &str) -> Result<String, SoftchatError> {
    if json.len() > MAX_APP_DATA_JSON_BYTES {
        return Err(SoftchatError::InvalidApplicationData);
    }
    let object: Map<String, Value> =
        serde_json::from_str(json).map_err(|_| SoftchatError::InvalidApplicationData)?;
    serde_json::to_string(&object).map_err(|_| SoftchatError::InvalidApplicationData)
}

fn take_string(
    object: &mut Map<String, Value>,
    key: &str,
) -> Result<Option<String>, SoftchatError> {
    match object.remove(key) {
        Some(Value::String(value)) => Ok(Some(value)),
        Some(_) => Err(SoftchatError::InvalidUserMetadata),
        None => Ok(None),
    }
}

fn insert_optional(object: &mut Map<String, Value>, key: &str, value: Option<String>) {
    if let Some(value) = value {
        object.insert(key.to_owned(), Value::String(value));
    }
}

fn validate_contact(mut contact: Contact) -> Result<Contact, SoftchatError> {
    contact.public_key = NostrPublicKey::from_hex(&contact.public_key)
        .map_err(|_| SoftchatError::InvalidContactList)?
        .to_hex();
    if !contact.relay_hint.is_empty() {
        let url = Url::parse(&contact.relay_hint).map_err(|_| SoftchatError::InvalidContactList)?;
        if !matches!(url.scheme(), "ws" | "wss")
            || url.host_str().is_none()
            || url.fragment().is_some()
        {
            return Err(SoftchatError::InvalidContactList);
        }
    }
    if contact.local_name.chars().count() > 256 {
        return Err(SoftchatError::InvalidContactList);
    }
    Ok(contact)
}

fn validate_identifier(identifier: &str) -> Result<(), SoftchatError> {
    if identifier.is_empty() || identifier.chars().count() > 256 {
        return Err(SoftchatError::InvalidApplicationData);
    }
    Ok(())
}

fn validate_https(value: &str) -> Result<(), SoftchatError> {
    let url = Url::parse(value).map_err(|_| SoftchatError::InvalidUserMetadata)?;
    if url.scheme() != "https" || url.host_str().is_none() || url.fragment().is_some() {
        return Err(SoftchatError::InvalidUserMetadata);
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    const ALICE_SECRET: &str = "5c0c523f52a5b6fad39ed2403092df8cebc36318b39383bca6c00808626fab3a";
    const BOB_SECRET: &str = "4b22aa260e4acb7021e32f38a6cdf4b673c6a277755bfce287e370c924dc936d";

    #[test]
    fn metadata_retains_unknown_fields_and_orders_replacements() -> Result<(), SoftchatError> {
        let alice = LocalIdentity::from_secret_hex(ALICE_SECRET)?;
        let first = alice.create_user_metadata(
            1,
            Some("Alice".to_owned()),
            None,
            None,
            Some("https://cdn.example/a.webp".to_owned()),
            None,
            None,
            Some(false),
            r#"{"future":{"retained":true}}"#,
        )?;
        assert_eq!(first.name.as_deref(), Some("Alice"));
        assert_eq!(first.unknown_json, r#"{"future":{"retained":true}}"#);
        let second =
            alice.create_user_metadata(2, None, None, None, None, None, None, None, "{}")?;
        assert_eq!(
            latest_user_metadata(vec![first.rumor, second.rumor.clone()])?
                .rumor
                .id,
            second.rumor.id
        );

        let tied_first = alice.create_user_metadata(
            3,
            Some("Tied first".to_owned()),
            None,
            None,
            None,
            None,
            None,
            None,
            "{}",
        )?;
        let tied_second = alice.create_user_metadata(
            3,
            Some("Tied second".to_owned()),
            None,
            None,
            None,
            None,
            None,
            None,
            "{}",
        )?;
        let expected = if tied_first.rumor.id < tied_second.rumor.id {
            tied_first.rumor.clone()
        } else {
            tied_second.rumor.clone()
        };
        for order in [
            vec![tied_first.rumor.clone(), tied_second.rumor.clone()],
            vec![tied_second.rumor.clone(), tied_first.rumor.clone()],
        ] {
            assert_eq!(latest_user_metadata(order)?.rumor.id, expected.id);
        }
        Ok(())
    }

    #[test]
    fn contact_writer_is_four_field_sorted_and_reader_keeps_first_duplicate()
    -> Result<(), SoftchatError> {
        let alice = LocalIdentity::from_secret_hex(ALICE_SECRET)?;
        let bob = LocalIdentity::from_secret_hex(BOB_SECRET)?;
        let bob_hex = bob.public_key().to_hex();
        let contact = Contact {
            public_key: bob_hex.clone(),
            relay_hint: String::new(),
            local_name: "Bob".to_owned(),
        };
        let view = alice.create_follow_list(1, vec![contact.clone()])?;
        assert_eq!(view.rumor.tags[0].len(), 4);
        assert_eq!(view.contacts, vec![contact]);

        let duplicate = alice.create_rumor(NostrEventDraft::new(
            2,
            NostrEventKind::FOLLOW_LIST,
            vec![
                NostrTag::new(vec!["p", &bob_hex, "", "First"])?,
                NostrTag::new(vec!["p", &bob_hex, "", "Second"])?,
            ],
            "",
        )?)?;
        let read = parse_follow_list(&duplicate)?;
        assert!(read.contained_duplicates);
        assert_eq!(read.contacts[0].local_name, "First");
        Ok(())
    }

    #[test]
    fn app_data_sync_is_direct_self_encrypted_and_deterministically_replaceable()
    -> Result<(), SoftchatError> {
        let alice = LocalIdentity::from_secret_hex(ALICE_SECRET)?;
        let first = alice.create_app_data_sync(
            1,
            AppDataContext::ReadState,
            r#"{"version":1,"read":1}"#,
        )?;
        let second = alice.create_app_data_sync(
            2,
            AppDataContext::ReadState,
            r#"{"version":1,"read":2}"#,
        )?;
        assert_ne!(first.event.content, first.json);
        assert_eq!(
            alice
                .decrypt_app_data_sync(&SignedNostrEvent::try_from(second.event.clone())?)?
                .json,
            r#"{"read":2,"version":1}"#
        );

        let generic_first =
            alice.create_application_data(1, "drafts".to_owned(), "one".to_owned())?;
        let generic_second =
            alice.create_application_data(2, "drafts".to_owned(), "two".to_owned())?;
        assert_eq!(
            latest_application_data(vec![generic_first.event, generic_second.event.clone()])?
                .content,
            "two"
        );

        let tied_first =
            alice.create_application_data(3, "drafts".to_owned(), "alpha".to_owned())?;
        let tied_second =
            alice.create_application_data(3, "drafts".to_owned(), "beta".to_owned())?;
        let expected_id = std::cmp::min(tied_first.event.id.clone(), tied_second.event.id.clone());
        for order in [
            vec![tied_first.event.clone(), tied_second.event.clone()],
            vec![tied_second.event, tied_first.event],
        ] {
            assert_eq!(latest_application_data(order)?.event.id, expected_id);
        }
        Ok(())
    }
}