From 68571ec3a8ae932f6dc466ed6117bf6c086b1388 Mon Sep 17 00:00:00 2001 From: mkysel <7513948+mkysel@users.noreply.github.com> Date: Mon, 5 Jan 2026 10:11:48 +0000 Subject: [PATCH] Nightly Protos --- xmtp_proto/proto_version | 2 +- xmtp_proto/src/gen/proto_descriptor.bin | Bin 329104 -> 309619 bytes xmtp_proto/src/gen/xmtp.message_api.v1.rs | 100 +- xmtp_proto/src/gen/xmtp.message_contents.rs | 856 +++++++++--------- xmtp_proto/src/gen/xmtp.mls.database.rs | 46 +- ...xmtp.mls.message_contents.content_types.rs | 176 ++-- .../src/gen/xmtp.mls.message_contents.rs | 650 ++++++------- 7 files changed, 915 insertions(+), 915 deletions(-) diff --git a/xmtp_proto/proto_version b/xmtp_proto/proto_version index 512eec8e86..1be543f5ed 100644 --- a/xmtp_proto/proto_version +++ b/xmtp_proto/proto_version @@ -1 +1 @@ -f5fc12ac686a11c2c2b006c03a07fcc4bf6ec5ea +5795d0e7e2ef9ea2a13b90b1ff0dd63784030597 diff --git a/xmtp_proto/src/gen/proto_descriptor.bin b/xmtp_proto/src/gen/proto_descriptor.bin index 7f6ba3d6a99724f0ebbad0a587b9fa91b926ee30..fe5a6de273f9cd77ec90ac00c31fff2ee9fab864 100644 GIT binary patch delta 16898 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 delta 36272 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, - /// encoded bytes of AuthData - #[prost(bytes = "vec", tag = "2")] - pub auth_data_bytes: ::prost::alloc::vec::Vec, - /// identity key signature of AuthData bytes - #[prost(message, optional, tag = "3")] - pub auth_data_signature: ::core::option::Option< - super::super::message_contents::Signature, - >, -} -impl ::prost::Name for Token { - const NAME: &'static str = "Token"; - const PACKAGE: &'static str = "xmtp.message_api.v1"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_api.v1.Token".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_api.v1.Token".into() - } -} -/// AuthData carries token parameters that are authenticated -/// by the identity key signature. -/// It is embedded in the Token structure as bytes -/// so that the bytes don't need to be reconstructed -/// to verify the token signature. -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct AuthData { - /// address of the wallet - #[prost(string, tag = "1")] - pub wallet_addr: ::prost::alloc::string::String, - /// time when the token was generated/signed - #[prost(uint64, tag = "2")] - pub created_ns: u64, -} -impl ::prost::Name for AuthData { - const NAME: &'static str = "AuthData"; - const PACKAGE: &'static str = "xmtp.message_api.v1"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_api.v1.AuthData".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_api.v1.AuthData".into() - } -} /// This is based off of the go-waku Index type, but with the /// receiverTime and pubsubTopic removed for simplicity. /// Both removed fields are optional @@ -768,3 +718,53 @@ pub mod message_api_server { const NAME: &'static str = SERVICE_NAME; } } +/// Token is used by clients to prove to the nodes +/// that they are serving a specific wallet. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Token { + /// identity key signed by a wallet + #[prost(message, optional, tag = "1")] + pub identity_key: ::core::option::Option, + /// encoded bytes of AuthData + #[prost(bytes = "vec", tag = "2")] + pub auth_data_bytes: ::prost::alloc::vec::Vec, + /// identity key signature of AuthData bytes + #[prost(message, optional, tag = "3")] + pub auth_data_signature: ::core::option::Option< + super::super::message_contents::Signature, + >, +} +impl ::prost::Name for Token { + const NAME: &'static str = "Token"; + const PACKAGE: &'static str = "xmtp.message_api.v1"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_api.v1.Token".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_api.v1.Token".into() + } +} +/// AuthData carries token parameters that are authenticated +/// by the identity key signature. +/// It is embedded in the Token structure as bytes +/// so that the bytes don't need to be reconstructed +/// to verify the token signature. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AuthData { + /// address of the wallet + #[prost(string, tag = "1")] + pub wallet_addr: ::prost::alloc::string::String, + /// time when the token was generated/signed + #[prost(uint64, tag = "2")] + pub created_ns: u64, +} +impl ::prost::Name for AuthData { + const NAME: &'static str = "AuthData"; + const PACKAGE: &'static str = "xmtp.message_api.v1"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_api.v1.AuthData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_api.v1.AuthData".into() + } +} diff --git a/xmtp_proto/src/gen/xmtp.message_contents.rs b/xmtp_proto/src/gen/xmtp.message_contents.rs index 1362df0280..32f9e205c9 100644 --- a/xmtp_proto/src/gen/xmtp.message_contents.rs +++ b/xmtp_proto/src/gen/xmtp.message_contents.rs @@ -320,231 +320,6 @@ impl ::prost::Name for SignedEciesCiphertext { "/xmtp.message_contents.SignedEciesCiphertext".into() } } -/// Unsealed invitation V1 -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct InvitationV1 { - /// topic name chosen for this conversation. - /// It MUST be randomly generated bytes (length >= 32), - /// then base64 encoded without padding - #[prost(string, tag = "1")] - pub topic: ::prost::alloc::string::String, - /// A context object defining metadata - #[prost(message, optional, tag = "2")] - pub context: ::core::option::Option, - /// The user's consent proof - #[prost(message, optional, tag = "4")] - pub consent_proof: ::core::option::Option, - /// message encryption scheme and keys for this conversation. - #[prost(oneof = "invitation_v1::Encryption", tags = "3")] - pub encryption: ::core::option::Option, -} -/// Nested message and enum types in `InvitationV1`. -pub mod invitation_v1 { - /// Supported encryption schemes - /// AES256-GCM-HKDF-SHA256 - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] - pub struct Aes256gcmHkdfsha256 { - /// randomly generated key material (32 bytes) - #[prost(bytes = "vec", tag = "1")] - pub key_material: ::prost::alloc::vec::Vec, - } - impl ::prost::Name for Aes256gcmHkdfsha256 { - const NAME: &'static str = "Aes256gcmHkdfsha256"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.InvitationV1.Aes256gcmHkdfsha256".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.InvitationV1.Aes256gcmHkdfsha256".into() - } - } - /// The context type - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Context { - /// Expected to be a URI (ie xmtp.org/convo1) - #[prost(string, tag = "1")] - pub conversation_id: ::prost::alloc::string::String, - /// Key value map of additional metadata that would be exposed to - /// application developers and could be used for filtering - #[prost(map = "string, string", tag = "2")] - pub metadata: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, - } - impl ::prost::Name for Context { - const NAME: &'static str = "Context"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.InvitationV1.Context".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.InvitationV1.Context".into() - } - } - /// message encryption scheme and keys for this conversation. - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum Encryption { - /// Specify the encryption method to process the key material properly. - #[prost(message, tag = "3")] - Aes256GcmHkdfSha256(Aes256gcmHkdfsha256), - } -} -impl ::prost::Name for InvitationV1 { - const NAME: &'static str = "InvitationV1"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.InvitationV1".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.InvitationV1".into() - } -} -/// Sealed Invitation V1 Header -/// Header carries information that is unencrypted, thus readable by the network -/// it is however authenticated as associated data with the AEAD scheme used -/// to encrypt the invitation body, thus providing tamper evidence. -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct SealedInvitationHeaderV1 { - #[prost(message, optional, tag = "1")] - pub sender: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub recipient: ::core::option::Option, - #[prost(uint64, tag = "3")] - pub created_ns: u64, -} -impl ::prost::Name for SealedInvitationHeaderV1 { - const NAME: &'static str = "SealedInvitationHeaderV1"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.SealedInvitationHeaderV1".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.SealedInvitationHeaderV1".into() - } -} -/// Sealed Invitation V1 -/// Invitation encrypted with key material derived from the sender's and -/// recipient's public key bundles using simplified X3DH where -/// the sender's ephemeral key is replaced with sender's pre-key. -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct SealedInvitationV1 { - /// encoded SealedInvitationHeaderV1 used as associated data for Ciphertext - #[prost(bytes = "vec", tag = "1")] - pub header_bytes: ::prost::alloc::vec::Vec, - /// Ciphertext.payload MUST contain encrypted InvitationV1. - #[prost(message, optional, tag = "2")] - pub ciphertext: ::core::option::Option, -} -impl ::prost::Name for SealedInvitationV1 { - const NAME: &'static str = "SealedInvitationV1"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.SealedInvitationV1".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.SealedInvitationV1".into() - } -} -/// Versioned Sealed Invitation -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct SealedInvitation { - #[prost(oneof = "sealed_invitation::Version", tags = "1")] - pub version: ::core::option::Option, -} -/// Nested message and enum types in `SealedInvitation`. -pub mod sealed_invitation { - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum Version { - #[prost(message, tag = "1")] - V1(super::SealedInvitationV1), - } -} -impl ::prost::Name for SealedInvitation { - const NAME: &'static str = "SealedInvitation"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.SealedInvitation".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.SealedInvitation".into() - } -} -/// Payload for user's consent proof to be set in the invitation -/// Signifying the conversation should be preapproved for the user on receipt -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct ConsentProofPayload { - /// the user's signature in hex format - #[prost(string, tag = "1")] - pub signature: ::prost::alloc::string::String, - /// approximate time when the user signed - #[prost(uint64, tag = "2")] - pub timestamp: u64, - /// version of the payload - #[prost(enumeration = "ConsentProofPayloadVersion", tag = "3")] - pub payload_version: i32, -} -impl ::prost::Name for ConsentProofPayload { - const NAME: &'static str = "ConsentProofPayload"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.ConsentProofPayload".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.ConsentProofPayload".into() - } -} -/// Version of consent proof payload -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum ConsentProofPayloadVersion { - Unspecified = 0, - ConsentProofPayloadVersion1 = 1, -} -impl ConsentProofPayloadVersion { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - Self::Unspecified => "CONSENT_PROOF_PAYLOAD_VERSION_UNSPECIFIED", - Self::ConsentProofPayloadVersion1 => "CONSENT_PROOF_PAYLOAD_VERSION_1", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "CONSENT_PROOF_PAYLOAD_VERSION_UNSPECIFIED" => Some(Self::Unspecified), - "CONSENT_PROOF_PAYLOAD_VERSION_1" => Some(Self::ConsentProofPayloadVersion1), - _ => None, - } - } -} -/// A light pointer for a conversation that contains no decryption keys -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ConversationReference { - #[prost(string, tag = "1")] - pub topic: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub peer_address: ::prost::alloc::string::String, - #[prost(uint64, tag = "3")] - pub created_ns: u64, - #[prost(message, optional, tag = "4")] - pub context: ::core::option::Option, - #[prost(message, optional, tag = "5")] - pub consent_proof_payload: ::core::option::Option, -} -impl ::prost::Name for ConversationReference { - const NAME: &'static str = "ConversationReference"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.ConversationReference".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.ConversationReference".into() - } -} /// PrivateKey generalized to support different key types #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct SignedPrivateKey { @@ -922,23 +697,399 @@ impl ::prost::Name for PrivatePreferencesPayload { "/xmtp.message_contents.PrivatePreferencesPayload".into() } } -/// ContentTypeId is used to identify the type of content stored in a Message. -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct ContentTypeId { - /// authority governing this content type +/// Unsealed invitation V1 +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvitationV1 { + /// topic name chosen for this conversation. + /// It MUST be randomly generated bytes (length >= 32), + /// then base64 encoded without padding #[prost(string, tag = "1")] - pub authority_id: ::prost::alloc::string::String, - /// type identifier - #[prost(string, tag = "2")] - pub type_id: ::prost::alloc::string::String, - /// major version of the type - #[prost(uint32, tag = "3")] - pub version_major: u32, - /// minor version of the type - #[prost(uint32, tag = "4")] - pub version_minor: u32, + pub topic: ::prost::alloc::string::String, + /// A context object defining metadata + #[prost(message, optional, tag = "2")] + pub context: ::core::option::Option, + /// The user's consent proof + #[prost(message, optional, tag = "4")] + pub consent_proof: ::core::option::Option, + /// message encryption scheme and keys for this conversation. + #[prost(oneof = "invitation_v1::Encryption", tags = "3")] + pub encryption: ::core::option::Option, } -impl ::prost::Name for ContentTypeId { +/// Nested message and enum types in `InvitationV1`. +pub mod invitation_v1 { + /// Supported encryption schemes + /// AES256-GCM-HKDF-SHA256 + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct Aes256gcmHkdfsha256 { + /// randomly generated key material (32 bytes) + #[prost(bytes = "vec", tag = "1")] + pub key_material: ::prost::alloc::vec::Vec, + } + impl ::prost::Name for Aes256gcmHkdfsha256 { + const NAME: &'static str = "Aes256gcmHkdfsha256"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.InvitationV1.Aes256gcmHkdfsha256".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.InvitationV1.Aes256gcmHkdfsha256".into() + } + } + /// The context type + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Context { + /// Expected to be a URI (ie xmtp.org/convo1) + #[prost(string, tag = "1")] + pub conversation_id: ::prost::alloc::string::String, + /// Key value map of additional metadata that would be exposed to + /// application developers and could be used for filtering + #[prost(map = "string, string", tag = "2")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + } + impl ::prost::Name for Context { + const NAME: &'static str = "Context"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.InvitationV1.Context".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.InvitationV1.Context".into() + } + } + /// message encryption scheme and keys for this conversation. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Encryption { + /// Specify the encryption method to process the key material properly. + #[prost(message, tag = "3")] + Aes256GcmHkdfSha256(Aes256gcmHkdfsha256), + } +} +impl ::prost::Name for InvitationV1 { + const NAME: &'static str = "InvitationV1"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.InvitationV1".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.InvitationV1".into() + } +} +/// Sealed Invitation V1 Header +/// Header carries information that is unencrypted, thus readable by the network +/// it is however authenticated as associated data with the AEAD scheme used +/// to encrypt the invitation body, thus providing tamper evidence. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SealedInvitationHeaderV1 { + #[prost(message, optional, tag = "1")] + pub sender: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub recipient: ::core::option::Option, + #[prost(uint64, tag = "3")] + pub created_ns: u64, +} +impl ::prost::Name for SealedInvitationHeaderV1 { + const NAME: &'static str = "SealedInvitationHeaderV1"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.SealedInvitationHeaderV1".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.SealedInvitationHeaderV1".into() + } +} +/// Sealed Invitation V1 +/// Invitation encrypted with key material derived from the sender's and +/// recipient's public key bundles using simplified X3DH where +/// the sender's ephemeral key is replaced with sender's pre-key. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SealedInvitationV1 { + /// encoded SealedInvitationHeaderV1 used as associated data for Ciphertext + #[prost(bytes = "vec", tag = "1")] + pub header_bytes: ::prost::alloc::vec::Vec, + /// Ciphertext.payload MUST contain encrypted InvitationV1. + #[prost(message, optional, tag = "2")] + pub ciphertext: ::core::option::Option, +} +impl ::prost::Name for SealedInvitationV1 { + const NAME: &'static str = "SealedInvitationV1"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.SealedInvitationV1".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.SealedInvitationV1".into() + } +} +/// Versioned Sealed Invitation +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SealedInvitation { + #[prost(oneof = "sealed_invitation::Version", tags = "1")] + pub version: ::core::option::Option, +} +/// Nested message and enum types in `SealedInvitation`. +pub mod sealed_invitation { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Version { + #[prost(message, tag = "1")] + V1(super::SealedInvitationV1), + } +} +impl ::prost::Name for SealedInvitation { + const NAME: &'static str = "SealedInvitation"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.SealedInvitation".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.SealedInvitation".into() + } +} +/// Payload for user's consent proof to be set in the invitation +/// Signifying the conversation should be preapproved for the user on receipt +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ConsentProofPayload { + /// the user's signature in hex format + #[prost(string, tag = "1")] + pub signature: ::prost::alloc::string::String, + /// approximate time when the user signed + #[prost(uint64, tag = "2")] + pub timestamp: u64, + /// version of the payload + #[prost(enumeration = "ConsentProofPayloadVersion", tag = "3")] + pub payload_version: i32, +} +impl ::prost::Name for ConsentProofPayload { + const NAME: &'static str = "ConsentProofPayload"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.ConsentProofPayload".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.ConsentProofPayload".into() + } +} +/// Version of consent proof payload +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ConsentProofPayloadVersion { + Unspecified = 0, + ConsentProofPayloadVersion1 = 1, +} +impl ConsentProofPayloadVersion { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "CONSENT_PROOF_PAYLOAD_VERSION_UNSPECIFIED", + Self::ConsentProofPayloadVersion1 => "CONSENT_PROOF_PAYLOAD_VERSION_1", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CONSENT_PROOF_PAYLOAD_VERSION_UNSPECIFIED" => Some(Self::Unspecified), + "CONSENT_PROOF_PAYLOAD_VERSION_1" => Some(Self::ConsentProofPayloadVersion1), + _ => None, + } + } +} +/// A light pointer for a conversation that contains no decryption keys +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConversationReference { + #[prost(string, tag = "1")] + pub topic: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub peer_address: ::prost::alloc::string::String, + #[prost(uint64, tag = "3")] + pub created_ns: u64, + #[prost(message, optional, tag = "4")] + pub context: ::core::option::Option, + #[prost(message, optional, tag = "5")] + pub consent_proof_payload: ::core::option::Option, +} +impl ::prost::Name for ConversationReference { + const NAME: &'static str = "ConversationReference"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.ConversationReference".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.ConversationReference".into() + } +} +/// Message header is encoded separately as the bytes are also used +/// as associated data for authenticated encryption +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct MessageHeaderV1 { + #[prost(message, optional, tag = "1")] + pub sender: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub recipient: ::core::option::Option, + #[prost(uint64, tag = "3")] + pub timestamp: u64, +} +impl ::prost::Name for MessageHeaderV1 { + const NAME: &'static str = "MessageHeaderV1"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.MessageHeaderV1".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.MessageHeaderV1".into() + } +} +/// Message is the top level protocol element +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct MessageV1 { + /// encapsulates encoded MessageHeaderV1 + #[prost(bytes = "vec", tag = "1")] + pub header_bytes: ::prost::alloc::vec::Vec, + /// Ciphertext.payload MUST contain encrypted EncodedContent + #[prost(message, optional, tag = "2")] + pub ciphertext: ::core::option::Option, +} +impl ::prost::Name for MessageV1 { + const NAME: &'static str = "MessageV1"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.MessageV1".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.MessageV1".into() + } +} +/// Message header carries information that is not encrypted, and is therefore +/// observable by the network. It is however authenticated as associated data +/// of the AEAD encryption used to protect the message, +/// thus providing tamper evidence. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct MessageHeaderV2 { + /// sender specified message creation time + #[prost(uint64, tag = "1")] + pub created_ns: u64, + /// the topic the message belongs to + #[prost(string, tag = "2")] + pub topic: ::prost::alloc::string::String, +} +impl ::prost::Name for MessageHeaderV2 { + const NAME: &'static str = "MessageHeaderV2"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.MessageHeaderV2".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.MessageHeaderV2".into() + } +} +/// Message combines the encoded header with the encrypted payload. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct MessageV2 { + /// encapsulates encoded MessageHeaderV2 + #[prost(bytes = "vec", tag = "1")] + pub header_bytes: ::prost::alloc::vec::Vec, + /// Ciphertext.payload MUST contain encrypted SignedContent + #[prost(message, optional, tag = "2")] + pub ciphertext: ::core::option::Option, + /// HMAC of the message ciphertext, with the HMAC key derived from the topic + /// key + #[prost(bytes = "vec", optional, tag = "3")] + pub sender_hmac: ::core::option::Option<::prost::alloc::vec::Vec>, + /// Flag indicating whether the message should be pushed from a notification + /// server + #[prost(bool, optional, tag = "4")] + pub should_push: ::core::option::Option, +} +impl ::prost::Name for MessageV2 { + const NAME: &'static str = "MessageV2"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.MessageV2".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.MessageV2".into() + } +} +/// Versioned Message +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Message { + #[prost(oneof = "message::Version", tags = "1, 2")] + pub version: ::core::option::Option, +} +/// Nested message and enum types in `Message`. +pub mod message { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Version { + #[prost(message, tag = "1")] + V1(super::MessageV1), + #[prost(message, tag = "2")] + V2(super::MessageV2), + } +} +impl ::prost::Name for Message { + const NAME: &'static str = "Message"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.Message".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.Message".into() + } +} +/// DecodedMessage represents the decrypted message contents. +/// DecodedMessage instances are not stored on the network, but +/// may be serialized and stored by clients +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DecodedMessage { + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub message_version: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub sender_address: ::prost::alloc::string::String, + #[prost(string, optional, tag = "4")] + pub recipient_address: ::core::option::Option<::prost::alloc::string::String>, + #[prost(uint64, tag = "5")] + pub sent_ns: u64, + #[prost(string, tag = "6")] + pub content_topic: ::prost::alloc::string::String, + #[prost(message, optional, tag = "7")] + pub conversation: ::core::option::Option, + /// encapsulates EncodedContent + #[prost(bytes = "vec", tag = "8")] + pub content_bytes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for DecodedMessage { + const NAME: &'static str = "DecodedMessage"; + const PACKAGE: &'static str = "xmtp.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.message_contents.DecodedMessage".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.message_contents.DecodedMessage".into() + } +} +/// ContentTypeId is used to identify the type of content stored in a Message. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ContentTypeId { + /// authority governing this content type + #[prost(string, tag = "1")] + pub authority_id: ::prost::alloc::string::String, + /// type identifier + #[prost(string, tag = "2")] + pub type_id: ::prost::alloc::string::String, + /// major version of the type + #[prost(uint32, tag = "3")] + pub version_major: u32, + /// minor version of the type + #[prost(uint32, tag = "4")] + pub version_minor: u32, +} +impl ::prost::Name for ContentTypeId { const NAME: &'static str = "ContentTypeId"; const PACKAGE: &'static str = "xmtp.message_contents"; fn full_name() -> ::prost::alloc::string::String { @@ -1081,65 +1232,6 @@ impl ::prost::Name for Composite { "/xmtp.message_contents.Composite".into() } } -/// LEGACY: User key bundle V1 using PublicKeys. -/// The PublicKeys MUST be signed. -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct ContactBundleV1 { - #[prost(message, optional, tag = "1")] - pub key_bundle: ::core::option::Option, -} -impl ::prost::Name for ContactBundleV1 { - const NAME: &'static str = "ContactBundleV1"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.ContactBundleV1".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.ContactBundleV1".into() - } -} -/// User key bundle V2 using SignedPublicKeys. -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct ContactBundleV2 { - #[prost(message, optional, tag = "1")] - pub key_bundle: ::core::option::Option, -} -impl ::prost::Name for ContactBundleV2 { - const NAME: &'static str = "ContactBundleV2"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.ContactBundleV2".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.ContactBundleV2".into() - } -} -/// Versioned ContactBundle -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct ContactBundle { - #[prost(oneof = "contact_bundle::Version", tags = "1, 2")] - pub version: ::core::option::Option, -} -/// Nested message and enum types in `ContactBundle`. -pub mod contact_bundle { - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum Version { - #[prost(message, tag = "1")] - V1(super::ContactBundleV1), - #[prost(message, tag = "2")] - V2(super::ContactBundleV2), - } -} -impl ::prost::Name for ContactBundle { - const NAME: &'static str = "ContactBundle"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.ContactBundle".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.ContactBundle".into() - } -} /// EciesMessage is a wrapper for ECIES encrypted payloads #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct EciesMessage { @@ -1246,172 +1338,80 @@ impl ::prost::Name for FrameAction { "/xmtp.message_contents.FrameAction".into() } } -/// Message header is encoded separately as the bytes are also used -/// as associated data for authenticated encryption -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct MessageHeaderV1 { - #[prost(message, optional, tag = "1")] - pub sender: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub recipient: ::core::option::Option, - #[prost(uint64, tag = "3")] - pub timestamp: u64, -} -impl ::prost::Name for MessageHeaderV1 { - const NAME: &'static str = "MessageHeaderV1"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.MessageHeaderV1".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.MessageHeaderV1".into() - } -} -/// Message is the top level protocol element +/// SignedPayload is a wrapper for a signature and a payload #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct MessageV1 { - /// encapsulates encoded MessageHeaderV1 +pub struct SignedPayload { #[prost(bytes = "vec", tag = "1")] - pub header_bytes: ::prost::alloc::vec::Vec, - /// Ciphertext.payload MUST contain encrypted EncodedContent + pub payload: ::prost::alloc::vec::Vec, #[prost(message, optional, tag = "2")] - pub ciphertext: ::core::option::Option, + pub signature: ::core::option::Option, } -impl ::prost::Name for MessageV1 { - const NAME: &'static str = "MessageV1"; +impl ::prost::Name for SignedPayload { + const NAME: &'static str = "SignedPayload"; const PACKAGE: &'static str = "xmtp.message_contents"; fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.MessageV1".into() + "xmtp.message_contents.SignedPayload".into() } fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.MessageV1".into() + "/xmtp.message_contents.SignedPayload".into() } } -/// Message header carries information that is not encrypted, and is therefore -/// observable by the network. It is however authenticated as associated data -/// of the AEAD encryption used to protect the message, -/// thus providing tamper evidence. +/// LEGACY: User key bundle V1 using PublicKeys. +/// The PublicKeys MUST be signed. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct MessageHeaderV2 { - /// sender specified message creation time - #[prost(uint64, tag = "1")] - pub created_ns: u64, - /// the topic the message belongs to - #[prost(string, tag = "2")] - pub topic: ::prost::alloc::string::String, +pub struct ContactBundleV1 { + #[prost(message, optional, tag = "1")] + pub key_bundle: ::core::option::Option, } -impl ::prost::Name for MessageHeaderV2 { - const NAME: &'static str = "MessageHeaderV2"; +impl ::prost::Name for ContactBundleV1 { + const NAME: &'static str = "ContactBundleV1"; const PACKAGE: &'static str = "xmtp.message_contents"; fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.MessageHeaderV2".into() + "xmtp.message_contents.ContactBundleV1".into() } fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.MessageHeaderV2".into() + "/xmtp.message_contents.ContactBundleV1".into() } } -/// Message combines the encoded header with the encrypted payload. +/// User key bundle V2 using SignedPublicKeys. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct MessageV2 { - /// encapsulates encoded MessageHeaderV2 - #[prost(bytes = "vec", tag = "1")] - pub header_bytes: ::prost::alloc::vec::Vec, - /// Ciphertext.payload MUST contain encrypted SignedContent - #[prost(message, optional, tag = "2")] - pub ciphertext: ::core::option::Option, - /// HMAC of the message ciphertext, with the HMAC key derived from the topic - /// key - #[prost(bytes = "vec", optional, tag = "3")] - pub sender_hmac: ::core::option::Option<::prost::alloc::vec::Vec>, - /// Flag indicating whether the message should be pushed from a notification - /// server - #[prost(bool, optional, tag = "4")] - pub should_push: ::core::option::Option, +pub struct ContactBundleV2 { + #[prost(message, optional, tag = "1")] + pub key_bundle: ::core::option::Option, } -impl ::prost::Name for MessageV2 { - const NAME: &'static str = "MessageV2"; +impl ::prost::Name for ContactBundleV2 { + const NAME: &'static str = "ContactBundleV2"; const PACKAGE: &'static str = "xmtp.message_contents"; fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.MessageV2".into() + "xmtp.message_contents.ContactBundleV2".into() } fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.MessageV2".into() + "/xmtp.message_contents.ContactBundleV2".into() } } -/// Versioned Message +/// Versioned ContactBundle #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct Message { - #[prost(oneof = "message::Version", tags = "1, 2")] - pub version: ::core::option::Option, +pub struct ContactBundle { + #[prost(oneof = "contact_bundle::Version", tags = "1, 2")] + pub version: ::core::option::Option, } -/// Nested message and enum types in `Message`. -pub mod message { +/// Nested message and enum types in `ContactBundle`. +pub mod contact_bundle { #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] pub enum Version { #[prost(message, tag = "1")] - V1(super::MessageV1), + V1(super::ContactBundleV1), #[prost(message, tag = "2")] - V2(super::MessageV2), - } -} -impl ::prost::Name for Message { - const NAME: &'static str = "Message"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.Message".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.Message".into() - } -} -/// DecodedMessage represents the decrypted message contents. -/// DecodedMessage instances are not stored on the network, but -/// may be serialized and stored by clients -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DecodedMessage { - #[prost(string, tag = "1")] - pub id: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub message_version: ::prost::alloc::string::String, - #[prost(string, tag = "3")] - pub sender_address: ::prost::alloc::string::String, - #[prost(string, optional, tag = "4")] - pub recipient_address: ::core::option::Option<::prost::alloc::string::String>, - #[prost(uint64, tag = "5")] - pub sent_ns: u64, - #[prost(string, tag = "6")] - pub content_topic: ::prost::alloc::string::String, - #[prost(message, optional, tag = "7")] - pub conversation: ::core::option::Option, - /// encapsulates EncodedContent - #[prost(bytes = "vec", tag = "8")] - pub content_bytes: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for DecodedMessage { - const NAME: &'static str = "DecodedMessage"; - const PACKAGE: &'static str = "xmtp.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.DecodedMessage".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.DecodedMessage".into() + V2(super::ContactBundleV2), } } -/// SignedPayload is a wrapper for a signature and a payload -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct SignedPayload { - #[prost(bytes = "vec", tag = "1")] - pub payload: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "2")] - pub signature: ::core::option::Option, -} -impl ::prost::Name for SignedPayload { - const NAME: &'static str = "SignedPayload"; +impl ::prost::Name for ContactBundle { + const NAME: &'static str = "ContactBundle"; const PACKAGE: &'static str = "xmtp.message_contents"; fn full_name() -> ::prost::alloc::string::String { - "xmtp.message_contents.SignedPayload".into() + "xmtp.message_contents.ContactBundle".into() } fn type_url() -> ::prost::alloc::string::String { - "/xmtp.message_contents.SignedPayload".into() + "/xmtp.message_contents.ContactBundle".into() } } diff --git a/xmtp_proto/src/gen/xmtp.mls.database.rs b/xmtp_proto/src/gen/xmtp.mls.database.rs index 4f51021643..9aed772deb 100644 --- a/xmtp_proto/src/gen/xmtp.mls.database.rs +++ b/xmtp_proto/src/gen/xmtp.mls.database.rs @@ -1,4 +1,27 @@ // This file is @generated by prost-build. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Task { + #[prost(oneof = "task::Task", tags = "1")] + pub task: ::core::option::Option, +} +/// Nested message and enum types in `Task`. +pub mod task { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Task { + #[prost(message, tag = "1")] + ProcessWelcomePointer(super::super::message_contents::WelcomePointer), + } +} +impl ::prost::Name for Task { + const NAME: &'static str = "Task"; + const PACKAGE: &'static str = "xmtp.mls.database"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.database.Task".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.database.Task".into() + } +} /// The data required to publish a message #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct SendMessageData { @@ -591,26 +614,3 @@ impl PermissionPolicyOption { } } } -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct Task { - #[prost(oneof = "task::Task", tags = "1")] - pub task: ::core::option::Option, -} -/// Nested message and enum types in `Task`. -pub mod task { - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum Task { - #[prost(message, tag = "1")] - ProcessWelcomePointer(super::super::message_contents::WelcomePointer), - } -} -impl ::prost::Name for Task { - const NAME: &'static str = "Task"; - const PACKAGE: &'static str = "xmtp.mls.database"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.database.Task".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.database.Task".into() - } -} diff --git a/xmtp_proto/src/gen/xmtp.mls.message_contents.content_types.rs b/xmtp_proto/src/gen/xmtp.mls.message_contents.content_types.rs index 0d7761f34f..0c4f5f816e 100644 --- a/xmtp_proto/src/gen/xmtp.mls.message_contents.content_types.rs +++ b/xmtp_proto/src/gen/xmtp.mls.message_contents.content_types.rs @@ -1,92 +1,4 @@ // This file is @generated by prost-build. -/// DeleteMessage message type -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct DeleteMessage { - /// ID of the message to delete - #[prost(string, tag = "1")] - pub message_id: ::prost::alloc::string::String, -} -impl ::prost::Name for DeleteMessage { - const NAME: &'static str = "DeleteMessage"; - const PACKAGE: &'static str = "xmtp.mls.message_contents.content_types"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.content_types.DeleteMessage".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.content_types.DeleteMessage".into() - } -} -/// LeaveRequest message type -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct LeaveRequest { - /// A serialized AuthenticatedNote containing the sender's signed, member-only verifiable statement - #[prost(bytes = "vec", optional, tag = "1")] - pub authenticated_note: ::core::option::Option<::prost::alloc::vec::Vec>, -} -impl ::prost::Name for LeaveRequest { - const NAME: &'static str = "LeaveRequest"; - const PACKAGE: &'static str = "xmtp.mls.message_contents.content_types"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.content_types.LeaveRequest".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.content_types.LeaveRequest".into() - } -} -/// MultiRemoteAttachment message type -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MultiRemoteAttachment { - /// Array of attachment information - #[prost(message, repeated, tag = "1")] - pub attachments: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for MultiRemoteAttachment { - const NAME: &'static str = "MultiRemoteAttachment"; - const PACKAGE: &'static str = "xmtp.mls.message_contents.content_types"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.content_types.MultiRemoteAttachment".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.content_types.MultiRemoteAttachment".into() - } -} -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct RemoteAttachmentInfo { - /// The SHA256 hash of the remote content - #[prost(string, tag = "1")] - pub content_digest: ::prost::alloc::string::String, - /// A 32 byte array for decrypting the remote content payload - #[prost(bytes = "vec", tag = "2")] - pub secret: ::prost::alloc::vec::Vec, - /// A byte array for the nonce used to encrypt the remote content payload - #[prost(bytes = "vec", tag = "3")] - pub nonce: ::prost::alloc::vec::Vec, - /// A byte array for the salt used to encrypt the remote content payload - #[prost(bytes = "vec", tag = "4")] - pub salt: ::prost::alloc::vec::Vec, - /// The scheme of the URL. Must be " - #[prost(string, tag = "5")] - pub scheme: ::prost::alloc::string::String, - /// The URL of the remote content - #[prost(string, tag = "6")] - pub url: ::prost::alloc::string::String, - /// The size of the encrypted content in bytes (max size of 4GB) - #[prost(uint32, optional, tag = "7")] - pub content_length: ::core::option::Option, - /// The filename of the remote content - #[prost(string, optional, tag = "8")] - pub filename: ::core::option::Option<::prost::alloc::string::String>, -} -impl ::prost::Name for RemoteAttachmentInfo { - const NAME: &'static str = "RemoteAttachmentInfo"; - const PACKAGE: &'static str = "xmtp.mls.message_contents.content_types"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.content_types.RemoteAttachmentInfo".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.content_types.RemoteAttachmentInfo".into() - } -} /// Reaction message type #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReactionV2 { @@ -242,3 +154,91 @@ impl ::prost::Name for Call { "/xmtp.mls.message_contents.content_types.Call".into() } } +/// LeaveRequest message type +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct LeaveRequest { + /// A serialized AuthenticatedNote containing the sender's signed, member-only verifiable statement + #[prost(bytes = "vec", optional, tag = "1")] + pub authenticated_note: ::core::option::Option<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for LeaveRequest { + const NAME: &'static str = "LeaveRequest"; + const PACKAGE: &'static str = "xmtp.mls.message_contents.content_types"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.content_types.LeaveRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.content_types.LeaveRequest".into() + } +} +/// MultiRemoteAttachment message type +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MultiRemoteAttachment { + /// Array of attachment information + #[prost(message, repeated, tag = "1")] + pub attachments: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MultiRemoteAttachment { + const NAME: &'static str = "MultiRemoteAttachment"; + const PACKAGE: &'static str = "xmtp.mls.message_contents.content_types"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.content_types.MultiRemoteAttachment".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.content_types.MultiRemoteAttachment".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct RemoteAttachmentInfo { + /// The SHA256 hash of the remote content + #[prost(string, tag = "1")] + pub content_digest: ::prost::alloc::string::String, + /// A 32 byte array for decrypting the remote content payload + #[prost(bytes = "vec", tag = "2")] + pub secret: ::prost::alloc::vec::Vec, + /// A byte array for the nonce used to encrypt the remote content payload + #[prost(bytes = "vec", tag = "3")] + pub nonce: ::prost::alloc::vec::Vec, + /// A byte array for the salt used to encrypt the remote content payload + #[prost(bytes = "vec", tag = "4")] + pub salt: ::prost::alloc::vec::Vec, + /// The scheme of the URL. Must be " + #[prost(string, tag = "5")] + pub scheme: ::prost::alloc::string::String, + /// The URL of the remote content + #[prost(string, tag = "6")] + pub url: ::prost::alloc::string::String, + /// The size of the encrypted content in bytes (max size of 4GB) + #[prost(uint32, optional, tag = "7")] + pub content_length: ::core::option::Option, + /// The filename of the remote content + #[prost(string, optional, tag = "8")] + pub filename: ::core::option::Option<::prost::alloc::string::String>, +} +impl ::prost::Name for RemoteAttachmentInfo { + const NAME: &'static str = "RemoteAttachmentInfo"; + const PACKAGE: &'static str = "xmtp.mls.message_contents.content_types"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.content_types.RemoteAttachmentInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.content_types.RemoteAttachmentInfo".into() + } +} +/// DeleteMessage message type +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DeleteMessage { + /// ID of the message to delete + #[prost(string, tag = "1")] + pub message_id: ::prost::alloc::string::String, +} +impl ::prost::Name for DeleteMessage { + const NAME: &'static str = "DeleteMessage"; + const PACKAGE: &'static str = "xmtp.mls.message_contents.content_types"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.content_types.DeleteMessage".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.content_types.DeleteMessage".into() + } +} diff --git a/xmtp_proto/src/gen/xmtp.mls.message_contents.rs b/xmtp_proto/src/gen/xmtp.mls.message_contents.rs index 9a06b4d74d..1262ee050f 100644 --- a/xmtp_proto/src/gen/xmtp.mls.message_contents.rs +++ b/xmtp_proto/src/gen/xmtp.mls.message_contents.rs @@ -275,6 +275,185 @@ impl WelcomeWrapperAlgorithm { } } } +/// A group member and affected installation IDs +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct MembershipChange { + #[prost(bytes = "vec", repeated, tag = "1")] + pub installation_ids: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, + #[prost(string, tag = "2")] + pub account_address: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub initiated_by_account_address: ::prost::alloc::string::String, +} +impl ::prost::Name for MembershipChange { + const NAME: &'static str = "MembershipChange"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.MembershipChange".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.MembershipChange".into() + } +} +/// The group membership change proto +/// +/// protolint:disable REPEATED_FIELD_NAMES_PLURALIZED +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GroupMembershipChanges { + /// Members that have been added in the commit + #[prost(message, repeated, tag = "1")] + pub members_added: ::prost::alloc::vec::Vec, + /// Members that have been removed in the commit + #[prost(message, repeated, tag = "2")] + pub members_removed: ::prost::alloc::vec::Vec, + /// Installations that have been added in the commit, grouped by member + #[prost(message, repeated, tag = "3")] + pub installations_added: ::prost::alloc::vec::Vec, + /// Installations removed in the commit, grouped by member + #[prost(message, repeated, tag = "4")] + pub installations_removed: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for GroupMembershipChanges { + const NAME: &'static str = "GroupMembershipChanges"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.GroupMembershipChanges".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.GroupMembershipChanges".into() + } +} +/// A summary of the changes in a commit. +/// Includes added/removed inboxes and changes to metadata +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GroupUpdated { + #[prost(string, tag = "1")] + pub initiated_by_inbox_id: ::prost::alloc::string::String, + /// The inboxes added in the commit + #[prost(message, repeated, tag = "2")] + pub added_inboxes: ::prost::alloc::vec::Vec, + /// The inboxes removed in the commit + #[prost(message, repeated, tag = "3")] + pub removed_inboxes: ::prost::alloc::vec::Vec, + /// The metadata changes in the commit + #[prost(message, repeated, tag = "4")] + pub metadata_field_changes: ::prost::alloc::vec::Vec< + group_updated::MetadataFieldChange, + >, + /// / The inboxes that were removed from the group in response to pending-remove/self-remove requests + #[prost(message, repeated, tag = "5")] + pub left_inboxes: ::prost::alloc::vec::Vec, + /// The inboxes that were added to admin list in the commit + #[prost(message, repeated, tag = "6")] + pub added_admin_inboxes: ::prost::alloc::vec::Vec, + /// The inboxes that were removed from admin list in the commit + #[prost(message, repeated, tag = "7")] + pub removed_admin_inboxes: ::prost::alloc::vec::Vec, + /// The inboxes that were added to super admin list in the commit + #[prost(message, repeated, tag = "8")] + pub added_super_admin_inboxes: ::prost::alloc::vec::Vec, + /// The inboxes that were removed from super admin list in the commit + #[prost(message, repeated, tag = "9")] + pub removed_super_admin_inboxes: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `GroupUpdated`. +pub mod group_updated { + /// An inbox that was added or removed in this commit + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct Inbox { + #[prost(string, tag = "1")] + pub inbox_id: ::prost::alloc::string::String, + } + impl ::prost::Name for Inbox { + const NAME: &'static str = "Inbox"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.GroupUpdated.Inbox".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.GroupUpdated.Inbox".into() + } + } + /// A summary of a change to the mutable metadata + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct MetadataFieldChange { + /// The field that was changed + #[prost(string, tag = "1")] + pub field_name: ::prost::alloc::string::String, + /// The previous value + #[prost(string, optional, tag = "2")] + pub old_value: ::core::option::Option<::prost::alloc::string::String>, + /// The updated value + #[prost(string, optional, tag = "3")] + pub new_value: ::core::option::Option<::prost::alloc::string::String>, + } + impl ::prost::Name for MetadataFieldChange { + const NAME: &'static str = "MetadataFieldChange"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.GroupUpdated.MetadataFieldChange".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.GroupUpdated.MetadataFieldChange".into() + } + } +} +impl ::prost::Name for GroupUpdated { + const NAME: &'static str = "GroupUpdated"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.GroupUpdated".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.GroupUpdated".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct OneshotMessage { + #[prost(oneof = "oneshot_message::MessageType", tags = "1")] + pub message_type: ::core::option::Option, +} +/// Nested message and enum types in `OneshotMessage`. +pub mod oneshot_message { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum MessageType { + #[prost(message, tag = "1")] + ReaddRequest(super::ReaddRequest), + } +} +impl ::prost::Name for OneshotMessage { + const NAME: &'static str = "OneshotMessage"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.OneshotMessage".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.OneshotMessage".into() + } +} +/// A request sent by an installation to recover from a fork. Other members +/// may remove and readd that installation from the group. +/// XIP: +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReaddRequest { + #[prost(bytes = "vec", tag = "1")] + pub group_id: ::prost::alloc::vec::Vec, + /// The sequence ID of the latest commit log entry at the time the request + /// is sent; used to disambiguate cases where an installation forks + /// and is readded multiple times. + #[prost(uint64, tag = "2")] + pub latest_commit_sequence_id: u64, +} +impl ::prost::Name for ReaddRequest { + const NAME: &'static str = "ReaddRequest"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.ReaddRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.ReaddRequest".into() + } +} /// ContentTypeId is used to identify the type of content stored in a Message. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ContentTypeId { @@ -440,229 +619,24 @@ pub enum Compression { Deflate = 0, Gzip = 1, } -impl Compression { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - Self::Deflate => "COMPRESSION_DEFLATE", - Self::Gzip => "COMPRESSION_GZIP", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "COMPRESSION_DEFLATE" => Some(Self::Deflate), - "COMPRESSION_GZIP" => Some(Self::Gzip), - _ => None, - } - } -} -/// Contains a mapping of `inbox_id` -> `sequence_id` for all members of a group. -/// Designed to be stored in the group context extension of the MLS group -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct GroupMembership { - #[prost(map = "string, uint64", tag = "1")] - pub members: ::std::collections::HashMap<::prost::alloc::string::String, u64>, - /// List of installations that failed to be added due to errors encountered during the evaluation process. - #[prost(bytes = "vec", repeated, tag = "2")] - pub failed_installations: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, -} -impl ::prost::Name for GroupMembership { - const NAME: &'static str = "GroupMembership"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.GroupMembership".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.GroupMembership".into() - } -} -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct OneshotMessage { - #[prost(oneof = "oneshot_message::MessageType", tags = "1")] - pub message_type: ::core::option::Option, -} -/// Nested message and enum types in `OneshotMessage`. -pub mod oneshot_message { - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum MessageType { - #[prost(message, tag = "1")] - ReaddRequest(super::ReaddRequest), - } -} -impl ::prost::Name for OneshotMessage { - const NAME: &'static str = "OneshotMessage"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.OneshotMessage".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.OneshotMessage".into() - } -} -/// A request sent by an installation to recover from a fork. Other members -/// may remove and readd that installation from the group. -/// XIP: -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct ReaddRequest { - #[prost(bytes = "vec", tag = "1")] - pub group_id: ::prost::alloc::vec::Vec, - /// The sequence ID of the latest commit log entry at the time the request - /// is sent; used to disambiguate cases where an installation forks - /// and is readded multiple times. - #[prost(uint64, tag = "2")] - pub latest_commit_sequence_id: u64, -} -impl ::prost::Name for ReaddRequest { - const NAME: &'static str = "ReaddRequest"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.ReaddRequest".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.ReaddRequest".into() - } -} -/// Parent message for group metadata -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct GroupMetadataV1 { - #[prost(enumeration = "ConversationType", tag = "1")] - pub conversation_type: i32, - /// This will be removed soon - #[prost(string, tag = "2")] - pub creator_account_address: ::prost::alloc::string::String, - #[prost(string, tag = "3")] - pub creator_inbox_id: ::prost::alloc::string::String, - /// Should only be present for CONVERSATION_TYPE_DM - #[prost(message, optional, tag = "4")] - pub dm_members: ::core::option::Option, - /// Should only be present for CONVERSATION_TYPE_ONESHOT - #[prost(message, optional, tag = "5")] - pub oneshot_message: ::core::option::Option, -} -impl ::prost::Name for GroupMetadataV1 { - const NAME: &'static str = "GroupMetadataV1"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.GroupMetadataV1".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.GroupMetadataV1".into() - } -} -/// Wrapper around an Inbox Id -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct Inbox { - #[prost(string, tag = "1")] - pub inbox_id: ::prost::alloc::string::String, -} -impl ::prost::Name for Inbox { - const NAME: &'static str = "Inbox"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.Inbox".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.Inbox".into() - } -} -/// Ordering does not matter here -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct DmMembers { - #[prost(message, optional, tag = "1")] - pub dm_member_one: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub dm_member_two: ::core::option::Option, -} -impl ::prost::Name for DmMembers { - const NAME: &'static str = "DmMembers"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.DmMembers".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.DmMembers".into() - } -} -/// Defines the type of conversation -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum ConversationType { - Unspecified = 0, - Group = 1, - Dm = 2, - Sync = 3, - Oneshot = 4, -} -impl ConversationType { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - Self::Unspecified => "CONVERSATION_TYPE_UNSPECIFIED", - Self::Group => "CONVERSATION_TYPE_GROUP", - Self::Dm => "CONVERSATION_TYPE_DM", - Self::Sync => "CONVERSATION_TYPE_SYNC", - Self::Oneshot => "CONVERSATION_TYPE_ONESHOT", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "CONVERSATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified), - "CONVERSATION_TYPE_GROUP" => Some(Self::Group), - "CONVERSATION_TYPE_DM" => Some(Self::Dm), - "CONVERSATION_TYPE_SYNC" => Some(Self::Sync), - "CONVERSATION_TYPE_ONESHOT" => Some(Self::Oneshot), - _ => None, - } - } -} -/// Message for group mutable metadata -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct GroupMutableMetadataV1 { - /// Map to store various metadata attributes (Group name, etc.) - #[prost(map = "string, string", tag = "1")] - pub attributes: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, - #[prost(message, optional, tag = "2")] - pub admin_list: ::core::option::Option, - /// Creator starts as only super_admin - /// Only super_admin can add/remove other super_admin - #[prost(message, optional, tag = "3")] - pub super_admin_list: ::core::option::Option, -} -impl ::prost::Name for GroupMutableMetadataV1 { - const NAME: &'static str = "GroupMutableMetadataV1"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.GroupMutableMetadataV1".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.GroupMutableMetadataV1".into() - } -} -/// Wrapper around a list of repeated Inbox Ids -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct Inboxes { - #[prost(string, repeated, tag = "1")] - pub inbox_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, -} -impl ::prost::Name for Inboxes { - const NAME: &'static str = "Inboxes"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.Inboxes".into() +impl Compression { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Deflate => "COMPRESSION_DEFLATE", + Self::Gzip => "COMPRESSION_GZIP", + } } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.Inboxes".into() + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "COMPRESSION_DEFLATE" => Some(Self::Deflate), + "COMPRESSION_GZIP" => Some(Self::Gzip), + _ => None, + } } } /// Message for group mutable metadata @@ -1033,136 +1007,162 @@ impl ::prost::Name for PermissionsUpdatePolicy { "/xmtp.mls.message_contents.PermissionsUpdatePolicy".into() } } -/// A group member and affected installation IDs +/// Message for group mutable metadata +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GroupMutableMetadataV1 { + /// Map to store various metadata attributes (Group name, etc.) + #[prost(map = "string, string", tag = "1")] + pub attributes: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + #[prost(message, optional, tag = "2")] + pub admin_list: ::core::option::Option, + /// Creator starts as only super_admin + /// Only super_admin can add/remove other super_admin + #[prost(message, optional, tag = "3")] + pub super_admin_list: ::core::option::Option, +} +impl ::prost::Name for GroupMutableMetadataV1 { + const NAME: &'static str = "GroupMutableMetadataV1"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.GroupMutableMetadataV1".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.GroupMutableMetadataV1".into() + } +} +/// Wrapper around a list of repeated Inbox Ids #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct MembershipChange { - #[prost(bytes = "vec", repeated, tag = "1")] - pub installation_ids: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, - #[prost(string, tag = "2")] - pub account_address: ::prost::alloc::string::String, - #[prost(string, tag = "3")] - pub initiated_by_account_address: ::prost::alloc::string::String, +pub struct Inboxes { + #[prost(string, repeated, tag = "1")] + pub inbox_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } -impl ::prost::Name for MembershipChange { - const NAME: &'static str = "MembershipChange"; +impl ::prost::Name for Inboxes { + const NAME: &'static str = "Inboxes"; const PACKAGE: &'static str = "xmtp.mls.message_contents"; fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.MembershipChange".into() + "xmtp.mls.message_contents.Inboxes".into() } fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.MembershipChange".into() + "/xmtp.mls.message_contents.Inboxes".into() } } -/// The group membership change proto -/// -/// protolint:disable REPEATED_FIELD_NAMES_PLURALIZED -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct GroupMembershipChanges { - /// Members that have been added in the commit - #[prost(message, repeated, tag = "1")] - pub members_added: ::prost::alloc::vec::Vec, - /// Members that have been removed in the commit - #[prost(message, repeated, tag = "2")] - pub members_removed: ::prost::alloc::vec::Vec, - /// Installations that have been added in the commit, grouped by member - #[prost(message, repeated, tag = "3")] - pub installations_added: ::prost::alloc::vec::Vec, - /// Installations removed in the commit, grouped by member - #[prost(message, repeated, tag = "4")] - pub installations_removed: ::prost::alloc::vec::Vec, +/// Parent message for group metadata +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GroupMetadataV1 { + #[prost(enumeration = "ConversationType", tag = "1")] + pub conversation_type: i32, + /// This will be removed soon + #[prost(string, tag = "2")] + pub creator_account_address: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub creator_inbox_id: ::prost::alloc::string::String, + /// Should only be present for CONVERSATION_TYPE_DM + #[prost(message, optional, tag = "4")] + pub dm_members: ::core::option::Option, + /// Should only be present for CONVERSATION_TYPE_ONESHOT + #[prost(message, optional, tag = "5")] + pub oneshot_message: ::core::option::Option, } -impl ::prost::Name for GroupMembershipChanges { - const NAME: &'static str = "GroupMembershipChanges"; +impl ::prost::Name for GroupMetadataV1 { + const NAME: &'static str = "GroupMetadataV1"; const PACKAGE: &'static str = "xmtp.mls.message_contents"; fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.GroupMembershipChanges".into() + "xmtp.mls.message_contents.GroupMetadataV1".into() } fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.GroupMembershipChanges".into() + "/xmtp.mls.message_contents.GroupMetadataV1".into() } } -/// A summary of the changes in a commit. -/// Includes added/removed inboxes and changes to metadata -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct GroupUpdated { +/// Wrapper around an Inbox Id +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Inbox { #[prost(string, tag = "1")] - pub initiated_by_inbox_id: ::prost::alloc::string::String, - /// The inboxes added in the commit - #[prost(message, repeated, tag = "2")] - pub added_inboxes: ::prost::alloc::vec::Vec, - /// The inboxes removed in the commit - #[prost(message, repeated, tag = "3")] - pub removed_inboxes: ::prost::alloc::vec::Vec, - /// The metadata changes in the commit - #[prost(message, repeated, tag = "4")] - pub metadata_field_changes: ::prost::alloc::vec::Vec< - group_updated::MetadataFieldChange, - >, - /// / The inboxes that were removed from the group in response to pending-remove/self-remove requests - #[prost(message, repeated, tag = "5")] - pub left_inboxes: ::prost::alloc::vec::Vec, - /// The inboxes that were added to admin list in the commit - #[prost(message, repeated, tag = "6")] - pub added_admin_inboxes: ::prost::alloc::vec::Vec, - /// The inboxes that were removed from admin list in the commit - #[prost(message, repeated, tag = "7")] - pub removed_admin_inboxes: ::prost::alloc::vec::Vec, - /// The inboxes that were added to super admin list in the commit - #[prost(message, repeated, tag = "8")] - pub added_super_admin_inboxes: ::prost::alloc::vec::Vec, - /// The inboxes that were removed from super admin list in the commit - #[prost(message, repeated, tag = "9")] - pub removed_super_admin_inboxes: ::prost::alloc::vec::Vec, + pub inbox_id: ::prost::alloc::string::String, } -/// Nested message and enum types in `GroupUpdated`. -pub mod group_updated { - /// An inbox that was added or removed in this commit - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] - pub struct Inbox { - #[prost(string, tag = "1")] - pub inbox_id: ::prost::alloc::string::String, +impl ::prost::Name for Inbox { + const NAME: &'static str = "Inbox"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.Inbox".into() } - impl ::prost::Name for Inbox { - const NAME: &'static str = "Inbox"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.GroupUpdated.Inbox".into() - } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.GroupUpdated.Inbox".into() - } + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.Inbox".into() } - /// A summary of a change to the mutable metadata - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] - pub struct MetadataFieldChange { - /// The field that was changed - #[prost(string, tag = "1")] - pub field_name: ::prost::alloc::string::String, - /// The previous value - #[prost(string, optional, tag = "2")] - pub old_value: ::core::option::Option<::prost::alloc::string::String>, - /// The updated value - #[prost(string, optional, tag = "3")] - pub new_value: ::core::option::Option<::prost::alloc::string::String>, +} +/// Ordering does not matter here +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DmMembers { + #[prost(message, optional, tag = "1")] + pub dm_member_one: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub dm_member_two: ::core::option::Option, +} +impl ::prost::Name for DmMembers { + const NAME: &'static str = "DmMembers"; + const PACKAGE: &'static str = "xmtp.mls.message_contents"; + fn full_name() -> ::prost::alloc::string::String { + "xmtp.mls.message_contents.DmMembers".into() } - impl ::prost::Name for MetadataFieldChange { - const NAME: &'static str = "MetadataFieldChange"; - const PACKAGE: &'static str = "xmtp.mls.message_contents"; - fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.GroupUpdated.MetadataFieldChange".into() + fn type_url() -> ::prost::alloc::string::String { + "/xmtp.mls.message_contents.DmMembers".into() + } +} +/// Defines the type of conversation +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ConversationType { + Unspecified = 0, + Group = 1, + Dm = 2, + Sync = 3, + Oneshot = 4, +} +impl ConversationType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "CONVERSATION_TYPE_UNSPECIFIED", + Self::Group => "CONVERSATION_TYPE_GROUP", + Self::Dm => "CONVERSATION_TYPE_DM", + Self::Sync => "CONVERSATION_TYPE_SYNC", + Self::Oneshot => "CONVERSATION_TYPE_ONESHOT", } - fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.GroupUpdated.MetadataFieldChange".into() + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CONVERSATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "CONVERSATION_TYPE_GROUP" => Some(Self::Group), + "CONVERSATION_TYPE_DM" => Some(Self::Dm), + "CONVERSATION_TYPE_SYNC" => Some(Self::Sync), + "CONVERSATION_TYPE_ONESHOT" => Some(Self::Oneshot), + _ => None, } } } -impl ::prost::Name for GroupUpdated { - const NAME: &'static str = "GroupUpdated"; +/// Contains a mapping of `inbox_id` -> `sequence_id` for all members of a group. +/// Designed to be stored in the group context extension of the MLS group +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GroupMembership { + #[prost(map = "string, uint64", tag = "1")] + pub members: ::std::collections::HashMap<::prost::alloc::string::String, u64>, + /// List of installations that failed to be added due to errors encountered during the evaluation process. + #[prost(bytes = "vec", repeated, tag = "2")] + pub failed_installations: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for GroupMembership { + const NAME: &'static str = "GroupMembership"; const PACKAGE: &'static str = "xmtp.mls.message_contents"; fn full_name() -> ::prost::alloc::string::String { - "xmtp.mls.message_contents.GroupUpdated".into() + "xmtp.mls.message_contents.GroupMembership".into() } fn type_url() -> ::prost::alloc::string::String { - "/xmtp.mls.message_contents.GroupUpdated".into() + "/xmtp.mls.message_contents.GroupMembership".into() } }