diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3c464d9..281deb2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,6 +37,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - An impl of `ProtocolError` for `()` for protocols that don't use errors. ([#60])
 - A dummy `CorrectnessProof` trait. ([#60])
 - A `misbehave` combinator, intended primarily for testing. ([#60])
+- A `chain` combinator for chaining two protocols. ([#60])
+- `EntryPoint::ENTRY_ROUND` constant. ([#60])
 
 
 [#32]: https://github.com/entropyxyz/manul/pull/32
diff --git a/examples/src/lib.rs b/examples/src/lib.rs
index c3aff76..37b869c 100644
--- a/examples/src/lib.rs
+++ b/examples/src/lib.rs
@@ -1,6 +1,7 @@
 extern crate alloc;
 
 pub mod simple;
+pub mod simple_chain;
 
 #[cfg(test)]
 mod simple_malicious;
diff --git a/examples/src/simple_chain.rs b/examples/src/simple_chain.rs
new file mode 100644
index 0000000..890292c
--- /dev/null
+++ b/examples/src/simple_chain.rs
@@ -0,0 +1,85 @@
+use core::fmt::Debug;
+
+use manul::{
+    combinators::{Chained, ChainedEntryPoint},
+    protocol::PartyId,
+};
+
+use super::simple::{Inputs, Round1};
+
+pub struct ChainedSimple;
+
+#[derive(Debug)]
+pub struct NewInputs<Id>(Inputs<Id>);
+
+impl<'a, Id: PartyId> From<&'a NewInputs<Id>> for Inputs<Id> {
+    fn from(source: &'a NewInputs<Id>) -> Self {
+        source.0.clone()
+    }
+}
+
+impl<Id: PartyId> From<(NewInputs<Id>, u8)> for Inputs<Id> {
+    fn from(source: (NewInputs<Id>, u8)) -> Self {
+        let (inputs, _result) = source;
+        inputs.0
+    }
+}
+
+impl<Id: PartyId> Chained<Id> for ChainedSimple {
+    type Inputs = NewInputs<Id>;
+    type EntryPoint1 = Round1<Id>;
+    type EntryPoint2 = Round1<Id>;
+}
+
+pub type DoubleSimpleEntryPoint<Id> = ChainedEntryPoint<Id, ChainedSimple>;
+
+#[cfg(test)]
+mod tests {
+    use alloc::collections::BTreeSet;
+
+    use manul::{
+        session::{signature::Keypair, SessionOutcome},
+        testing::{run_sync, BinaryFormat, TestSessionParams, TestSigner, TestVerifier},
+    };
+    use rand_core::OsRng;
+    use tracing_subscriber::EnvFilter;
+
+    use super::{DoubleSimpleEntryPoint, NewInputs};
+    use crate::simple::Inputs;
+
+    #[test]
+    fn round() {
+        let signers = (0..3).map(TestSigner::new).collect::<Vec<_>>();
+        let all_ids = signers
+            .iter()
+            .map(|signer| signer.verifying_key())
+            .collect::<BTreeSet<_>>();
+        let inputs = signers
+            .into_iter()
+            .map(|signer| {
+                (
+                    signer,
+                    NewInputs(Inputs {
+                        all_ids: all_ids.clone(),
+                    }),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        let my_subscriber = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .finish();
+        let reports = tracing::subscriber::with_default(my_subscriber, || {
+            run_sync::<DoubleSimpleEntryPoint<TestVerifier>, TestSessionParams<BinaryFormat>>(&mut OsRng, inputs)
+                .unwrap()
+        });
+
+        for (_id, report) in reports {
+            if let SessionOutcome::Result(result) = report.outcome {
+                assert_eq!(result, 3); // 0 + 1 + 2
+            } else {
+                panic!("Session did not finish successfully");
+            }
+        }
+    }
+}
diff --git a/manul/benches/empty_rounds.rs b/manul/benches/empty_rounds.rs
index 87eefee..9978486 100644
--- a/manul/benches/empty_rounds.rs
+++ b/manul/benches/empty_rounds.rs
@@ -51,6 +51,7 @@ struct Round1Artifact;
 impl<Id: PartyId> EntryPoint<Id> for EmptyRound<Id> {
     type Inputs = Inputs<Id>;
     type Protocol = EmptyProtocol;
+
     fn new(
         _rng: &mut impl CryptoRngCore,
         _shared_randomness: &[u8],
diff --git a/manul/src/combinators.rs b/manul/src/combinators.rs
index 66d2aba..95c3021 100644
--- a/manul/src/combinators.rs
+++ b/manul/src/combinators.rs
@@ -1,5 +1,7 @@
 //! Combinators operating on protocols.
 
+mod chain;
 mod misbehave;
 
+pub use chain::{Chained, ChainedEntryPoint, ChainedProtocol};
 pub use misbehave::{Behavior, Misbehaving, MisbehavingEntryPoint, MisbehavingInputs};
diff --git a/manul/src/combinators/chain.rs b/manul/src/combinators/chain.rs
new file mode 100644
index 0000000..e78d8bd
--- /dev/null
+++ b/manul/src/combinators/chain.rs
@@ -0,0 +1,471 @@
+use alloc::{
+    boxed::Box,
+    collections::{BTreeMap, BTreeSet},
+    format,
+    string::String,
+    vec::Vec,
+};
+use core::{fmt::Debug, marker::PhantomData};
+
+use rand_core::CryptoRngCore;
+use serde::{Deserialize, Serialize};
+
+use crate::protocol::*;
+
+/// A trait defining two protocols executed sequentially.
+pub trait Chained<Id>: 'static
+where
+    Id: PartyId,
+{
+    /// The inputs of the new chained protocol.
+    type Inputs: Send + Sync + Debug;
+
+    /// The entry point of the first protocol.
+    type EntryPoint1: EntryPoint<Id, Inputs: for<'a> From<&'a Self::Inputs>>;
+
+    /// The entry point of the second protocol.
+    type EntryPoint2: EntryPoint<
+        Id,
+        Inputs: From<(
+            Self::Inputs,
+            <<Self::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::Result,
+        )>,
+    >;
+}
+
+#[derive_where::derive_where(Debug, Clone)]
+#[derive(Serialize, Deserialize)]
+#[serde(bound(serialize = "
+    <<C::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::ProtocolError: Serialize,
+    <<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::ProtocolError: Serialize,
+"))]
+#[serde(bound(deserialize = "
+    <<C::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::ProtocolError: for<'x> Deserialize<'x>,
+    <<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::ProtocolError: for<'x> Deserialize<'x>,
+"))]
+pub enum ChainedProtocolError<Id: PartyId, C: Chained<Id>> {
+    Protocol1(<<C::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::ProtocolError),
+    Protocol2(<<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::ProtocolError),
+}
+
+impl<Id, C> ChainedProtocolError<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+    fn from_protocol1(err: <<C::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::ProtocolError) -> Self {
+        Self::Protocol1(err)
+    }
+
+    fn from_protocol2(err: <<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::ProtocolError) -> Self {
+        Self::Protocol2(err)
+    }
+}
+
+impl<Id, C> ProtocolError for ChainedProtocolError<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+    fn description(&self) -> String {
+        match self {
+            Self::Protocol1(err) => format!("Protocol1: {}", err.description()),
+            Self::Protocol2(err) => format!("Protocol2: {}", err.description()),
+        }
+    }
+
+    fn required_direct_messages(&self) -> BTreeSet<RoundId> {
+        let (protocol_num, round_ids) = match self {
+            Self::Protocol1(err) => (1, err.required_direct_messages()),
+            Self::Protocol2(err) => (2, err.required_direct_messages()),
+        };
+        round_ids
+            .into_iter()
+            .map(|round_id| round_id.group_under(protocol_num))
+            .collect()
+    }
+
+    fn required_echo_broadcasts(&self) -> BTreeSet<RoundId> {
+        let (protocol_num, round_ids) = match self {
+            Self::Protocol1(err) => (1, err.required_echo_broadcasts()),
+            Self::Protocol2(err) => (2, err.required_echo_broadcasts()),
+        };
+        round_ids
+            .into_iter()
+            .map(|round_id| round_id.group_under(protocol_num))
+            .collect()
+    }
+
+    fn required_normal_broadcasts(&self) -> BTreeSet<RoundId> {
+        let (protocol_num, round_ids) = match self {
+            Self::Protocol1(err) => (1, err.required_normal_broadcasts()),
+            Self::Protocol2(err) => (2, err.required_normal_broadcasts()),
+        };
+        round_ids
+            .into_iter()
+            .map(|round_id| round_id.group_under(protocol_num))
+            .collect()
+    }
+
+    fn required_combined_echos(&self) -> BTreeSet<RoundId> {
+        let (protocol_num, round_ids) = match self {
+            Self::Protocol1(err) => (1, err.required_combined_echos()),
+            Self::Protocol2(err) => (2, err.required_combined_echos()),
+        };
+        round_ids
+            .into_iter()
+            .map(|round_id| round_id.group_under(protocol_num))
+            .collect()
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn verify_messages_constitute_error(
+        &self,
+        deserializer: &Deserializer,
+        echo_broadcast: &EchoBroadcast,
+        normal_broadcast: &NormalBroadcast,
+        direct_message: &DirectMessage,
+        echo_broadcasts: &BTreeMap<RoundId, EchoBroadcast>,
+        normal_broadcasts: &BTreeMap<RoundId, NormalBroadcast>,
+        direct_messages: &BTreeMap<RoundId, DirectMessage>,
+        combined_echos: &BTreeMap<RoundId, Vec<EchoBroadcast>>,
+    ) -> Result<(), ProtocolValidationError> {
+        // TODO: the cloning can be avoided if instead we provide a reference to some "transcript API",
+        // and can replace it here with a proxy that will remove nesting from round ID's.
+        let echo_broadcasts = echo_broadcasts
+            .clone()
+            .into_iter()
+            .map(|(round_id, v)| round_id.ungroup().map(|round_id| (round_id, v)))
+            .collect::<Result<BTreeMap<_, _>, _>>()?;
+        let normal_broadcasts = normal_broadcasts
+            .clone()
+            .into_iter()
+            .map(|(round_id, v)| round_id.ungroup().map(|round_id| (round_id, v)))
+            .collect::<Result<BTreeMap<_, _>, _>>()?;
+        let direct_messages = direct_messages
+            .clone()
+            .into_iter()
+            .map(|(round_id, v)| round_id.ungroup().map(|round_id| (round_id, v)))
+            .collect::<Result<BTreeMap<_, _>, _>>()?;
+        let combined_echos = combined_echos
+            .clone()
+            .into_iter()
+            .map(|(round_id, v)| round_id.ungroup().map(|round_id| (round_id, v)))
+            .collect::<Result<BTreeMap<_, _>, _>>()?;
+
+        match self {
+            Self::Protocol1(err) => err.verify_messages_constitute_error(
+                deserializer,
+                echo_broadcast,
+                normal_broadcast,
+                direct_message,
+                &echo_broadcasts,
+                &normal_broadcasts,
+                &direct_messages,
+                &combined_echos,
+            ),
+            Self::Protocol2(err) => err.verify_messages_constitute_error(
+                deserializer,
+                echo_broadcast,
+                normal_broadcast,
+                direct_message,
+                &echo_broadcasts,
+                &normal_broadcasts,
+                &direct_messages,
+                &combined_echos,
+            ),
+        }
+    }
+}
+
+#[derive_where::derive_where(Debug, Clone)]
+#[derive(Serialize, Deserialize)]
+#[serde(bound(serialize = "
+    <<C::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::CorrectnessProof: Serialize,
+    <<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::CorrectnessProof: Serialize,
+"))]
+#[serde(bound(deserialize = "
+    <<C::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::CorrectnessProof: for<'x> Deserialize<'x>,
+    <<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::CorrectnessProof: for<'x> Deserialize<'x>,
+"))]
+pub enum ChainedCorrectnessProof<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+    Protocol1(<<C::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::CorrectnessProof),
+    Protocol2(<<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::CorrectnessProof),
+}
+
+impl<Id, C> ChainedCorrectnessProof<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+    fn from_protocol1(proof: <<C::EntryPoint1 as EntryPoint<Id>>::Protocol as Protocol>::CorrectnessProof) -> Self {
+        Self::Protocol1(proof)
+    }
+
+    fn from_protocol2(proof: <<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::CorrectnessProof) -> Self {
+        Self::Protocol2(proof)
+    }
+}
+
+impl<Id, C> CorrectnessProof for ChainedCorrectnessProof<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+}
+
+/// The protocol resulting from chaining two sub-protocols as described by `C`.
+#[derive(Debug)]
+#[allow(clippy::type_complexity)]
+pub struct ChainedProtocol<Id: PartyId, C: Chained<Id>>(PhantomData<fn((Id, C)) -> (Id, C)>);
+
+impl<Id, C> Protocol for ChainedProtocol<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+    type Result = <<C::EntryPoint2 as EntryPoint<Id>>::Protocol as Protocol>::Result;
+    type ProtocolError = ChainedProtocolError<Id, C>;
+    type CorrectnessProof = ChainedCorrectnessProof<Id, C>;
+}
+
+/// The entry point of the chained protocol.
+#[derive_where::derive_where(Debug)]
+pub struct ChainedEntryPoint<Id: PartyId, C: Chained<Id>> {
+    state: ChainState<Id, C>,
+}
+
+#[derive_where::derive_where(Debug)]
+enum ChainState<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+    Protocol1 {
+        round: BoxedRound<Id, <C::EntryPoint1 as EntryPoint<Id>>::Protocol>,
+        shared_randomness: Box<[u8]>,
+        id: Id,
+        inputs: C::Inputs,
+    },
+    Protocol2(BoxedRound<Id, <C::EntryPoint2 as EntryPoint<Id>>::Protocol>),
+}
+
+impl<Id, C> EntryPoint<Id> for ChainedEntryPoint<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+    type Inputs = C::Inputs;
+    type Protocol = ChainedProtocol<Id, C>;
+    const ENTRY_ROUND: RoundId = <C::EntryPoint1 as EntryPoint<Id>>::ENTRY_ROUND.group_under(1);
+
+    fn new(
+        rng: &mut impl CryptoRngCore,
+        shared_randomness: &[u8],
+        id: Id,
+        inputs: Self::Inputs,
+    ) -> Result<BoxedRound<Id, Self::Protocol>, LocalError> {
+        let round = C::EntryPoint1::new(rng, shared_randomness, id.clone(), (&inputs).into())?;
+        let round = ChainedEntryPoint {
+            state: ChainState::Protocol1 {
+                shared_randomness: shared_randomness.into(),
+                id,
+                inputs,
+                round,
+            },
+        };
+        Ok(BoxedRound::new_object_safe(round))
+    }
+}
+
+impl<Id, C> ObjectSafeRound<Id> for ChainedEntryPoint<Id, C>
+where
+    Id: PartyId,
+    C: Chained<Id>,
+{
+    type Protocol = ChainedProtocol<Id, C>;
+
+    fn id(&self) -> RoundId {
+        match &self.state {
+            ChainState::Protocol1 { round, .. } => round.as_ref().id().group_under(1),
+            ChainState::Protocol2(round) => round.as_ref().id().group_under(2),
+        }
+    }
+
+    fn possible_next_rounds(&self) -> BTreeSet<RoundId> {
+        match &self.state {
+            ChainState::Protocol1 { round, .. } => {
+                let mut next_rounds = round
+                    .as_ref()
+                    .possible_next_rounds()
+                    .into_iter()
+                    .map(|round_id| round_id.group_under(1))
+                    .collect::<BTreeSet<_>>();
+
+                // If there are no next rounds, this is the result round.
+                // This means that in the chain the next round will be the entry round of the second protocol.
+                if next_rounds.is_empty() {
+                    next_rounds.insert(C::EntryPoint2::ENTRY_ROUND.group_under(2));
+                }
+                next_rounds
+            }
+            ChainState::Protocol2(round) => round
+                .as_ref()
+                .possible_next_rounds()
+                .into_iter()
+                .map(|round_id| round_id.group_under(2))
+                .collect(),
+        }
+    }
+
+    fn message_destinations(&self) -> &BTreeSet<Id> {
+        match &self.state {
+            ChainState::Protocol1 { round, .. } => round.as_ref().message_destinations(),
+            ChainState::Protocol2(round) => round.as_ref().message_destinations(),
+        }
+    }
+
+    fn make_direct_message(
+        &self,
+        rng: &mut dyn CryptoRngCore,
+        serializer: &Serializer,
+        deserializer: &Deserializer,
+        destination: &Id,
+    ) -> Result<(DirectMessage, Option<Artifact>), LocalError> {
+        match &self.state {
+            ChainState::Protocol1 { round, .. } => {
+                round
+                    .as_ref()
+                    .make_direct_message(rng, serializer, deserializer, destination)
+            }
+            ChainState::Protocol2(round) => {
+                round
+                    .as_ref()
+                    .make_direct_message(rng, serializer, deserializer, destination)
+            }
+        }
+    }
+
+    fn make_echo_broadcast(
+        &self,
+        rng: &mut dyn CryptoRngCore,
+        serializer: &Serializer,
+        deserializer: &Deserializer,
+    ) -> Result<EchoBroadcast, LocalError> {
+        match &self.state {
+            ChainState::Protocol1 { round, .. } => round.as_ref().make_echo_broadcast(rng, serializer, deserializer),
+            ChainState::Protocol2(round) => round.as_ref().make_echo_broadcast(rng, serializer, deserializer),
+        }
+    }
+
+    fn make_normal_broadcast(
+        &self,
+        rng: &mut dyn CryptoRngCore,
+        serializer: &Serializer,
+        deserializer: &Deserializer,
+    ) -> Result<NormalBroadcast, LocalError> {
+        match &self.state {
+            ChainState::Protocol1 { round, .. } => round.as_ref().make_normal_broadcast(rng, serializer, deserializer),
+            ChainState::Protocol2(round) => round.as_ref().make_normal_broadcast(rng, serializer, deserializer),
+        }
+    }
+
+    fn receive_message(
+        &self,
+        rng: &mut dyn CryptoRngCore,
+        deserializer: &Deserializer,
+        from: &Id,
+        echo_broadcast: EchoBroadcast,
+        normal_broadcast: NormalBroadcast,
+        direct_message: DirectMessage,
+    ) -> Result<Payload, ReceiveError<Id, Self::Protocol>> {
+        match &self.state {
+            ChainState::Protocol1 { round, .. } => match round.as_ref().receive_message(
+                rng,
+                deserializer,
+                from,
+                echo_broadcast,
+                normal_broadcast,
+                direct_message,
+            ) {
+                Ok(payload) => Ok(payload),
+                Err(err) => Err(err.map(ChainedProtocolError::from_protocol1)),
+            },
+            ChainState::Protocol2(round) => match round.as_ref().receive_message(
+                rng,
+                deserializer,
+                from,
+                echo_broadcast,
+                normal_broadcast,
+                direct_message,
+            ) {
+                Ok(payload) => Ok(payload),
+                Err(err) => Err(err.map(ChainedProtocolError::from_protocol2)),
+            },
+        }
+    }
+
+    fn finalize(
+        self: Box<Self>,
+        rng: &mut dyn CryptoRngCore,
+        payloads: BTreeMap<Id, Payload>,
+        artifacts: BTreeMap<Id, Artifact>,
+    ) -> Result<FinalizeOutcome<Id, Self::Protocol>, FinalizeError<Self::Protocol>> {
+        match self.state {
+            ChainState::Protocol1 {
+                round,
+                id,
+                inputs,
+                shared_randomness,
+            } => match round.into_boxed().finalize(rng, payloads, artifacts) {
+                Ok(FinalizeOutcome::Result(result)) => {
+                    let mut boxed_rng = BoxedRng(rng);
+                    let round = C::EntryPoint2::new(&mut boxed_rng, &shared_randomness, id, (inputs, result).into())?;
+
+                    Ok(FinalizeOutcome::AnotherRound(BoxedRound::new_object_safe(
+                        ChainedEntryPoint::<Id, C> {
+                            state: ChainState::Protocol2(round),
+                        },
+                    )))
+                }
+                Ok(FinalizeOutcome::AnotherRound(round)) => Ok(FinalizeOutcome::AnotherRound(
+                    BoxedRound::new_object_safe(ChainedEntryPoint::<Id, C> {
+                        state: ChainState::Protocol1 {
+                            shared_randomness,
+                            id,
+                            inputs,
+                            round,
+                        },
+                    }),
+                )),
+                Err(FinalizeError::Local(err)) => Err(FinalizeError::Local(err)),
+                Err(FinalizeError::Unattributable(proof)) => Err(FinalizeError::Unattributable(
+                    ChainedCorrectnessProof::from_protocol1(proof),
+                )),
+            },
+            ChainState::Protocol2(round) => match round.into_boxed().finalize(rng, payloads, artifacts) {
+                Ok(FinalizeOutcome::Result(result)) => Ok(FinalizeOutcome::Result(result)),
+                Ok(FinalizeOutcome::AnotherRound(round)) => Ok(FinalizeOutcome::AnotherRound(
+                    BoxedRound::new_object_safe(ChainedEntryPoint::<Id, C> {
+                        state: ChainState::Protocol2(round),
+                    }),
+                )),
+                Err(FinalizeError::Local(err)) => Err(FinalizeError::Local(err)),
+                Err(FinalizeError::Unattributable(proof)) => Err(FinalizeError::Unattributable(
+                    ChainedCorrectnessProof::from_protocol2(proof),
+                )),
+            },
+        }
+    }
+
+    fn expecting_messages_from(&self) -> &BTreeSet<Id> {
+        match &self.state {
+            ChainState::Protocol1 { round, .. } => round.as_ref().expecting_messages_from(),
+            ChainState::Protocol2(round) => round.as_ref().expecting_messages_from(),
+        }
+    }
+}
diff --git a/manul/src/protocol/errors.rs b/manul/src/protocol/errors.rs
index a77ecc3..a5820f2 100644
--- a/manul/src/protocol/errors.rs
+++ b/manul/src/protocol/errors.rs
@@ -1,4 +1,4 @@
-use alloc::{format, string::String};
+use alloc::{boxed::Box, format, string::String};
 use core::fmt::Debug;
 
 use super::round::Protocol;
@@ -50,7 +50,7 @@ pub(crate) enum ReceiveErrorType<Id, P: Protocol> {
     // so this whole enum is crate-private and the variants are created
     // via constructors and From impls.
     /// An echo round error occurred.
-    Echo(EchoRoundError<Id>),
+    Echo(Box<EchoRoundError<Id>>),
 }
 
 impl<Id, P: Protocol> ReceiveError<Id, P> {
@@ -68,6 +68,33 @@ impl<Id, P: Protocol> ReceiveError<Id, P> {
     pub fn protocol(error: P::ProtocolError) -> Self {
         Self(ReceiveErrorType::Protocol(error))
     }
+
+    /// Maps the error to a different protocol, given the mapping function for protocol errors.
+    pub(crate) fn map<T, F>(self, f: F) -> ReceiveError<Id, T>
+    where
+        F: Fn(P::ProtocolError) -> T::ProtocolError,
+        T: Protocol,
+    {
+        ReceiveError(self.0.map::<T, F>(f))
+    }
+}
+
+impl<Id, P: Protocol> ReceiveErrorType<Id, P> {
+    pub(crate) fn map<T, F>(self, f: F) -> ReceiveErrorType<Id, T>
+    where
+        F: Fn(P::ProtocolError) -> T::ProtocolError,
+        T: Protocol,
+    {
+        match self {
+            Self::Local(err) => ReceiveErrorType::Local(err),
+            Self::InvalidDirectMessage(err) => ReceiveErrorType::InvalidDirectMessage(err),
+            Self::InvalidEchoBroadcast(err) => ReceiveErrorType::InvalidEchoBroadcast(err),
+            Self::InvalidNormalBroadcast(err) => ReceiveErrorType::InvalidNormalBroadcast(err),
+            Self::Unprovable(err) => ReceiveErrorType::Unprovable(err),
+            Self::Echo(err) => ReceiveErrorType::Echo(err),
+            Self::Protocol(err) => ReceiveErrorType::Protocol(f(err)),
+        }
+    }
 }
 
 impl<Id, P> From<LocalError> for ReceiveError<Id, P>
@@ -93,7 +120,7 @@ where
     P: Protocol,
 {
     fn from(error: EchoRoundError<Id>) -> Self {
-        Self(ReceiveErrorType::Echo(error))
+        Self(ReceiveErrorType::Echo(Box::new(error)))
     }
 }
 
diff --git a/manul/src/protocol/round.rs b/manul/src/protocol/round.rs
index 1f8c556..17e1a32 100644
--- a/manul/src/protocol/round.rs
+++ b/manul/src/protocol/round.rs
@@ -5,7 +5,10 @@ use alloc::{
     string::String,
     vec::Vec,
 };
-use core::{any::Any, fmt::Debug};
+use core::{
+    any::Any,
+    fmt::{self, Debug, Display},
+};
 
 use rand_core::CryptoRngCore;
 use serde::{Deserialize, Serialize};
@@ -26,22 +29,86 @@ pub enum FinalizeOutcome<Id: PartyId, P: Protocol> {
     Result(P::Result),
 }
 
+// Maximum depth of group nesting in RoundIds.
+// We need this to be limited to allow the nesting to be performed in `const` context
+// (since we cannot use heap there).
+const ROUND_ID_DEPTH: usize = 8;
+
 /// A round identifier.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct RoundId {
-    round_num: u8,
+    depth: u8,
+    round_nums: [u8; ROUND_ID_DEPTH],
     is_echo: bool,
 }
 
+impl Display for RoundId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(f, "Round ")?;
+        for i in (0..self.depth as usize).rev() {
+            write!(f, "{}", self.round_nums.get(i).expect("Depth within range"))?;
+            if i != 0 {
+                write!(f, "-")?;
+            }
+        }
+        Ok(())
+    }
+}
+
 impl RoundId {
     /// Creates a new round identifier.
-    pub fn new(round_num: u8) -> Self {
+    pub const fn new(round_num: u8) -> Self {
+        let mut round_nums = [0u8; ROUND_ID_DEPTH];
+        #[allow(clippy::indexing_slicing)]
+        {
+            round_nums[0] = round_num;
+        }
         Self {
-            round_num,
+            depth: 1,
+            round_nums,
             is_echo: false,
         }
     }
 
+    /// Prefixes this round ID (possibly already nested) with a group number.
+    ///
+    /// **Warning:** the maximum nesting depth is 8. Panics if this nesting overflows it.
+    pub(crate) const fn group_under(&self, round_num: u8) -> Self {
+        if self.depth as usize == ROUND_ID_DEPTH {
+            panic!("Maximum depth reached");
+        }
+        let mut round_nums = self.round_nums;
+
+        // Would use `expect("Depth within range")` here, but `expect()` in const fns is unstable.
+        #[allow(clippy::indexing_slicing)]
+        {
+            round_nums[self.depth as usize] = round_num;
+        }
+
+        Self {
+            depth: self.depth + 1,
+            round_nums,
+            is_echo: self.is_echo,
+        }
+    }
+
+    /// Removes the top group prefix from this round ID.
+    ///
+    /// Returns the `Err` variant if the round ID is not nested.
+    pub(crate) fn ungroup(&self) -> Result<Self, LocalError> {
+        if self.depth == 1 {
+            Err(LocalError::new("This round ID is not in a group"))
+        } else {
+            let mut round_nums = self.round_nums;
+            *round_nums.get_mut(self.depth as usize - 1).expect("Depth within range") = 0;
+            Ok(Self {
+                depth: self.depth - 1,
+                round_nums,
+                is_echo: self.is_echo,
+            })
+        }
+    }
+
     /// Returns `true` if this is an ID of an echo broadcast round.
     pub(crate) fn is_echo(&self) -> bool {
         self.is_echo
@@ -57,7 +124,8 @@ impl RoundId {
             panic!("This is already an echo round ID");
         }
         Self {
-            round_num: self.round_num,
+            depth: self.depth,
+            round_nums: self.round_nums,
             is_echo: true,
         }
     }
@@ -72,7 +140,8 @@ impl RoundId {
             panic!("This is already an non-echo round ID");
         }
         Self {
-            round_num: self.round_num,
+            depth: self.depth,
+            round_nums: self.round_nums,
             is_echo: false,
         }
     }
@@ -299,6 +368,9 @@ pub trait EntryPoint<Id: PartyId> {
     /// The protocol implemented by the round this entry points returns.
     type Protocol: Protocol;
 
+    /// The ID of the round returned by [`Self::new`].
+    const ENTRY_ROUND: RoundId = RoundId::new(1);
+
     /// Creates the round.
     ///
     /// `session_id` can be assumed to be the same for each node participating in a session.
diff --git a/manul/src/session/session.rs b/manul/src/session/session.rs
index ad33fc3..b8edb31 100644
--- a/manul/src/session/session.rs
+++ b/manul/src/session/session.rs
@@ -349,7 +349,7 @@ where
             }
             Err(MessageVerificationError::Local(error)) => return Err(error),
         };
-        debug!("{key:?}: Received {message_round_id:?} message from {from:?}");
+        debug!("{key:?}: Received {message_round_id} message from {from:?}");
 
         match message_for {
             MessageFor::ThisRound => {
@@ -357,7 +357,7 @@ where
                 Ok(PreprocessOutcome::ToProcess(verified_message))
             }
             MessageFor::NextRound => {
-                debug!("{key:?}: Caching message from {from:?} for {message_round_id:?}");
+                debug!("{key:?}: Caching message from {from:?} for {message_round_id}");
                 accum.cache_message(verified_message)?;
                 Ok(PreprocessOutcome::Cached)
             }
@@ -734,7 +734,7 @@ where
             }
             ReceiveErrorType::Echo(error) => {
                 let (_echo_broadcast, normal_broadcast, _direct_message) = processed.message.into_parts();
-                let evidence = Evidence::new_echo_round_error(&from, normal_broadcast, error)?;
+                let evidence = Evidence::new_echo_round_error(&from, normal_broadcast, *error)?;
                 self.register_provable_error(&from, evidence)
             }
             ReceiveErrorType::Local(error) => Err(error),
diff --git a/manul/src/testing/run_sync.rs b/manul/src/testing/run_sync.rs
index aa3db0c..8d08c87 100644
--- a/manul/src/testing/run_sync.rs
+++ b/manul/src/testing/run_sync.rs
@@ -45,7 +45,7 @@ where
     let state = loop {
         match session.can_finalize(&accum) {
             CanFinalize::Yes => {
-                debug!("{:?}: finalizing {:?}", session.verifier(), session.round_id(),);
+                debug!("{:?}: finalizing {}", session.verifier(), session.round_id());
                 match session.finalize_round(rng, accum)? {
                     RoundOutcome::Finished(report) => break State::Finished(report),
                     RoundOutcome::AnotherRound {