Add DAVE protocol support to serenity-voice-model (#3475)

Co-authored-by: Vitamin <cbayush6@gmail.com>

Author: 2 people

voice-model/src/event/from.rs

@@ -66,3 +66,69 @@ impl From<ClientDisconnect> for Event {
         Event::ClientDisconnect(i)
     }
 }
+
+impl From<DaveTransitionReady> for Event {
+    fn from(i: DaveTransitionReady) -> Self {
+        Event::DaveTransitionReady(i)
+    }
+}
+
+impl From<DavePrepareEpoch> for Event {
+    fn from(i: DavePrepareEpoch) -> Self {
+        Event::DavePrepareEpoch(i)
+    }
+}
+
+impl From<DaveMlsExternalSender> for Event {
+    fn from(i: DaveMlsExternalSender) -> Self {
+        Event::DaveMlsExternalSender(i)
+    }
+}
+
+impl From<DaveMlsKeyPackage> for Event {
+    fn from(i: DaveMlsKeyPackage) -> Self {
+        Event::DaveMlsKeyPackage(i)
+    }
+}
+
+impl From<DaveMlsProposals> for Event {
+    fn from(i: DaveMlsProposals) -> Self {
+        Event::DaveMlsProposals(i)
+    }
+}
+
+impl From<DaveMlsCommitWelcome> for Event {
+    fn from(i: DaveMlsCommitWelcome) -> Self {
+        Event::DaveMlsCommitWelcome(i)
+    }
+}
+
+impl From<DaveMlsWelcome> for Event {
+    fn from(i: DaveMlsWelcome) -> Self {
+        Event::DaveMlsWelcome(i)
+    }
+}
+
+impl From<DavePrepareTransition> for Event {
+    fn from(i: DavePrepareTransition) -> Self {
+        Event::DavePrepareTransition(i)
+    }
+}
+
+impl From<DaveExecuteTransition> for Event {
+    fn from(i: DaveExecuteTransition) -> Self {
+        Event::DaveExecuteTransition(i)
+    }
+}
+
+impl From<DaveMlsAnnounceCommitTransition> for Event {
+    fn from(i: DaveMlsAnnounceCommitTransition) -> Self {
+        Event::DaveMlsAnnounceCommitTransition(i)
+    }
+}
+
+impl From<DaveMlsInvalidCommitWelcome> for Event {
+    fn from(i: DaveMlsInvalidCommitWelcome) -> Self {
+        Event::DaveMlsInvalidCommitWelcome(i)
+    }
+}

voice-model/src/event/mod.rs

@@ -40,6 +40,28 @@ pub enum Event {
     ClientConnect(ClientConnect),
     /// Status update in the current channel, indicating that a user has disconnected.
     ClientDisconnect(ClientDisconnect),
+    /// DAVE: Signals the bot is ready for group operations after epoch transition.
+    DaveTransitionReady(DaveTransitionReady),
+    /// DAVE: Notifies of an upcoming epoch change.
+    DavePrepareEpoch(DavePrepareEpoch),
+    /// DAVE: Provides the external sender package for MLS group initialization.
+    DaveMlsExternalSender(DaveMlsExternalSender),
+    /// DAVE: Sends the key package for MLS group participation.
+    DaveMlsKeyPackage(DaveMlsKeyPackage),
+    /// DAVE: Provides proposals for group member changes.
+    DaveMlsProposals(DaveMlsProposals),
+    /// DAVE: Provides a commit with optional welcome for group transitions.
+    DaveMlsCommitWelcome(DaveMlsCommitWelcome),
+    /// DAVE: Provides the welcome message for new members.
+    DaveMlsWelcome(DaveMlsWelcome),
+    /// DAVE: Prepares for a protocol transition.
+    DavePrepareTransition(DavePrepareTransition),
+    /// DAVE: Executes a prepared protocol transition.
+    DaveExecuteTransition(DaveExecuteTransition),
+    /// DAVE: Announces a commit for group transition.
+    DaveMlsAnnounceCommitTransition(DaveMlsAnnounceCommitTransition),
+    /// DAVE: Reports an invalid commit or welcome message.
+    DaveMlsInvalidCommitWelcome(DaveMlsInvalidCommitWelcome),
 }
 
 impl Event {
@@ -58,6 +80,17 @@ impl Event {
             Resumed => Opcode::Resumed,
             ClientConnect(_) => Opcode::ClientConnect,
             ClientDisconnect(_) => Opcode::ClientDisconnect,
+            DaveTransitionReady(_) => Opcode::DaveTransitionReady,
+            DavePrepareEpoch(_) => Opcode::DavePrepareEpoch,
+            DaveMlsExternalSender(_) => Opcode::DaveMlsExternalSender,
+            DaveMlsKeyPackage(_) => Opcode::DaveMlsKeyPackage,
+            DaveMlsProposals(_) => Opcode::DaveMlsProposals,
+            DaveMlsCommitWelcome(_) => Opcode::DaveMlsCommitWelcome,
+            DaveMlsWelcome(_) => Opcode::DaveMlsWelcome,
+            DavePrepareTransition(_) => Opcode::DavePrepareTransition,
+            DaveExecuteTransition(_) => Opcode::DaveExecuteTransition,
+            DaveMlsAnnounceCommitTransition(_) => Opcode::DaveMlsAnnounceCommitTransition,
+            DaveMlsInvalidCommitWelcome(_) => Opcode::DaveMlsInvalidCommitWelcome,
         }
     }
 }
@@ -85,6 +118,17 @@ impl Serialize for Event {
             Resumed => s.serialize_field("d", &None::<()>)?,
             ClientConnect(e) => s.serialize_field("d", e)?,
             ClientDisconnect(e) => s.serialize_field("d", e)?,
+            DaveTransitionReady(e) => s.serialize_field("d", e)?,
+            DavePrepareEpoch(e) => s.serialize_field("d", e)?,
+            DaveMlsExternalSender(e) => s.serialize_field("d", e)?,
+            DaveMlsKeyPackage(e) => s.serialize_field("d", e)?,
+            DaveMlsProposals(e) => s.serialize_field("d", e)?,
+            DaveMlsCommitWelcome(e) => s.serialize_field("d", e)?,
+            DaveMlsWelcome(e) => s.serialize_field("d", e)?,
+            DavePrepareTransition(e) => s.serialize_field("d", e)?,
+            DaveExecuteTransition(e) => s.serialize_field("d", e)?,
+            DaveMlsAnnounceCommitTransition(e) => s.serialize_field("d", e)?,
+            DaveMlsInvalidCommitWelcome(e) => s.serialize_field("d", e)?,
         }
 
         s.end()
@@ -115,7 +159,7 @@ impl<'de> Visitor<'de> for EventVisitor {
                     let valid_op = Opcode::deserialize(des).map_err(|_| {
                         DeError::invalid_value(
                             Unexpected::Unsigned(raw.into()),
-                            &"opcode in [0--9] + [12--13]",
+                            &"opcode in [0--9] + [12--13] + [21--24] + [26--31]",
                         )
                     })?;
                     op = Some(valid_op);
@@ -143,6 +187,28 @@ impl<'de> Visitor<'de> for EventVisitor {
                         return Ok(map.next_value::<ClientConnect>()?.into()),
                     Some(Opcode::ClientDisconnect) =>
                         return Ok(map.next_value::<ClientDisconnect>()?.into()),
+                    Some(Opcode::DaveTransitionReady) =>
+                        return Ok(map.next_value::<DaveTransitionReady>()?.into()),
+                    Some(Opcode::DavePrepareEpoch) =>
+                        return Ok(map.next_value::<DavePrepareEpoch>()?.into()),
+                    Some(Opcode::DaveMlsExternalSender) =>
+                        return Ok(map.next_value::<DaveMlsExternalSender>()?.into()),
+                    Some(Opcode::DaveMlsKeyPackage) =>
+                        return Ok(map.next_value::<DaveMlsKeyPackage>()?.into()),
+                    Some(Opcode::DaveMlsProposals) =>
+                        return Ok(map.next_value::<DaveMlsProposals>()?.into()),
+                    Some(Opcode::DaveMlsCommitWelcome) =>
+                        return Ok(map.next_value::<DaveMlsCommitWelcome>()?.into()),
+                    Some(Opcode::DaveMlsWelcome) =>
+                        return Ok(map.next_value::<DaveMlsWelcome>()?.into()),
+                    Some(Opcode::DavePrepareTransition) =>
+                        return Ok(map.next_value::<DavePrepareTransition>()?.into()),
+                    Some(Opcode::DaveExecuteTransition) =>
+                        return Ok(map.next_value::<DaveExecuteTransition>()?.into()),
+                    Some(Opcode::DaveMlsAnnounceCommitTransition) =>
+                        return Ok(map.next_value::<DaveMlsAnnounceCommitTransition>()?.into()),
+                    Some(Opcode::DaveMlsInvalidCommitWelcome) =>
+                        return Ok(map.next_value::<DaveMlsInvalidCommitWelcome>()?.into()),
                     None => {
                         d = Some(map.next_value::<&RawValue>()?);
                     },
@@ -178,6 +244,25 @@ impl<'de> Visitor<'de> for EventVisitor {
             Opcode::Resumed => Ok(Event::Resumed),
             Opcode::ClientConnect => serde_json::from_str::<ClientConnect>(d).map(Into::into),
             Opcode::ClientDisconnect => serde_json::from_str::<ClientDisconnect>(d).map(Into::into),
+            Opcode::DaveTransitionReady =>
+                serde_json::from_str::<DaveTransitionReady>(d).map(Into::into),
+            Opcode::DavePrepareEpoch => serde_json::from_str::<DavePrepareEpoch>(d).map(Into::into),
+            Opcode::DaveMlsExternalSender =>
+                serde_json::from_str::<DaveMlsExternalSender>(d).map(Into::into),
+            Opcode::DaveMlsKeyPackage =>
+                serde_json::from_str::<DaveMlsKeyPackage>(d).map(Into::into),
+            Opcode::DaveMlsProposals => serde_json::from_str::<DaveMlsProposals>(d).map(Into::into),
+            Opcode::DaveMlsCommitWelcome =>
+                serde_json::from_str::<DaveMlsCommitWelcome>(d).map(Into::into),
+            Opcode::DaveMlsWelcome => serde_json::from_str::<DaveMlsWelcome>(d).map(Into::into),
+            Opcode::DavePrepareTransition =>
+                serde_json::from_str::<DavePrepareTransition>(d).map(Into::into),
+            Opcode::DaveExecuteTransition =>
+                serde_json::from_str::<DaveExecuteTransition>(d).map(Into::into),
+            Opcode::DaveMlsAnnounceCommitTransition =>
+                serde_json::from_str::<DaveMlsAnnounceCommitTransition>(d).map(Into::into),
+            Opcode::DaveMlsInvalidCommitWelcome =>
+                serde_json::from_str::<DaveMlsInvalidCommitWelcome>(d).map(Into::into),
         })
         .map_err(DeError::custom)
     }

voice-model/src/opcode.rs

@@ -33,4 +33,26 @@ pub enum Opcode {
     ClientConnect = 12,
     /// Message indicating that another user has disconnected from the voice channel.
     ClientDisconnect = 13,
+    /// DAVE: Signals the bot is ready for group operations after epoch transition.
+    DaveTransitionReady = 23,
+    /// DAVE: Notifies of an upcoming epoch change.
+    DavePrepareEpoch = 24,
+    /// DAVE: Provides the external sender package for MLS group initialization.
+    DaveMlsExternalSender = 25,
+    /// DAVE: Sends the key package for MLS group participation.
+    DaveMlsKeyPackage = 26,
+    /// DAVE: Provides proposals for group member changes (add/remove).
+    DaveMlsProposals = 27,
+    /// DAVE: Provides a commit with optional welcome for group transitions.
+    DaveMlsCommitWelcome = 28,
+    /// DAVE: Provides the welcome message for new members.
+    DaveMlsWelcome = 30,
+    /// DAVE: Prepares for a protocol transition.
+    DavePrepareTransition = 21,
+    /// DAVE: Executes a prepared protocol transition.
+    DaveExecuteTransition = 22,
+    /// DAVE: Announces a commit for group transition.
+    DaveMlsAnnounceCommitTransition = 29,
+    /// DAVE: Reports an invalid commit or welcome message.
+    DaveMlsInvalidCommitWelcome = 31,
 }

voice-model/src/payload.rs

@@ -132,3 +132,159 @@ pub struct Speaking {
     /// Used alongside the SSRC to map individual packets to their sender.
     pub user_id: Option<UserId>,
 }
+
+/// DAVE protocol version field in the Identify payload.
+///
+/// Signals to Discord that the bot supports end-to-end encryption
+/// and which protocol version(s) it supports.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+#[serde(transparent)]
+pub struct MaxDaveProtocolVersion(pub u16);
+
+impl MaxDaveProtocolVersion {
+    /// Protocol version 1 - Current DAVE protocol version
+    pub const V1: Self = Self(1);
+}
+
+impl Default for MaxDaveProtocolVersion {
+    fn default() -> Self {
+        Self::V1
+    }
+}
+
+/// External sender package for DAVE MLS group creation.
+///
+/// Received from the server (Opcode 25) containing the voice gateway's
+/// credential and signature public key for the MLS group's external_senders extension.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DaveMlsExternalSender {
+    /// Serialized ExternalSender containing signature_key and credential.
+    pub external_sender: Vec<u8>,
+}
+
+/// Key package for DAVE MLS group participation.
+///
+/// Sent to the server (Opcode 26) during the join handshake.
+/// The basic credential identity is the big-endian 64-bit user ID.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DaveMlsKeyPackage {
+    /// Serialized MLSMessage containing the KeyPackage (see RFC 9420).
+    pub key_package: Vec<u8>,
+}
+
+/// Operation type for MLS proposals.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+#[repr(u8)]
+pub enum DaveMlsProposalsOperationType {
+    /// Append proposals to the pending proposal list.
+    Append = 0,
+    /// Revoke previously sent proposals by their reference.
+    Revoke = 1,
+}
+
+/// Proposals for group member changes.
+///
+/// Received from the server (Opcode 27) for add/remove operations.
+/// Contains either proposals to append or proposal refs to revoke.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DaveMlsProposals {
+    /// The type of operation (append or revoke).
+    pub operation_type: DaveMlsProposalsOperationType,
+    /// Serialized proposal data.
+    /// For append: serialized MLSMessage proposal messages.
+    /// For revoke: serialized ProposalRef values.
+    pub proposals: Vec<u8>,
+}
+
+/// Commit with optional welcome message for group transitions.
+///
+/// Sent by the client (Opcode 28) after processing proposals.
+/// When at least one add proposal is handled, the welcome message MUST be included.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DaveMlsCommitWelcome {
+    /// Serialized MLS commit message (see RFC 9420 MLSMessage and Commit definitions).
+    pub commit: Vec<u8>,
+    /// Optional MLS Welcome message for new members (see RFC 9420 Welcome definition).
+    /// Required when the commit includes one or more add proposals.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub welcome: Option<Vec<u8>>,
+}
+
+/// Welcome message for new members joining the group.
+///
+/// Received from the server (Opcode 30) as confirmation of successful join.
+/// Includes the transition ID for the group transition.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DaveMlsWelcome {
+    /// The transition ID for this group transition.
+    pub transition_id: u16,
+    /// Serialized MLS Welcome message (see RFC 9420 Welcome definition).
+    pub welcome: Vec<u8>,
+}
+
+/// Prepare epoch notification before group transition.
+///
+/// Received from the server (Opcode 24) to signal an upcoming epoch change.
+/// When `epoch` is 1, this indicates a new MLS group is to be created.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DavePrepareEpoch {
+    /// The protocol version for the upcoming epoch.
+    pub protocol_version: u16,
+    /// The new epoch number after the transition.
+    pub epoch: u64,
+}
+
+/// Transition ready confirmation.
+///
+/// Sent by the client (Opcode 23) to confirm it's ready for a previously announced transition.
+/// The client sends this after processing a commit or preparing receive-side decryptors.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct DaveTransitionReady {
+    /// The transition ID the client is ready to execute.
+    pub transition_id: u16,
+}
+
+/// Prepare protocol transition notification.
+///
+/// Received from the server (Opcode 21) to announce an upcoming protocol transition.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DavePrepareTransition {
+    /// The protocol version for the transition.
+    pub protocol_version: u16,
+    /// The transition ID for this transition.
+    pub transition_id: u16,
+}
+
+/// Execute protocol transition notification.
+///
+/// Received from the server (Opcode 22) to execute a previously prepared transition.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DaveExecuteTransition {
+    /// The transition ID for this transition.
+    pub transition_id: u16,
+}
+
+/// Announce commit for group transition.
+///
+/// Received from the server (Opcode 29) to broadcast an MLS commit for moving to the next epoch.
+/// The commit is one received from a group member via dave_mls_commit_welcome (Opcode 28).
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DaveMlsAnnounceCommitTransition {
+    /// Sequence number for the announcement.
+    pub sequence_number: u16,
+    /// The transition ID for this group epoch change.
+    pub transition_id: u16,
+    /// Serialized MLS commit message (see RFC 9420 MLSMessage and Commit definitions).
+    pub commit_message: Vec<u8>,
+}
+
+/// Invalid commit or welcome report.
+///
+/// Sent to the server (Opcode 31) to report an invalid commit or welcome message.
+/// This asks the voice gateway to remove and re-add the member to recover.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
+pub struct DaveMlsInvalidCommitWelcome {
+    /// The transition ID in which the invalid Commit or Welcome was received.
+    pub transition_id: u16,
+}