diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5335d8a..191bd9e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,12 +19,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `EchoBroadcast` and `DirectMessage` now use `ProtocolMessagePart` trait for their methods. ([#47])
 - Added normal broadcasts support in addition to echo ones; signatures of `Round` methods changed accordingly; added `Round::make_normal_broadcast()`. ([#47])
 - Serialization format is a part of `SessionParameters` now; `Round` and `Protocol` methods receive dynamic serializers/deserializers. ([#33])
+- Renamed `(Verified)MessageBundle` to `(Verified)Message`. Both are now generic over `Verifier`. ([#56])
 
 
 ### Added
 
 - `SerializableMap` wrapper for `BTreeMap` supporting more formats and providing some safety features. (#[32])
 - `DirectMessage::assert_is_none()` and `verify_is_some()`, same for `EchoBroadcast`. Users can now check that a part of the round message (echo or direct) is `None` as expected, and make a verifiable evidence if it is not. ([#46])
+- Re-export `digest` from the `session` module. ([#56])
+- Added `Message::destination()`. ([#56])
 
 
 [#32]: https://github.com/entropyxyz/manul/pull/32
@@ -35,6 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#41]: https://github.com/entropyxyz/manul/pull/41
 [#46]: https://github.com/entropyxyz/manul/pull/46
 [#47]: https://github.com/entropyxyz/manul/pull/47
+[#56]: https://github.com/entropyxyz/manul/pull/56
 
 
 ## [0.0.1] - 2024-10-12
diff --git a/examples/tests/async_runner.rs b/examples/tests/async_runner.rs
index 53a1dcc..008ee82 100644
--- a/examples/tests/async_runner.rs
+++ b/examples/tests/async_runner.rs
@@ -5,8 +5,8 @@ use alloc::collections::{BTreeMap, BTreeSet};
 use manul::{
     protocol::Protocol,
     session::{
-        signature::Keypair, CanFinalize, LocalError, MessageBundle, RoundOutcome, Session, SessionId,
-        SessionParameters, SessionReport,
+        signature::Keypair, CanFinalize, LocalError, Message, RoundOutcome, Session, SessionId, SessionParameters,
+        SessionReport,
     },
     testing::{BinaryFormat, TestSessionParams, TestSigner},
 };
@@ -23,12 +23,12 @@ use tracing_subscriber::{util::SubscriberInitExt, EnvFilter};
 struct MessageOut<SP: SessionParameters> {
     from: SP::Verifier,
     to: SP::Verifier,
-    message: MessageBundle,
+    message: Message<SP::Verifier>,
 }
 
 struct MessageIn<SP: SessionParameters> {
     from: SP::Verifier,
-    message: MessageBundle,
+    message: Message<SP::Verifier>,
 }
 
 /// Runs a session. Simulates what each participating party would run as the protocol progresses.
diff --git a/manul/src/session.rs b/manul/src/session.rs
index 1763e5e..3710d96 100644
--- a/manul/src/session.rs
+++ b/manul/src/session.rs
@@ -17,11 +17,12 @@ mod wire_format;
 
 pub use crate::protocol::{LocalError, RemoteError};
 pub use evidence::{Evidence, EvidenceError};
-pub use message::MessageBundle;
+pub use message::{Message, VerifiedMessage};
 pub use session::{CanFinalize, RoundAccumulator, RoundOutcome, Session, SessionId, SessionParameters};
 pub use transcript::{SessionOutcome, SessionReport};
 pub use wire_format::WireFormat;
 
 pub(crate) use echo::EchoRoundError;
 
+pub use digest;
 pub use signature;
diff --git a/manul/src/session/echo.rs b/manul/src/session/echo.rs
index 9e209ef..5bbd124 100644
--- a/manul/src/session/echo.rs
+++ b/manul/src/session/echo.rs
@@ -12,7 +12,7 @@ use serde::{Deserialize, Serialize};
 use tracing::debug;
 
 use super::{
-    message::{MessageVerificationError, SignedMessage},
+    message::{MessageVerificationError, SignedMessagePart},
     session::SessionParameters,
     LocalError,
 };
@@ -42,8 +42,8 @@ pub(crate) enum EchoRoundError<Id> {
     MismatchedBroadcasts {
         guilty_party: Id,
         error: MismatchedBroadcastsError,
-        we_received: SignedMessage<EchoBroadcast>,
-        echoed_to_us: SignedMessage<EchoBroadcast>,
+        we_received: SignedMessagePart<EchoBroadcast>,
+        echoed_to_us: SignedMessagePart<EchoBroadcast>,
     },
 }
 
@@ -68,7 +68,7 @@ pub(crate) enum MismatchedBroadcastsError {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub(crate) struct EchoRoundMessage<SP: SessionParameters> {
-    pub(super) echo_broadcasts: SerializableMap<SP::Verifier, SignedMessage<EchoBroadcast>>,
+    pub(super) echo_broadcasts: SerializableMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>,
 }
 
 /// Each protocol round can contain one `EchoRound` with "echo messages" that are sent to all
@@ -77,7 +77,7 @@ pub(crate) struct EchoRoundMessage<SP: SessionParameters> {
 #[derive_where::derive_where(Debug)]
 pub struct EchoRound<P, SP: SessionParameters> {
     verifier: SP::Verifier,
-    echo_broadcasts: BTreeMap<SP::Verifier, SignedMessage<EchoBroadcast>>,
+    echo_broadcasts: BTreeMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>,
     destinations: BTreeSet<SP::Verifier>,
     expected_echos: BTreeSet<SP::Verifier>,
     main_round: Box<dyn ObjectSafeRound<SP::Verifier, Protocol = P>>,
@@ -92,8 +92,8 @@ where
 {
     pub fn new(
         verifier: SP::Verifier,
-        my_echo_broadcast: SignedMessage<EchoBroadcast>,
-        echo_broadcasts: BTreeMap<SP::Verifier, SignedMessage<EchoBroadcast>>,
+        my_echo_broadcast: SignedMessagePart<EchoBroadcast>,
+        echo_broadcasts: BTreeMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>,
         main_round: Box<dyn ObjectSafeRound<SP::Verifier, Protocol = P>>,
         payloads: BTreeMap<SP::Verifier, Payload>,
         artifacts: BTreeMap<SP::Verifier, Artifact>,
diff --git a/manul/src/session/evidence.rs b/manul/src/session/evidence.rs
index 4a2e9a6..c0fab32 100644
--- a/manul/src/session/evidence.rs
+++ b/manul/src/session/evidence.rs
@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 
 use super::{
     echo::{EchoRound, EchoRoundError, EchoRoundMessage, MismatchedBroadcastsError},
-    message::{MessageVerificationError, MissingMessage, SignedMessage},
+    message::{MessageVerificationError, SignedMessagePart},
     session::SessionParameters,
     transcript::Transcript,
     LocalError,
@@ -37,15 +37,6 @@ pub enum EvidenceError {
     InvalidEvidence(String),
 }
 
-// Other nodes would send a signed message with the payload being either Some(...) or None.
-// We expect the messages in the evidence only be the Some(...) ones, so if it's not the case, it's invalid evidence.
-// It's hard to enforce statically since we have to keep the signed messages as they were created by remote nodes.
-impl From<MissingMessage> for EvidenceError {
-    fn from(_error: MissingMessage) -> Self {
-        Self::InvalidEvidence("The signed message is missing the expected payload".into())
-    }
-}
-
 impl From<MessageVerificationError> for EvidenceError {
     fn from(error: MessageVerificationError) -> Self {
         match error {
@@ -98,9 +89,9 @@ where
 {
     pub(crate) fn new_protocol_error(
         verifier: &SP::Verifier,
-        echo_broadcast: SignedMessage<EchoBroadcast>,
-        normal_broadcast: SignedMessage<NormalBroadcast>,
-        direct_message: SignedMessage<DirectMessage>,
+        echo_broadcast: SignedMessagePart<EchoBroadcast>,
+        normal_broadcast: SignedMessagePart<NormalBroadcast>,
+        direct_message: SignedMessagePart<DirectMessage>,
         error: P::ProtocolError,
         transcript: &Transcript<P, SP>,
     ) -> Result<Self, LocalError> {
@@ -164,7 +155,7 @@ where
 
     pub(crate) fn new_echo_round_error(
         verifier: &SP::Verifier,
-        normal_broadcast: SignedMessage<NormalBroadcast>,
+        normal_broadcast: SignedMessagePart<NormalBroadcast>,
         error: EchoRoundError<SP::Verifier>,
     ) -> Result<Self, LocalError> {
         let description = format!("Echo round error: {}", error.description());
@@ -196,7 +187,7 @@ where
 
     pub(crate) fn new_invalid_direct_message(
         verifier: &SP::Verifier,
-        direct_message: SignedMessage<DirectMessage>,
+        direct_message: SignedMessagePart<DirectMessage>,
         error: DirectMessageError,
     ) -> Self {
         Self {
@@ -211,7 +202,7 @@ where
 
     pub(crate) fn new_invalid_echo_broadcast(
         verifier: &SP::Verifier,
-        echo_broadcast: SignedMessage<EchoBroadcast>,
+        echo_broadcast: SignedMessagePart<EchoBroadcast>,
         error: EchoBroadcastError,
     ) -> Self {
         Self {
@@ -226,7 +217,7 @@ where
 
     pub(crate) fn new_invalid_normal_broadcast(
         verifier: &SP::Verifier,
-        normal_broadcast: SignedMessage<NormalBroadcast>,
+        normal_broadcast: SignedMessagePart<NormalBroadcast>,
         error: NormalBroadcastError,
     ) -> Self {
         Self {
@@ -280,7 +271,7 @@ enum EvidenceEnum<P: Protocol, SP: SessionParameters> {
 #[derive_where::derive_where(Debug)]
 #[derive(Clone, Serialize, Deserialize)]
 pub struct InvalidEchoPackEvidence<SP: SessionParameters> {
-    normal_broadcast: SignedMessage<NormalBroadcast>,
+    normal_broadcast: SignedMessagePart<NormalBroadcast>,
     invalid_echo_sender: SP::Verifier,
 }
 
@@ -324,8 +315,8 @@ where
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MismatchedBroadcastsEvidence {
     error: MismatchedBroadcastsError,
-    we_received: SignedMessage<EchoBroadcast>,
-    echoed_to_us: SignedMessage<EchoBroadcast>,
+    we_received: SignedMessagePart<EchoBroadcast>,
+    echoed_to_us: SignedMessagePart<EchoBroadcast>,
 }
 
 impl MismatchedBroadcastsEvidence {
@@ -360,7 +351,7 @@ impl MismatchedBroadcastsEvidence {
 #[derive_where::derive_where(Debug)]
 #[derive(Clone, Serialize, Deserialize)]
 pub struct InvalidDirectMessageEvidence<P: Protocol> {
-    direct_message: SignedMessage<DirectMessage>,
+    direct_message: SignedMessagePart<DirectMessage>,
     phantom: core::marker::PhantomData<P>,
 }
 
@@ -390,7 +381,7 @@ where
 #[derive_where::derive_where(Debug)]
 #[derive(Clone, Serialize, Deserialize)]
 pub struct InvalidEchoBroadcastEvidence<P: Protocol> {
-    echo_broadcast: SignedMessage<EchoBroadcast>,
+    echo_broadcast: SignedMessagePart<EchoBroadcast>,
     phantom: core::marker::PhantomData<P>,
 }
 
@@ -420,7 +411,7 @@ where
 #[derive_where::derive_where(Debug)]
 #[derive(Clone, Serialize, Deserialize)]
 pub struct InvalidNormalBroadcastEvidence<P: Protocol> {
-    normal_broadcast: SignedMessage<NormalBroadcast>,
+    normal_broadcast: SignedMessagePart<NormalBroadcast>,
     phantom: core::marker::PhantomData<P>,
 }
 
@@ -454,13 +445,13 @@ where
 #[derive(Clone, Serialize, Deserialize)]
 struct ProtocolEvidence<P: Protocol> {
     error: P::ProtocolError,
-    direct_message: SignedMessage<DirectMessage>,
-    echo_broadcast: SignedMessage<EchoBroadcast>,
-    normal_broadcast: SignedMessage<NormalBroadcast>,
-    direct_messages: SerializableMap<RoundId, SignedMessage<DirectMessage>>,
-    echo_broadcasts: SerializableMap<RoundId, SignedMessage<EchoBroadcast>>,
-    normal_broadcasts: SerializableMap<RoundId, SignedMessage<NormalBroadcast>>,
-    combined_echos: SerializableMap<RoundId, SignedMessage<NormalBroadcast>>,
+    direct_message: SignedMessagePart<DirectMessage>,
+    echo_broadcast: SignedMessagePart<EchoBroadcast>,
+    normal_broadcast: SignedMessagePart<NormalBroadcast>,
+    direct_messages: SerializableMap<RoundId, SignedMessagePart<DirectMessage>>,
+    echo_broadcasts: SerializableMap<RoundId, SignedMessagePart<EchoBroadcast>>,
+    normal_broadcasts: SerializableMap<RoundId, SignedMessagePart<NormalBroadcast>>,
+    combined_echos: SerializableMap<RoundId, SignedMessagePart<NormalBroadcast>>,
 }
 
 impl<P> ProtocolEvidence<P>
diff --git a/manul/src/session/message.rs b/manul/src/session/message.rs
index 210cfee..51dbc55 100644
--- a/manul/src/session/message.rs
+++ b/manul/src/session/message.rs
@@ -44,7 +44,7 @@ pub(crate) enum MessageVerificationError {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub(crate) struct SignedMessage<M> {
+pub(crate) struct SignedMessagePart<M> {
     signature: SerializedSignature,
     message_with_metadata: MessageWithMetadata<M>,
 }
@@ -84,7 +84,7 @@ impl<M: ProtocolMessagePart> MessageWithMetadata<M> {
         SP: SessionParameters,
     {
         let digest =
-            SP::Digest::new_with_prefix(b"SignedMessage").chain_update(SP::WireFormat::serialize(&self.metadata)?);
+            SP::Digest::new_with_prefix(b"SignedMessagePart").chain_update(SP::WireFormat::serialize(&self.metadata)?);
 
         let digest = match self.message.maybe_message().as_ref() {
             None => digest.chain_update([0u8]),
@@ -95,7 +95,7 @@ impl<M: ProtocolMessagePart> MessageWithMetadata<M> {
     }
 }
 
-impl<M> SignedMessage<M>
+impl<M> SignedMessagePart<M>
 where
     M: ProtocolMessagePart,
 {
@@ -129,7 +129,7 @@ where
         &self.message_with_metadata.message
     }
 
-    pub(crate) fn verify<SP>(self, verifier: &SP::Verifier) -> Result<VerifiedMessage<M>, MessageVerificationError>
+    pub(crate) fn verify<SP>(self, verifier: &SP::Verifier) -> Result<VerifiedMessagePart<M>, MessageVerificationError>
     where
         SP: SessionParameters,
     {
@@ -142,7 +142,7 @@ where
             .deserialize::<SP>()
             .map_err(|_| MessageVerificationError::InvalidSignature)?;
         if verifier.verify_digest(digest, &signature).is_ok() {
-            Ok(VerifiedMessage {
+            Ok(VerifiedMessagePart {
                 signature: self.signature,
                 message_with_metadata: self.message_with_metadata,
             })
@@ -152,16 +152,13 @@ where
     }
 }
 
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct MissingMessage;
-
 #[derive(Debug, Clone)]
-pub struct VerifiedMessage<M> {
+pub struct VerifiedMessagePart<M> {
     signature: SerializedSignature,
     message_with_metadata: MessageWithMetadata<M>,
 }
 
-impl<M> VerifiedMessage<M> {
+impl<M> VerifiedMessagePart<M> {
     pub(crate) fn metadata(&self) -> &MessageMetadata {
         &self.message_with_metadata.metadata
     }
@@ -170,49 +167,56 @@ impl<M> VerifiedMessage<M> {
         &self.message_with_metadata.message
     }
 
-    pub fn into_unverified(self) -> SignedMessage<M> {
-        SignedMessage {
+    pub fn into_unverified(self) -> SignedMessagePart<M> {
+        SignedMessagePart {
             signature: self.signature,
             message_with_metadata: self.message_with_metadata,
         }
     }
 }
 
-/// A message bundle destined for another node.
-///
-/// During message pre-processing, a `MessageBundle` transitions to a `CheckedMessageBundle`.
-///
-/// Note that this is already signed.
+/// A signed message destined for another node.
 #[derive(Clone, Debug)]
-pub struct MessageBundle {
-    direct_message: SignedMessage<DirectMessage>,
-    echo_broadcast: SignedMessage<EchoBroadcast>,
-    normal_broadcast: SignedMessage<NormalBroadcast>,
+pub struct Message<Verifier> {
+    destination: Verifier,
+    direct_message: SignedMessagePart<DirectMessage>,
+    echo_broadcast: SignedMessagePart<EchoBroadcast>,
+    normal_broadcast: SignedMessagePart<NormalBroadcast>,
 }
 
-impl MessageBundle {
+impl<Verifier> Message<Verifier>
+where
+    Verifier: Clone,
+{
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn new<SP>(
         rng: &mut impl CryptoRngCore,
         signer: &SP::Signer,
         session_id: &SessionId,
         round_id: RoundId,
+        destination: &Verifier,
         direct_message: DirectMessage,
-        echo_broadcast: SignedMessage<EchoBroadcast>,
-        normal_broadcast: SignedMessage<NormalBroadcast>,
+        echo_broadcast: SignedMessagePart<EchoBroadcast>,
+        normal_broadcast: SignedMessagePart<NormalBroadcast>,
     ) -> Result<Self, LocalError>
     where
         SP: SessionParameters,
     {
-        let direct_message = SignedMessage::new::<SP>(rng, signer, session_id, round_id, direct_message)?;
+        let direct_message = SignedMessagePart::new::<SP>(rng, signer, session_id, round_id, direct_message)?;
         Ok(Self {
+            destination: destination.clone(),
             direct_message,
             echo_broadcast,
             normal_broadcast,
         })
     }
 
-    pub(crate) fn unify_metadata(self) -> Option<CheckedMessageBundle> {
+    /// The verifier of the party this message is intended for.
+    pub fn destination(&self) -> &Verifier {
+        &self.destination
+    }
+
+    pub(crate) fn unify_metadata(self) -> Option<CheckedMessage> {
         if self.echo_broadcast.metadata() != self.direct_message.metadata() {
             return None;
         }
@@ -222,7 +226,7 @@ impl MessageBundle {
         }
 
         let metadata = self.direct_message.message_with_metadata.metadata.clone();
-        Some(CheckedMessageBundle {
+        Some(CheckedMessage {
             metadata,
             direct_message: self.direct_message,
             echo_broadcast: self.echo_broadcast,
@@ -231,24 +235,24 @@ impl MessageBundle {
     }
 }
 
-/// A `CheckedMessageBundle` is like a [`MessageBundle`] but where we have checked that the metadata
+/// A `CheckedMessage` is like a [`Message`] but where we have checked that the metadata
 /// (i.e. SessionId and RoundId) from the Echo message (if any) matches with that of the
 /// [`DirectMessage`].
-/// `CheckedMessageBundle`s can transition to [`VerifiedMessageBundle`].
+/// `CheckedMessage`s can transition to [`VerifiedMessage`].
 #[derive(Clone, Debug)]
-pub(crate) struct CheckedMessageBundle {
+pub(crate) struct CheckedMessage {
     metadata: MessageMetadata,
-    direct_message: SignedMessage<DirectMessage>,
-    echo_broadcast: SignedMessage<EchoBroadcast>,
-    normal_broadcast: SignedMessage<NormalBroadcast>,
+    direct_message: SignedMessagePart<DirectMessage>,
+    echo_broadcast: SignedMessagePart<EchoBroadcast>,
+    normal_broadcast: SignedMessagePart<NormalBroadcast>,
 }
 
-impl CheckedMessageBundle {
+impl CheckedMessage {
     pub fn metadata(&self) -> &MessageMetadata {
         &self.metadata
     }
 
-    pub fn verify<SP>(self, verifier: &SP::Verifier) -> Result<VerifiedMessageBundle<SP>, MessageVerificationError>
+    pub fn verify<SP>(self, verifier: &SP::Verifier) -> Result<VerifiedMessage<SP::Verifier>, MessageVerificationError>
     where
         SP: SessionParameters,
     {
@@ -256,7 +260,7 @@ impl CheckedMessageBundle {
         let echo_broadcast = self.echo_broadcast.verify::<SP>(verifier)?;
         let normal_broadcast = self.normal_broadcast.verify::<SP>(verifier)?;
 
-        Ok(VerifiedMessageBundle {
+        Ok(VerifiedMessage {
             from: verifier.clone(),
             metadata: self.metadata,
             direct_message,
@@ -266,28 +270,26 @@ impl CheckedMessageBundle {
     }
 }
 
-/// A `VerifiedMessageBundle` is the final evolution of a [`MessageBundle`]. At this point in the
-/// process, the [`DirectMessage`] and an eventual [`EchoBroadcast`] have been fully checked and the
-/// signature on the [`SignedMessage`] from the original [`MessageBundle`] successfully verified.
-#[derive_where::derive_where(Debug)]
-#[derive(Clone)]
-pub struct VerifiedMessageBundle<SP: SessionParameters> {
-    from: SP::Verifier,
+// A `VerifiedMessage` is the final evolution of a [`Message`]. At this point in the
+// process, the [`DirectMessage`] and an eventual [`EchoBroadcast`] have been fully checked and the
+// signatures of message parts (direct, broadcast etc) from the original [`Message`] successfully verified.
+
+/// A [`Message`] that had its metadata and signatures verified.
+#[derive(Debug, Clone)]
+pub struct VerifiedMessage<Verifier> {
+    from: Verifier,
     metadata: MessageMetadata,
-    direct_message: VerifiedMessage<DirectMessage>,
-    echo_broadcast: VerifiedMessage<EchoBroadcast>,
-    normal_broadcast: VerifiedMessage<NormalBroadcast>,
+    direct_message: VerifiedMessagePart<DirectMessage>,
+    echo_broadcast: VerifiedMessagePart<EchoBroadcast>,
+    normal_broadcast: VerifiedMessagePart<NormalBroadcast>,
 }
 
-impl<SP> VerifiedMessageBundle<SP>
-where
-    SP: SessionParameters,
-{
+impl<Verifier> VerifiedMessage<Verifier> {
     pub(crate) fn metadata(&self) -> &MessageMetadata {
         &self.metadata
     }
 
-    pub(crate) fn from(&self) -> &SP::Verifier {
+    pub(crate) fn from(&self) -> &Verifier {
         &self.from
     }
 
@@ -303,14 +305,14 @@ where
         self.normal_broadcast.payload()
     }
 
-    /// Split the `VerifiedMessageBundle` into its signed constituent parts:
+    /// Split the `VerifiedMessage` into its signed constituent parts:
     /// the echo broadcast and the direct message.
     pub(crate) fn into_parts(
         self,
     ) -> (
-        SignedMessage<EchoBroadcast>,
-        SignedMessage<NormalBroadcast>,
-        SignedMessage<DirectMessage>,
+        SignedMessagePart<EchoBroadcast>,
+        SignedMessagePart<NormalBroadcast>,
+        SignedMessagePart<DirectMessage>,
     ) {
         let direct_message = self.direct_message.into_unverified();
         let echo_broadcast = self.echo_broadcast.into_unverified();
diff --git a/manul/src/session/session.rs b/manul/src/session/session.rs
index 04d9fdc..210e0b7 100644
--- a/manul/src/session/session.rs
+++ b/manul/src/session/session.rs
@@ -16,7 +16,7 @@ use tracing::{debug, trace};
 use super::{
     echo::EchoRound,
     evidence::Evidence,
-    message::{MessageBundle, MessageVerificationError, SignedMessage, VerifiedMessageBundle},
+    message::{Message, MessageVerificationError, SignedMessagePart, VerifiedMessage},
     transcript::{SessionOutcome, SessionReport, Transcript},
     wire_format::WireFormat,
     LocalError, RemoteError,
@@ -114,8 +114,8 @@ pub struct Session<P: Protocol, SP: SessionParameters> {
     deserializer: Deserializer,
     round: Box<dyn ObjectSafeRound<SP::Verifier, Protocol = P>>,
     message_destinations: BTreeSet<SP::Verifier>,
-    echo_broadcast: SignedMessage<EchoBroadcast>,
-    normal_broadcast: SignedMessage<NormalBroadcast>,
+    echo_broadcast: SignedMessagePart<EchoBroadcast>,
+    normal_broadcast: SignedMessagePart<NormalBroadcast>,
     possible_next_rounds: BTreeSet<RoundId>,
     transcript: Transcript<P, SP>,
 }
@@ -130,7 +130,7 @@ pub enum RoundOutcome<P: Protocol, SP: SessionParameters> {
         /// The session object for the new round.
         session: Session<P, SP>,
         /// The messages intended for the new round cached during the previous round.
-        cached_messages: Vec<VerifiedMessageBundle<SP>>,
+        cached_messages: Vec<VerifiedMessage<SP::Verifier>>,
     },
 }
 
@@ -181,10 +181,10 @@ where
         let verifier = signer.verifying_key();
 
         let echo = round.make_echo_broadcast(rng, &serializer)?;
-        let echo_broadcast = SignedMessage::new::<SP>(rng, &signer, &session_id, round.id(), echo)?;
+        let echo_broadcast = SignedMessagePart::new::<SP>(rng, &signer, &session_id, round.id(), echo)?;
 
         let normal = round.make_normal_broadcast(rng, &serializer)?;
-        let normal_broadcast = SignedMessage::new::<SP>(rng, &signer, &session_id, round.id(), normal)?;
+        let normal_broadcast = SignedMessagePart::new::<SP>(rng, &signer, &session_id, round.id(), normal)?;
 
         let message_destinations = round.message_destinations().clone();
 
@@ -231,28 +231,28 @@ where
         &self,
         rng: &mut impl CryptoRngCore,
         destination: &SP::Verifier,
-    ) -> Result<(MessageBundle, ProcessedArtifact<SP>), LocalError> {
+    ) -> Result<(Message<SP::Verifier>, ProcessedArtifact<SP>), LocalError> {
         let (direct_message, artifact) =
             self.round
                 .make_direct_message_with_artifact(rng, &self.serializer, destination)?;
 
-        let bundle = MessageBundle::new::<SP>(
+        let message = Message::new::<SP>(
             rng,
             &self.signer,
             &self.session_id,
             self.round.id(),
+            destination,
             direct_message,
             self.echo_broadcast.clone(),
             self.normal_broadcast.clone(),
         )?;
 
-        Ok((
-            bundle,
-            ProcessedArtifact {
-                destination: destination.clone(),
-                artifact,
-            },
-        ))
+        let processed_artifact = ProcessedArtifact {
+            destination: destination.clone(),
+            artifact,
+        };
+
+        Ok((message, processed_artifact))
     }
 
     /// Adds the artifact from [`make_message`](`Self::make_message`) to the accumulator.
@@ -286,8 +286,8 @@ where
         &self,
         accum: &mut RoundAccumulator<P, SP>,
         from: &SP::Verifier,
-        message: MessageBundle,
-    ) -> Result<Option<VerifiedMessageBundle<SP>>, LocalError> {
+        message: Message<SP::Verifier>,
+    ) -> Result<Option<VerifiedMessage<SP::Verifier>>, LocalError> {
         // Quick preliminary checks, before we proceed with more expensive verification
         let key = self.verifier();
         if self.transcript.is_banned(from) || accum.is_banned(from) {
@@ -382,7 +382,7 @@ where
     pub fn process_message(
         &self,
         rng: &mut impl CryptoRngCore,
-        message: VerifiedMessageBundle<SP>,
+        message: VerifiedMessage<SP::Verifier>,
     ) -> ProcessedMessage<P, SP> {
         let processed = self.round.receive_message(
             rng,
@@ -545,10 +545,10 @@ pub struct RoundAccumulator<P: Protocol, SP: SessionParameters> {
     processing: BTreeSet<SP::Verifier>,
     payloads: BTreeMap<SP::Verifier, Payload>,
     artifacts: BTreeMap<SP::Verifier, Artifact>,
-    cached: BTreeMap<SP::Verifier, BTreeMap<RoundId, VerifiedMessageBundle<SP>>>,
-    echo_broadcasts: BTreeMap<SP::Verifier, SignedMessage<EchoBroadcast>>,
-    normal_broadcasts: BTreeMap<SP::Verifier, SignedMessage<NormalBroadcast>>,
-    direct_messages: BTreeMap<SP::Verifier, SignedMessage<DirectMessage>>,
+    cached: BTreeMap<SP::Verifier, BTreeMap<RoundId, VerifiedMessage<SP::Verifier>>>,
+    echo_broadcasts: BTreeMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>,
+    normal_broadcasts: BTreeMap<SP::Verifier, SignedMessagePart<NormalBroadcast>>,
+    direct_messages: BTreeMap<SP::Verifier, SignedMessagePart<DirectMessage>>,
     provable_errors: BTreeMap<SP::Verifier, Evidence<P, SP>>,
     unprovable_errors: BTreeMap<SP::Verifier, RemoteError>,
 }
@@ -626,7 +626,7 @@ where
         }
     }
 
-    fn mark_processing(&mut self, message: &VerifiedMessageBundle<SP>) -> Result<(), LocalError> {
+    fn mark_processing(&mut self, message: &VerifiedMessage<SP::Verifier>) -> Result<(), LocalError> {
         if !self.processing.insert(message.from().clone()) {
             Err(LocalError::new(format!(
                 "A message from {:?} is already marked as being processed",
@@ -733,7 +733,7 @@ where
         }
     }
 
-    fn cache_message(&mut self, message: VerifiedMessageBundle<SP>) -> Result<(), LocalError> {
+    fn cache_message(&mut self, message: VerifiedMessage<SP::Verifier>) -> Result<(), LocalError> {
         let from = message.from().clone();
         let round_id = message.metadata().round_id();
         let cached = self.cached.entry(from.clone()).or_default();
@@ -755,14 +755,14 @@ pub struct ProcessedArtifact<SP: SessionParameters> {
 
 #[derive(Debug)]
 pub struct ProcessedMessage<P: Protocol, SP: SessionParameters> {
-    message: VerifiedMessageBundle<SP>,
+    message: VerifiedMessage<SP::Verifier>,
     processed: Result<Payload, ReceiveError<SP::Verifier, P>>,
 }
 
-fn filter_messages<SP: SessionParameters>(
-    messages: BTreeMap<SP::Verifier, BTreeMap<RoundId, VerifiedMessageBundle<SP>>>,
+fn filter_messages<Verifier>(
+    messages: BTreeMap<Verifier, BTreeMap<RoundId, VerifiedMessage<Verifier>>>,
     round_id: RoundId,
-) -> Vec<VerifiedMessageBundle<SP>> {
+) -> Vec<VerifiedMessage<Verifier>> {
     messages
         .into_values()
         .filter_map(|mut messages| messages.remove(&round_id))
@@ -776,13 +776,13 @@ mod tests {
     use impls::impls;
     use serde::{Deserialize, Serialize};
 
-    use super::{MessageBundle, ProcessedArtifact, ProcessedMessage, Session, VerifiedMessageBundle};
+    use super::{Message, ProcessedArtifact, ProcessedMessage, Session, VerifiedMessage};
     use crate::{
         protocol::{
             Deserializer, DirectMessage, EchoBroadcast, NormalBroadcast, Protocol, ProtocolError,
             ProtocolValidationError, RoundId,
         },
-        testing::{BinaryFormat, TestSessionParams},
+        testing::{BinaryFormat, TestSessionParams, TestVerifier},
     };
 
     #[test]
@@ -836,9 +836,9 @@ mod tests {
         assert!(impls!(Session<DummyProtocol, SP>: Sync));
 
         // These objects are sent to/from message processing tasks
-        assert!(impls!(MessageBundle: Send));
+        assert!(impls!(Message<TestVerifier>: Send));
         assert!(impls!(ProcessedArtifact<SP>: Send));
-        assert!(impls!(VerifiedMessageBundle<SP>: Send));
+        assert!(impls!(VerifiedMessage<TestVerifier>: Send));
         assert!(impls!(ProcessedMessage<DummyProtocol, SP>: Send));
     }
 }
diff --git a/manul/src/session/transcript.rs b/manul/src/session/transcript.rs
index edb2c18..a1d2cfe 100644
--- a/manul/src/session/transcript.rs
+++ b/manul/src/session/transcript.rs
@@ -4,14 +4,14 @@ use alloc::{
 };
 use core::fmt::Debug;
 
-use super::{evidence::Evidence, message::SignedMessage, session::SessionParameters, LocalError, RemoteError};
+use super::{evidence::Evidence, message::SignedMessagePart, session::SessionParameters, LocalError, RemoteError};
 use crate::protocol::{DirectMessage, EchoBroadcast, NormalBroadcast, Protocol, RoundId};
 
 #[derive(Debug)]
 pub(crate) struct Transcript<P: Protocol, SP: SessionParameters> {
-    echo_broadcasts: BTreeMap<RoundId, BTreeMap<SP::Verifier, SignedMessage<EchoBroadcast>>>,
-    normal_broadcasts: BTreeMap<RoundId, BTreeMap<SP::Verifier, SignedMessage<NormalBroadcast>>>,
-    direct_messages: BTreeMap<RoundId, BTreeMap<SP::Verifier, SignedMessage<DirectMessage>>>,
+    echo_broadcasts: BTreeMap<RoundId, BTreeMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>>,
+    normal_broadcasts: BTreeMap<RoundId, BTreeMap<SP::Verifier, SignedMessagePart<NormalBroadcast>>>,
+    direct_messages: BTreeMap<RoundId, BTreeMap<SP::Verifier, SignedMessagePart<DirectMessage>>>,
     provable_errors: BTreeMap<SP::Verifier, Evidence<P, SP>>,
     unprovable_errors: BTreeMap<SP::Verifier, RemoteError>,
     missing_messages: BTreeMap<RoundId, BTreeSet<SP::Verifier>>,
@@ -37,9 +37,9 @@ where
     pub fn update(
         self,
         round_id: RoundId,
-        echo_broadcasts: BTreeMap<SP::Verifier, SignedMessage<EchoBroadcast>>,
-        normal_broadcasts: BTreeMap<SP::Verifier, SignedMessage<NormalBroadcast>>,
-        direct_messages: BTreeMap<SP::Verifier, SignedMessage<DirectMessage>>,
+        echo_broadcasts: BTreeMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>,
+        normal_broadcasts: BTreeMap<SP::Verifier, SignedMessagePart<NormalBroadcast>>,
+        direct_messages: BTreeMap<SP::Verifier, SignedMessagePart<DirectMessage>>,
         provable_errors: BTreeMap<SP::Verifier, Evidence<P, SP>>,
         unprovable_errors: BTreeMap<SP::Verifier, RemoteError>,
         missing_messages: BTreeSet<SP::Verifier>,
@@ -116,7 +116,7 @@ where
         &self,
         round_id: RoundId,
         from: &SP::Verifier,
-    ) -> Result<SignedMessage<EchoBroadcast>, LocalError> {
+    ) -> Result<SignedMessagePart<EchoBroadcast>, LocalError> {
         self.echo_broadcasts
             .get(&round_id)
             .ok_or_else(|| LocalError::new(format!("No echo broadcasts registered for {round_id:?}")))?
@@ -129,7 +129,7 @@ where
         &self,
         round_id: RoundId,
         from: &SP::Verifier,
-    ) -> Result<SignedMessage<NormalBroadcast>, LocalError> {
+    ) -> Result<SignedMessagePart<NormalBroadcast>, LocalError> {
         self.normal_broadcasts
             .get(&round_id)
             .ok_or_else(|| LocalError::new(format!("No normal broadcasts registered for {round_id:?}")))?
@@ -142,7 +142,7 @@ where
         &self,
         round_id: RoundId,
         from: &SP::Verifier,
-    ) -> Result<SignedMessage<DirectMessage>, LocalError> {
+    ) -> Result<SignedMessagePart<DirectMessage>, LocalError> {
         self.direct_messages
             .get(&round_id)
             .ok_or_else(|| LocalError::new(format!("No direct messages registered for {round_id:?}")))?
@@ -158,7 +158,7 @@ where
     pub fn echo_broadcasts(
         &self,
         round_id: RoundId,
-    ) -> Result<BTreeMap<SP::Verifier, SignedMessage<EchoBroadcast>>, LocalError> {
+    ) -> Result<BTreeMap<SP::Verifier, SignedMessagePart<EchoBroadcast>>, LocalError> {
         self.echo_broadcasts
             .get(&round_id)
             .cloned()
diff --git a/manul/src/testing/run_sync.rs b/manul/src/testing/run_sync.rs
index 4a45f69..1ca8669 100644
--- a/manul/src/testing/run_sync.rs
+++ b/manul/src/testing/run_sync.rs
@@ -8,7 +8,7 @@ use tracing::debug;
 use crate::{
     protocol::{FirstRound, Protocol},
     session::{
-        CanFinalize, LocalError, MessageBundle, RoundAccumulator, RoundOutcome, Session, SessionId, SessionParameters,
+        CanFinalize, LocalError, Message, RoundAccumulator, RoundOutcome, Session, SessionId, SessionParameters,
         SessionReport,
     },
 };
@@ -21,10 +21,10 @@ enum State<P: Protocol, SP: SessionParameters> {
     Finished(SessionReport<P, SP>),
 }
 
-struct Message<SP: SessionParameters> {
+struct RoundMessage<SP: SessionParameters> {
     from: SP::Verifier,
     to: SP::Verifier,
-    message: MessageBundle,
+    message: Message<SP::Verifier>,
 }
 
 #[allow(clippy::type_complexity)]
@@ -32,7 +32,7 @@ fn propagate<P, SP>(
     rng: &mut impl CryptoRngCore,
     session: Session<P, SP>,
     accum: RoundAccumulator<P, SP>,
-) -> Result<(State<P, SP>, Vec<Message<SP>>), LocalError>
+) -> Result<(State<P, SP>, Vec<RoundMessage<SP>>), LocalError>
 where
     P: 'static + Protocol,
     SP: 'static + SessionParameters,
@@ -74,7 +74,7 @@ where
         let destinations = session.message_destinations();
         for destination in destinations {
             let (message, artifact) = session.make_message(rng, destination)?;
-            messages.push(Message {
+            messages.push(RoundMessage {
                 from: session.verifier().clone(),
                 to: destination.clone(),
                 message,
@@ -110,7 +110,7 @@ where
         let destinations = session.message_destinations();
         for destination in destinations {
             let (message, artifact) = session.make_message(rng, destination)?;
-            messages.push(Message {
+            messages.push(RoundMessage {
                 from: session.verifier().clone(),
                 to: destination.clone(),
                 message,