Metadata

pub struct GroupMetadataOptions {
    pub name: Option<String>,
    pub image_url_square: Option<String>,
    pub description: Option<String>,
    pub message_disappearing_settings: Option<MessageDisappearingSettings>,
    pub app_data: Option<String>,
}

impl Default for GroupMetadataOptions {
    fn default() -> Self {
        Self {
            name: None,
            image_url_square: None,
            description: None,
            message_disappearing_settings: None,
            app_data: None,
        }
    }
}

pub struct DMMetadataOptions {
    pub message_disappearing_settings: Option<MessageDisappearingSettings>,
}

pub struct GroupMetadata {
    pub conversation_type: ConversationType,
    pub creator_inbox_id: String,
    pub dm_members: Option<DmMembers<InboxId>>,
    pub oneshot_message: Option<OneshotMessage>,
}

pub fn new(
    conversation_type: ConversationType,
    creator_inbox_id: String,
    dm_members: Option<DmMembers<InboxId>>,
    oneshot_message: Option<OneshotMessage>,
) -> Self

impl TryFrom<GroupMetadata> for Vec<u8>
impl TryFrom<&Vec<u8>> for GroupMetadata
impl TryFrom<GroupMetadataProto> for GroupMetadata
impl TryFrom<&Extensions> for GroupMetadata

pub fn extract_group_metadata(
    extensions: &Extensions,
) -> Result<GroupMetadata, GroupMetadataError>

pub struct GroupMutableMetadata {
    pub attributes: HashMap<String, String>,
    pub admin_list: Vec<String>,
    pub super_admin_list: Vec<String>,
}

pub fn new(
    attributes: HashMap<String, String>,
    admin_list: Vec<String>,
    super_admin_list: Vec<String>,
) -> Self

pub fn new_default(
    creator_inbox_id: String,
    commit_log_signer: Option<Secret>,
    opts: GroupMetadataOptions,
) -> Self

pub fn new_dm_default(
    _creator_inbox_id: String,
    _dm_target_inbox_id: &str,
    commit_log_signer: Option<Secret>,
    opts: DMMetadataOptions,
) -> Self

pub fn supported_fields() -> Vec<MetadataField>

pub fn is_admin(&self, inbox_id: &String) -> bool

pub fn is_super_admin(&self, inbox_id: &String) -> bool

pub fn commit_log_signer(&self) -> Option<Secret>

impl TryFrom<GroupMutableMetadata> for Vec<u8>
impl TryFrom<&Vec<u8>> for GroupMutableMetadata
impl TryFrom<GroupMutableMetadataProto> for GroupMutableMetadata
impl TryFrom<&Extensions> for GroupMutableMetadata
impl TryFrom<&OpenMlsGroup> for GroupMutableMetadata

pub fn find_mutable_metadata_extension(
    extensions: &Extensions,
) -> Option<&Vec<u8>>

pub fn extract_group_mutable_metadata(
    group: &OpenMlsGroup,
) -> Result<GroupMutableMetadata, GroupMutableMetadataError>

pub enum MetadataField {
    GroupName,
    Description,
    GroupImageUrlSquare,
    MessageDisappearFromNS,
    MessageDisappearInNS,
    MinimumSupportedProtocolVersion,
    CommitLogSigner,
    AppData,
}

pub const fn as_str(&self) -> &'static str

impl fmt::Display for MetadataField {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

pub struct MessageDisappearingSettings {
    pub from_ns: i64,
    pub in_ns: i64,
}

pub fn new(from_ns: i64, in_ns: i64) -> Self

pub fn is_enabled(&self) -> bool

impl Default for MessageDisappearingSettings {
    fn default() -> Self {
        Self { from_ns: 0, in_ns: 0 }
    }
}

pub struct DmMembers<Id: AsRef<str>> {
    pub member_one_inbox_id: Id,
    pub member_two_inbox_id: Id,
}

impl DmMembers<String> {
    pub fn as_ref(&'a self) -> DmMembers<&'a str>
}

impl<Id: AsRef<str>> Display for DmMembers<Id> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        // Formats as "dm:{sorted_inbox_id_1}:{sorted_inbox_id_2}"
        // IDs are lowercased and sorted for consistent ordering
    }
}

impl<Id: AsRef<str>> From<DmMembers<Id>> for DmMembersProto
impl<Id: AsRef<str>> From<DmMembers<Id>> for String
impl TryFrom<DmMembersProto> for DmMembers<InboxId>

pub enum GroupMetadataError {
    Serialization(prost::EncodeError),
    Deserialization(prost::DecodeError),
    InvalidConversationType,
    MissingExtension,
    InvalidDmMembers,
    MissingDmMember,
    Conversion(xmtp_proto::ConversionError),
}

pub enum GroupMutableMetadataError {
    Serialization(prost::EncodeError),
    Deserialization(prost::DecodeError),
    MissingExtension,
    NonMutableExtensionUpdate,
    TooManyUpdates,
    NoUpdates,
    MissingMetadataField,
}

use xmtp_mls_common::group::GroupMetadataOptions;
use xmtp_mls_common::group_mutable_metadata::MessageDisappearingSettings;

let opts = GroupMetadataOptions {
    name: Some("My Awesome Group".to_string()),
    description: Some("A group for awesome people".to_string()),
    image_url_square: Some("https://example.com/image.png".to_string()),
    message_disappearing_settings: Some(MessageDisappearingSettings::new(
        1_000_000_000,  // from_ns: start time
        86_400_000_000_000,  // in_ns: 24 hours
    )),
    app_data: Some(r#"{"custom":"data"}"#.to_string()),
};

let group = MlsGroup::create_and_insert(
    context,
    ConversationType::Group,
    PolicySet::default(),
    opts,
    None,
)?;

use xmtp_mls_common::group_metadata::extract_group_metadata;
use xmtp_mls_common::group_mutable_metadata::extract_group_mutable_metadata;

// Extract immutable metadata
let metadata = extract_group_metadata(mls_group.extensions())?;
println!("Creator: {}", metadata.creator_inbox_id);

// Extract mutable metadata
let mutable = extract_group_mutable_metadata(&mls_group)?;
if let Some(name) = mutable.attributes.get("group_name") {
    println!("Group name: {}", name);
}

let mutable = extract_group_mutable_metadata(&mls_group)?;
let my_inbox_id = context.inbox_id().to_string();

if mutable.is_super_admin(&my_inbox_id) {
    println!("I'm a super admin!");
} else if mutable.is_admin(&my_inbox_id) {
    println!("I'm a regular admin");
} else {
    println!("I'm a regular member");
}

const MAX_GROUP_DESCRIPTION_LENGTH: usize = 1000;
const MAX_GROUP_NAME_LENGTH: usize = 100;
const MAX_GROUP_IMAGE_URL_LENGTH: usize = 2048;
const MAX_APP_DATA_LENGTH: usize = 8192;