src/group/proposal.rs - platform/external/rust/crates/mls-rs - Git at Google

 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // Copyright by contributors to this project.
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)

 use alloc::{boxed::Box, vec::Vec};

 #[cfg(feature = "by_ref_proposal")]
 use crate::tree_kem::leaf_node::LeafNode;

 use crate::{
     client::MlsError, tree_kem::node::LeafIndex, CipherSuite, KeyPackage, MlsMessage,
     ProtocolVersion,
 };
 use core::fmt::{self, Debug};
 use mls_rs_codec::{MlsDecode, MlsEncode, MlsSize};
 use mls_rs_core::{group::Capabilities, identity::SigningIdentity};

 #[cfg(feature = "by_ref_proposal")]
 use crate::group::proposal_ref::ProposalRef;

 pub use mls_rs_core::extension::ExtensionList;
 pub use mls_rs_core::group::ProposalType;

 #[cfg(feature = "psk")]
 use crate::psk::{ExternalPskId, JustPreSharedKeyID, PreSharedKeyID};

 #[derive(Clone, Debug, PartialEq, MlsSize, MlsEncode, MlsDecode)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A proposal that adds a member to a [`Group`](crate::group::Group).
 pub struct AddProposal {
     pub(crate) key_package: KeyPackage,
 }

 impl AddProposal {
     /// The [`SigningIdentity`] of the [`Member`](mls_rs_core::group::Member)
     /// that will be added by this proposal.
     pub fn signing_identity(&self) -> &SigningIdentity {
         self.key_package.signing_identity()
     }

     /// Client [`Capabilities`] of the [`Member`](mls_rs_core::group::Member)
     /// that will be added by this proposal.
     pub fn capabilities(&self) -> Capabilities {
         self.key_package.leaf_node.ungreased_capabilities()
     }

     /// Key package extensions that are assoiciated with the
     /// [`Member`](mls_rs_core::group::Member) that will be added by this proposal.
     pub fn key_package_extensions(&self) -> ExtensionList {
         self.key_package.ungreased_extensions()
     }

     /// Leaf node extensions that will be entered into the group state for the
     /// [`Member`](mls_rs_core::group::Member) that will be added.
     pub fn leaf_node_extensions(&self) -> ExtensionList {
         self.key_package.leaf_node.ungreased_extensions()
     }
 }

 impl From<KeyPackage> for AddProposal {
     fn from(key_package: KeyPackage) -> Self {
         Self { key_package }
     }
 }

 impl TryFrom<MlsMessage> for AddProposal {
     type Error = MlsError;

     fn try_from(value: MlsMessage) -> Result<Self, Self::Error> {
         value
             .into_key_package()
             .ok_or(MlsError::UnexpectedMessageType)
             .map(Into::into)
     }
 }

 #[cfg(feature = "by_ref_proposal")]
 #[derive(Clone, Debug, PartialEq, MlsSize, MlsEncode, MlsDecode)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A proposal that will update an existing [`Member`](mls_rs_core::group::Member) of a
 /// [`Group`](crate::group::Group).
 pub struct UpdateProposal {
     pub(crate) leaf_node: LeafNode,
 }

 #[cfg(feature = "by_ref_proposal")]
 impl UpdateProposal {
     /// The new [`SigningIdentity`] of the [`Member`](mls_rs_core::group::Member)
     /// that is being updated by this proposal.
     pub fn signing_identity(&self) -> &SigningIdentity {
         &self.leaf_node.signing_identity
     }

     /// New Client [`Capabilities`] of the [`Member`](mls_rs_core::group::Member)
     /// that will be updated by this proposal.
     pub fn capabilities(&self) -> Capabilities {
         self.leaf_node.ungreased_capabilities()
     }

     /// New Leaf node extensions that will be entered into the group state for the
     /// [`Member`](mls_rs_core::group::Member) that is being updated by this proposal.
     pub fn leaf_node_extensions(&self) -> ExtensionList {
         self.leaf_node.ungreased_extensions()
     }
 }

 #[derive(Clone, Debug, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A proposal to remove an existing [`Member`](mls_rs_core::group::Member) of a
 /// [`Group`](crate::group::Group).
 pub struct RemoveProposal {
     pub(crate) to_remove: LeafIndex,
 }

 impl RemoveProposal {
     /// The index of the [`Member`](mls_rs_core::group::Member) that will be removed by
     /// this proposal.
     pub fn to_remove(&self) -> u32 {
         *self.to_remove
     }
 }

 impl From<u32> for RemoveProposal {
     fn from(value: u32) -> Self {
         RemoveProposal {
             to_remove: LeafIndex(value),
         }
     }
 }

 #[cfg(feature = "psk")]
 #[derive(Clone, Debug, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A proposal to add a pre-shared key to a group.
 pub struct PreSharedKeyProposal {
     pub(crate) psk: PreSharedKeyID,
 }

 #[cfg(feature = "psk")]
 impl PreSharedKeyProposal {
     /// The external pre-shared key id of this proposal.
     ///
     /// MLS requires the pre-shared key type for PreSharedKeyProposal to be of
     /// type `External`.
     ///
     /// Returns `None` in the condition that the underlying psk is not external.
     pub fn external_psk_id(&self) -> Option<&ExternalPskId> {
         match self.psk.key_id {
             JustPreSharedKeyID::External(ref ext) => Some(ext),
             JustPreSharedKeyID::Resumption(_) => None,
         }
     }
 }

 #[derive(Clone, PartialEq, MlsSize, MlsEncode, MlsDecode)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A proposal to reinitialize a group using new parameters.
 pub struct ReInitProposal {
     #[mls_codec(with = "mls_rs_codec::byte_vec")]
     #[cfg_attr(feature = "serde", serde(with = "mls_rs_core::vec_serde"))]
     pub(crate) group_id: Vec<u8>,
     pub(crate) version: ProtocolVersion,
     pub(crate) cipher_suite: CipherSuite,
     pub(crate) extensions: ExtensionList,
 }

 impl Debug for ReInitProposal {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ReInitProposal")
             .field(
                 "group_id",
                 &mls_rs_core::debug::pretty_group_id(&self.group_id),
             )
             .field("version", &self.version)
             .field("cipher_suite", &self.cipher_suite)
             .field("extensions", &self.extensions)
             .finish()
     }
 }

 impl ReInitProposal {
     /// The unique id of the new group post reinitialization.
     pub fn group_id(&self) -> &[u8] {
         &self.group_id
     }

     /// The new protocol version to use post reinitialization.
     pub fn new_version(&self) -> ProtocolVersion {
         self.version
     }

     /// The new ciphersuite to use post reinitialization.
     pub fn new_cipher_suite(&self) -> CipherSuite {
         self.cipher_suite
     }

     /// Group context extensions to set in the new group post reinitialization.
     pub fn new_group_context_extensions(&self) -> &ExtensionList {
         &self.extensions
     }
 }

 #[derive(Clone, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A proposal used for external commits.
 pub struct ExternalInit {
     #[mls_codec(with = "mls_rs_codec::byte_vec")]
     #[cfg_attr(feature = "serde", serde(with = "mls_rs_core::vec_serde"))]
     pub(crate) kem_output: Vec<u8>,
 }

 impl Debug for ExternalInit {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ExternalInit")
             .field(
                 "kem_output",
                 &mls_rs_core::debug::pretty_bytes(&self.kem_output),
             )
             .finish()
     }
 }

 #[cfg(feature = "custom_proposal")]
 #[derive(Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(
     all(feature = "ffi", not(test)),
     safer_ffi_gen::ffi_type(clone, opaque)
 )]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A user defined custom proposal.
 ///
 /// User defined proposals are passed through the protocol as an opaque value.
 pub struct CustomProposal {
     proposal_type: ProposalType,
     #[cfg_attr(feature = "serde", serde(with = "mls_rs_core::vec_serde"))]
     data: Vec<u8>,
 }

 #[cfg(feature = "custom_proposal")]
 impl Debug for CustomProposal {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("CustomProposal")
             .field("proposal_type", &self.proposal_type)
             .field("data", &mls_rs_core::debug::pretty_bytes(&self.data))
             .finish()
     }
 }

 #[cfg(feature = "custom_proposal")]
 #[cfg_attr(all(feature = "ffi", not(test)), safer_ffi_gen::safer_ffi_gen)]
 impl CustomProposal {
     /// Create a custom proposal.
     ///
     /// # Warning
     ///
     /// Avoid using the [`ProposalType`] values that have constants already
     /// defined by this crate. Using existing constants in a custom proposal
     /// has unspecified behavior.
     pub fn new(proposal_type: ProposalType, data: Vec<u8>) -> Self {
         Self {
             proposal_type,
             data,
         }
     }

     /// The proposal type used for this custom proposal.
     pub fn proposal_type(&self) -> ProposalType {
         self.proposal_type
     }

     /// The opaque data communicated by this custom proposal.
     pub fn data(&self) -> &[u8] {
         &self.data
     }
 }

 /// Trait to simplify creating custom proposals that are serialized with MLS
 /// encoding.
 #[cfg(feature = "custom_proposal")]
 pub trait MlsCustomProposal: MlsSize + MlsEncode + MlsDecode + Sized {
     fn proposal_type() -> ProposalType;

     fn to_custom_proposal(&self) -> Result<CustomProposal, mls_rs_codec::Error> {
         Ok(CustomProposal::new(
             Self::proposal_type(),
             self.mls_encode_to_vec()?,
         ))
     }

     fn from_custom_proposal(proposal: &CustomProposal) -> Result<Self, mls_rs_codec::Error> {
         if proposal.proposal_type() != Self::proposal_type() {
             // #[cfg(feature = "std")]
             // return Err(mls_rs_codec::Error::Custom(
             //     "invalid proposal type".to_string(),
             // ));

             //#[cfg(not(feature = "std"))]
             return Err(mls_rs_codec::Error::Custom(4));
         }

         Self::mls_decode(&mut proposal.data())
     }
 }

 #[allow(clippy::large_enum_variant)]
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(u16)]
 #[non_exhaustive]
 /// An enum that represents all possible types of proposals.
 pub enum Proposal {
     Add(alloc::boxed::Box<AddProposal>),
     #[cfg(feature = "by_ref_proposal")]
     Update(UpdateProposal),
     Remove(RemoveProposal),
     #[cfg(feature = "psk")]
     Psk(PreSharedKeyProposal),
     ReInit(ReInitProposal),
     ExternalInit(ExternalInit),
     GroupContextExtensions(ExtensionList),
     #[cfg(feature = "custom_proposal")]
     Custom(CustomProposal),
 }

 impl MlsSize for Proposal {
     fn mls_encoded_len(&self) -> usize {
         let inner_len = match self {
             Proposal::Add(p) => p.mls_encoded_len(),
             #[cfg(feature = "by_ref_proposal")]
             Proposal::Update(p) => p.mls_encoded_len(),
             Proposal::Remove(p) => p.mls_encoded_len(),
             #[cfg(feature = "psk")]
             Proposal::Psk(p) => p.mls_encoded_len(),
             Proposal::ReInit(p) => p.mls_encoded_len(),
             Proposal::ExternalInit(p) => p.mls_encoded_len(),
             Proposal::GroupContextExtensions(p) => p.mls_encoded_len(),
             #[cfg(feature = "custom_proposal")]
             Proposal::Custom(p) => mls_rs_codec::byte_vec::mls_encoded_len(&p.data),
         };

         self.proposal_type().mls_encoded_len() + inner_len
     }
 }

 impl MlsEncode for Proposal {
     fn mls_encode(&self, writer: &mut Vec<u8>) -> Result<(), mls_rs_codec::Error> {
         self.proposal_type().mls_encode(writer)?;

         match self {
             Proposal::Add(p) => p.mls_encode(writer),
             #[cfg(feature = "by_ref_proposal")]
             Proposal::Update(p) => p.mls_encode(writer),
             Proposal::Remove(p) => p.mls_encode(writer),
             #[cfg(feature = "psk")]
             Proposal::Psk(p) => p.mls_encode(writer),
             Proposal::ReInit(p) => p.mls_encode(writer),
             Proposal::ExternalInit(p) => p.mls_encode(writer),
             Proposal::GroupContextExtensions(p) => p.mls_encode(writer),
             #[cfg(feature = "custom_proposal")]
             Proposal::Custom(p) => {
                 if p.proposal_type.raw_value() <= 7 {
                     // #[cfg(feature = "std")]
                     // return Err(mls_rs_codec::Error::Custom(
                     //     "custom proposal types can not be set to defined values of 0-7".to_string(),
                     // ));

                     // #[cfg(not(feature = "std"))]
                     return Err(mls_rs_codec::Error::Custom(2));
                 }
                 mls_rs_codec::byte_vec::mls_encode(&p.data, writer)
             }
         }
     }
 }

 impl MlsDecode for Proposal {
     fn mls_decode(reader: &mut &[u8]) -> Result<Self, mls_rs_codec::Error> {
         let proposal_type = ProposalType::mls_decode(reader)?;

         Ok(match proposal_type {
             ProposalType::ADD => {
                 Proposal::Add(alloc::boxed::Box::new(AddProposal::mls_decode(reader)?))
             }
             #[cfg(feature = "by_ref_proposal")]
             ProposalType::UPDATE => Proposal::Update(UpdateProposal::mls_decode(reader)?),
             ProposalType::REMOVE => Proposal::Remove(RemoveProposal::mls_decode(reader)?),
             #[cfg(feature = "psk")]
             ProposalType::PSK => Proposal::Psk(PreSharedKeyProposal::mls_decode(reader)?),
             ProposalType::RE_INIT => Proposal::ReInit(ReInitProposal::mls_decode(reader)?),
             ProposalType::EXTERNAL_INIT => {
                 Proposal::ExternalInit(ExternalInit::mls_decode(reader)?)
             }
             ProposalType::GROUP_CONTEXT_EXTENSIONS => {
                 Proposal::GroupContextExtensions(ExtensionList::mls_decode(reader)?)
             }
             #[cfg(feature = "custom_proposal")]
             custom => Proposal::Custom(CustomProposal {
                 proposal_type: custom,
                 data: mls_rs_codec::byte_vec::mls_decode(reader)?,
             }),
             // TODO fix test dependency on openssl loading codec with default features
             #[cfg(not(feature = "custom_proposal"))]
             _ => return Err(mls_rs_codec::Error::Custom(3)),
         })
     }
 }

 impl Proposal {
     pub fn proposal_type(&self) -> ProposalType {
         match self {
             Proposal::Add(_) => ProposalType::ADD,
             #[cfg(feature = "by_ref_proposal")]
             Proposal::Update(_) => ProposalType::UPDATE,
             Proposal::Remove(_) => ProposalType::REMOVE,
             #[cfg(feature = "psk")]
             Proposal::Psk(_) => ProposalType::PSK,
             Proposal::ReInit(_) => ProposalType::RE_INIT,
             Proposal::ExternalInit(_) => ProposalType::EXTERNAL_INIT,
             Proposal::GroupContextExtensions(_) => ProposalType::GROUP_CONTEXT_EXTENSIONS,
             #[cfg(feature = "custom_proposal")]
             Proposal::Custom(c) => c.proposal_type,
         }
     }
 }

 #[derive(Clone, Debug, PartialEq)]
 /// An enum that represents a borrowed version of [`Proposal`].
 pub enum BorrowedProposal<'a> {
     Add(&'a AddProposal),
     #[cfg(feature = "by_ref_proposal")]
     Update(&'a UpdateProposal),
     Remove(&'a RemoveProposal),
     #[cfg(feature = "psk")]
     Psk(&'a PreSharedKeyProposal),
     ReInit(&'a ReInitProposal),
     ExternalInit(&'a ExternalInit),
     GroupContextExtensions(&'a ExtensionList),
     #[cfg(feature = "custom_proposal")]
     Custom(&'a CustomProposal),
 }

 impl<'a> From<BorrowedProposal<'a>> for Proposal {
     fn from(value: BorrowedProposal<'a>) -> Self {
         match value {
             BorrowedProposal::Add(add) => Proposal::Add(alloc::boxed::Box::new(add.clone())),
             #[cfg(feature = "by_ref_proposal")]
             BorrowedProposal::Update(update) => Proposal::Update(update.clone()),
             BorrowedProposal::Remove(remove) => Proposal::Remove(remove.clone()),
             #[cfg(feature = "psk")]
             BorrowedProposal::Psk(psk) => Proposal::Psk(psk.clone()),
             BorrowedProposal::ReInit(reinit) => Proposal::ReInit(reinit.clone()),
             BorrowedProposal::ExternalInit(external) => Proposal::ExternalInit(external.clone()),
             BorrowedProposal::GroupContextExtensions(ext) => {
                 Proposal::GroupContextExtensions(ext.clone())
             }
             #[cfg(feature = "custom_proposal")]
             BorrowedProposal::Custom(custom) => Proposal::Custom(custom.clone()),
         }
     }
 }

 impl BorrowedProposal<'_> {
     pub fn proposal_type(&self) -> ProposalType {
         match self {
             BorrowedProposal::Add(_) => ProposalType::ADD,
             #[cfg(feature = "by_ref_proposal")]
             BorrowedProposal::Update(_) => ProposalType::UPDATE,
             BorrowedProposal::Remove(_) => ProposalType::REMOVE,
             #[cfg(feature = "psk")]
             BorrowedProposal::Psk(_) => ProposalType::PSK,
             BorrowedProposal::ReInit(_) => ProposalType::RE_INIT,
             BorrowedProposal::ExternalInit(_) => ProposalType::EXTERNAL_INIT,
             BorrowedProposal::GroupContextExtensions(_) => ProposalType::GROUP_CONTEXT_EXTENSIONS,
             #[cfg(feature = "custom_proposal")]
             BorrowedProposal::Custom(c) => c.proposal_type,
         }
     }
 }

 impl<'a> From<&'a Proposal> for BorrowedProposal<'a> {
     fn from(p: &'a Proposal) -> Self {
         match p {
             Proposal::Add(p) => BorrowedProposal::Add(p),
             #[cfg(feature = "by_ref_proposal")]
             Proposal::Update(p) => BorrowedProposal::Update(p),
             Proposal::Remove(p) => BorrowedProposal::Remove(p),
             #[cfg(feature = "psk")]
             Proposal::Psk(p) => BorrowedProposal::Psk(p),
             Proposal::ReInit(p) => BorrowedProposal::ReInit(p),
             Proposal::ExternalInit(p) => BorrowedProposal::ExternalInit(p),
             Proposal::GroupContextExtensions(p) => BorrowedProposal::GroupContextExtensions(p),
             #[cfg(feature = "custom_proposal")]
             Proposal::Custom(p) => BorrowedProposal::Custom(p),
         }
     }
 }

 impl<'a> From<&'a AddProposal> for BorrowedProposal<'a> {
     fn from(p: &'a AddProposal) -> Self {
         Self::Add(p)
     }
 }

 #[cfg(feature = "by_ref_proposal")]
 impl<'a> From<&'a UpdateProposal> for BorrowedProposal<'a> {
     fn from(p: &'a UpdateProposal) -> Self {
         Self::Update(p)
     }
 }

 impl<'a> From<&'a RemoveProposal> for BorrowedProposal<'a> {
     fn from(p: &'a RemoveProposal) -> Self {
         Self::Remove(p)
     }
 }

 #[cfg(feature = "psk")]
 impl<'a> From<&'a PreSharedKeyProposal> for BorrowedProposal<'a> {
     fn from(p: &'a PreSharedKeyProposal) -> Self {
         Self::Psk(p)
     }
 }

 impl<'a> From<&'a ReInitProposal> for BorrowedProposal<'a> {
     fn from(p: &'a ReInitProposal) -> Self {
         Self::ReInit(p)
     }
 }

 impl<'a> From<&'a ExternalInit> for BorrowedProposal<'a> {
     fn from(p: &'a ExternalInit) -> Self {
         Self::ExternalInit(p)
     }
 }

 impl<'a> From<&'a ExtensionList> for BorrowedProposal<'a> {
     fn from(p: &'a ExtensionList) -> Self {
         Self::GroupContextExtensions(p)
     }
 }

 #[cfg(feature = "custom_proposal")]
 impl<'a> From<&'a CustomProposal> for BorrowedProposal<'a> {
     fn from(p: &'a CustomProposal) -> Self {
         Self::Custom(p)
     }
 }

 #[derive(Clone, Debug, PartialEq, MlsSize, MlsEncode, MlsDecode)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(u8)]
 pub(crate) enum ProposalOrRef {
     Proposal(Box<Proposal>) = 1u8,
     #[cfg(feature = "by_ref_proposal")]
     Reference(ProposalRef) = 2u8,
 }

 impl From<Proposal> for ProposalOrRef {
     fn from(proposal: Proposal) -> Self {
         Self::Proposal(Box::new(proposal))
     }
 }

 #[cfg(feature = "by_ref_proposal")]
 impl From<ProposalRef> for ProposalOrRef {
     fn from(r: ProposalRef) -> Self {
         Self::Reference(r)
     }
 }
	// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
	// Copyright by contributors to this project.
	// SPDX-License-Identifier: (Apache-2.0 OR MIT)

	use alloc::{boxed::Box, vec::Vec};

	#[cfg(feature = "by_ref_proposal")]
	use crate::tree_kem::leaf_node::LeafNode;

	use crate::{
	client::MlsError, tree_kem::node::LeafIndex, CipherSuite, KeyPackage, MlsMessage,
	ProtocolVersion,
	};
	use core::fmt::{self, Debug};
	use mls_rs_codec::{MlsDecode, MlsEncode, MlsSize};
	use mls_rs_core::{group::Capabilities, identity::SigningIdentity};

	#[cfg(feature = "by_ref_proposal")]
	use crate::group::proposal_ref::ProposalRef;

	pub use mls_rs_core::extension::ExtensionList;
	pub use mls_rs_core::group::ProposalType;

	#[cfg(feature = "psk")]
	use crate::psk::{ExternalPskId, JustPreSharedKeyID, PreSharedKeyID};

	#[derive(Clone, Debug, PartialEq, MlsSize, MlsEncode, MlsDecode)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	/// A proposal that adds a member to a [`Group`](crate::group::Group).
	pub struct AddProposal {
	pub(crate) key_package: KeyPackage,
	}

	impl AddProposal {
	/// The [`SigningIdentity`] of the [`Member`](mls_rs_core::group::Member)
	/// that will be added by this proposal.
	pub fn signing_identity(&self) -> &SigningIdentity {
	self.key_package.signing_identity()
	}

	/// Client [`Capabilities`] of the [`Member`](mls_rs_core::group::Member)
	/// that will be added by this proposal.
	pub fn capabilities(&self) -> Capabilities {
	self.key_package.leaf_node.ungreased_capabilities()
	}

	/// Key package extensions that are assoiciated with the
	/// [`Member`](mls_rs_core::group::Member) that will be added by this proposal.
	pub fn key_package_extensions(&self) -> ExtensionList {
	self.key_package.ungreased_extensions()
	}

	/// Leaf node extensions that will be entered into the group state for the
	/// [`Member`](mls_rs_core::group::Member) that will be added.
	pub fn leaf_node_extensions(&self) -> ExtensionList {
	self.key_package.leaf_node.ungreased_extensions()
	}
	}

	impl From<KeyPackage> for AddProposal {
	fn from(key_package: KeyPackage) -> Self {
	Self { key_package }
	}
	}

	impl TryFrom<MlsMessage> for AddProposal {
	type Error = MlsError;

	fn try_from(value: MlsMessage) -> Result<Self, Self::Error> {
	value
	.into_key_package()
	.ok_or(MlsError::UnexpectedMessageType)
	.map(Into::into)
	}
	}

	#[cfg(feature = "by_ref_proposal")]
	#[derive(Clone, Debug, PartialEq, MlsSize, MlsEncode, MlsDecode)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	/// A proposal that will update an existing [`Member`](mls_rs_core::group::Member) of a
	/// [`Group`](crate::group::Group).
	pub struct UpdateProposal {
	pub(crate) leaf_node: LeafNode,
	}

	#[cfg(feature = "by_ref_proposal")]
	impl UpdateProposal {
	/// The new [`SigningIdentity`] of the [`Member`](mls_rs_core::group::Member)
	/// that is being updated by this proposal.
	pub fn signing_identity(&self) -> &SigningIdentity {
	&self.leaf_node.signing_identity
	}

	/// New Client [`Capabilities`] of the [`Member`](mls_rs_core::group::Member)
	/// that will be updated by this proposal.
	pub fn capabilities(&self) -> Capabilities {
	self.leaf_node.ungreased_capabilities()
	}

	/// New Leaf node extensions that will be entered into the group state for the
	/// [`Member`](mls_rs_core::group::Member) that is being updated by this proposal.
	pub fn leaf_node_extensions(&self) -> ExtensionList {
	self.leaf_node.ungreased_extensions()
	}
	}

	#[derive(Clone, Debug, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	/// A proposal to remove an existing [`Member`](mls_rs_core::group::Member) of a
	/// [`Group`](crate::group::Group).
	pub struct RemoveProposal {
	pub(crate) to_remove: LeafIndex,
	}

	impl RemoveProposal {
	/// The index of the [`Member`](mls_rs_core::group::Member) that will be removed by
	/// this proposal.
	pub fn to_remove(&self) -> u32 {
	*self.to_remove
	}
	}

	impl From<u32> for RemoveProposal {
	fn from(value: u32) -> Self {
	RemoveProposal {
	to_remove: LeafIndex(value),
	}
	}
	}

	#[cfg(feature = "psk")]
	#[derive(Clone, Debug, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	/// A proposal to add a pre-shared key to a group.
	pub struct PreSharedKeyProposal {
	pub(crate) psk: PreSharedKeyID,
	}

	#[cfg(feature = "psk")]
	impl PreSharedKeyProposal {
	/// The external pre-shared key id of this proposal.
	///
	/// MLS requires the pre-shared key type for PreSharedKeyProposal to be of
	/// type `External`.
	///
	/// Returns `None` in the condition that the underlying psk is not external.
	pub fn external_psk_id(&self) -> Option<&ExternalPskId> {
	match self.psk.key_id {
	JustPreSharedKeyID::External(ref ext) => Some(ext),
	JustPreSharedKeyID::Resumption(_) => None,
	}
	}
	}

	#[derive(Clone, PartialEq, MlsSize, MlsEncode, MlsDecode)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	/// A proposal to reinitialize a group using new parameters.
	pub struct ReInitProposal {
	#[mls_codec(with = "mls_rs_codec::byte_vec")]
	#[cfg_attr(feature = "serde", serde(with = "mls_rs_core::vec_serde"))]
	pub(crate) group_id: Vec<u8>,
	pub(crate) version: ProtocolVersion,
	pub(crate) cipher_suite: CipherSuite,
	pub(crate) extensions: ExtensionList,
	}

	impl Debug for ReInitProposal {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.debug_struct("ReInitProposal")
	.field(
	"group_id",
	&mls_rs_core::debug::pretty_group_id(&self.group_id),
	)
	.field("version", &self.version)
	.field("cipher_suite", &self.cipher_suite)
	.field("extensions", &self.extensions)
	.finish()
	}
	}

	impl ReInitProposal {
	/// The unique id of the new group post reinitialization.
	pub fn group_id(&self) -> &[u8] {
	&self.group_id
	}

	/// The new protocol version to use post reinitialization.
	pub fn new_version(&self) -> ProtocolVersion {
	self.version
	}

	/// The new ciphersuite to use post reinitialization.
	pub fn new_cipher_suite(&self) -> CipherSuite {
	self.cipher_suite
	}

	/// Group context extensions to set in the new group post reinitialization.
	pub fn new_group_context_extensions(&self) -> &ExtensionList {
	&self.extensions
	}
	}

	#[derive(Clone, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	/// A proposal used for external commits.
	pub struct ExternalInit {
	#[mls_codec(with = "mls_rs_codec::byte_vec")]
	#[cfg_attr(feature = "serde", serde(with = "mls_rs_core::vec_serde"))]
	pub(crate) kem_output: Vec<u8>,
	}

	impl Debug for ExternalInit {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.debug_struct("ExternalInit")
	.field(
	"kem_output",
	&mls_rs_core::debug::pretty_bytes(&self.kem_output),
	)
	.finish()
	}
	}

	#[cfg(feature = "custom_proposal")]
	#[derive(Clone, PartialEq, Eq)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(
	all(feature = "ffi", not(test)),
	safer_ffi_gen::ffi_type(clone, opaque)
	)]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	/// A user defined custom proposal.
	///
	/// User defined proposals are passed through the protocol as an opaque value.
	pub struct CustomProposal {
	proposal_type: ProposalType,
	#[cfg_attr(feature = "serde", serde(with = "mls_rs_core::vec_serde"))]
	data: Vec<u8>,
	}

	#[cfg(feature = "custom_proposal")]
	impl Debug for CustomProposal {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.debug_struct("CustomProposal")
	.field("proposal_type", &self.proposal_type)
	.field("data", &mls_rs_core::debug::pretty_bytes(&self.data))
	.finish()
	}
	}

	#[cfg(feature = "custom_proposal")]
	#[cfg_attr(all(feature = "ffi", not(test)), safer_ffi_gen::safer_ffi_gen)]
	impl CustomProposal {
	/// Create a custom proposal.
	///
	/// # Warning
	///
	/// Avoid using the [`ProposalType`] values that have constants already
	/// defined by this crate. Using existing constants in a custom proposal
	/// has unspecified behavior.
	pub fn new(proposal_type: ProposalType, data: Vec<u8>) -> Self {
	Self {
	proposal_type,
	data,
	}
	}

	/// The proposal type used for this custom proposal.
	pub fn proposal_type(&self) -> ProposalType {
	self.proposal_type
	}

	/// The opaque data communicated by this custom proposal.
	pub fn data(&self) -> &[u8] {
	&self.data
	}
	}

	/// Trait to simplify creating custom proposals that are serialized with MLS
	/// encoding.
	#[cfg(feature = "custom_proposal")]
	pub trait MlsCustomProposal: MlsSize + MlsEncode + MlsDecode + Sized {
	fn proposal_type() -> ProposalType;

	fn to_custom_proposal(&self) -> Result<CustomProposal, mls_rs_codec::Error> {
	Ok(CustomProposal::new(
	Self::proposal_type(),
	self.mls_encode_to_vec()?,
	))
	}

	fn from_custom_proposal(proposal: &CustomProposal) -> Result<Self, mls_rs_codec::Error> {
	if proposal.proposal_type() != Self::proposal_type() {
	// #[cfg(feature = "std")]
	// return Err(mls_rs_codec::Error::Custom(
	// "invalid proposal type".to_string(),
	// ));

	//#[cfg(not(feature = "std"))]
	return Err(mls_rs_codec::Error::Custom(4));
	}

	Self::mls_decode(&mut proposal.data())
	}
	}

	#[allow(clippy::large_enum_variant)]
	#[derive(Clone, Debug, PartialEq)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	#[repr(u16)]
	#[non_exhaustive]
	/// An enum that represents all possible types of proposals.
	pub enum Proposal {
	Add(alloc::boxed::Box<AddProposal>),
	#[cfg(feature = "by_ref_proposal")]
	Update(UpdateProposal),
	Remove(RemoveProposal),
	#[cfg(feature = "psk")]
	Psk(PreSharedKeyProposal),
	ReInit(ReInitProposal),
	ExternalInit(ExternalInit),
	GroupContextExtensions(ExtensionList),
	#[cfg(feature = "custom_proposal")]
	Custom(CustomProposal),
	}

	impl MlsSize for Proposal {
	fn mls_encoded_len(&self) -> usize {
	let inner_len = match self {
	Proposal::Add(p) => p.mls_encoded_len(),
	#[cfg(feature = "by_ref_proposal")]
	Proposal::Update(p) => p.mls_encoded_len(),
	Proposal::Remove(p) => p.mls_encoded_len(),
	#[cfg(feature = "psk")]
	Proposal::Psk(p) => p.mls_encoded_len(),
	Proposal::ReInit(p) => p.mls_encoded_len(),
	Proposal::ExternalInit(p) => p.mls_encoded_len(),
	Proposal::GroupContextExtensions(p) => p.mls_encoded_len(),
	#[cfg(feature = "custom_proposal")]
	Proposal::Custom(p) => mls_rs_codec::byte_vec::mls_encoded_len(&p.data),
	};

	self.proposal_type().mls_encoded_len() + inner_len
	}
	}

	impl MlsEncode for Proposal {
	fn mls_encode(&self, writer: &mut Vec<u8>) -> Result<(), mls_rs_codec::Error> {
	self.proposal_type().mls_encode(writer)?;

	match self {
	Proposal::Add(p) => p.mls_encode(writer),
	#[cfg(feature = "by_ref_proposal")]
	Proposal::Update(p) => p.mls_encode(writer),
	Proposal::Remove(p) => p.mls_encode(writer),
	#[cfg(feature = "psk")]
	Proposal::Psk(p) => p.mls_encode(writer),
	Proposal::ReInit(p) => p.mls_encode(writer),
	Proposal::ExternalInit(p) => p.mls_encode(writer),
	Proposal::GroupContextExtensions(p) => p.mls_encode(writer),
	#[cfg(feature = "custom_proposal")]
	Proposal::Custom(p) => {
	if p.proposal_type.raw_value() <= 7 {
	// #[cfg(feature = "std")]
	// return Err(mls_rs_codec::Error::Custom(
	// "custom proposal types can not be set to defined values of 0-7".to_string(),
	// ));

	// #[cfg(not(feature = "std"))]
	return Err(mls_rs_codec::Error::Custom(2));
	}
	mls_rs_codec::byte_vec::mls_encode(&p.data, writer)
	}
	}
	}
	}

	impl MlsDecode for Proposal {
	fn mls_decode(reader: &mut &[u8]) -> Result<Self, mls_rs_codec::Error> {
	let proposal_type = ProposalType::mls_decode(reader)?;

	Ok(match proposal_type {
	ProposalType::ADD => {
	Proposal::Add(alloc::boxed::Box::new(AddProposal::mls_decode(reader)?))
	}
	#[cfg(feature = "by_ref_proposal")]
	ProposalType::UPDATE => Proposal::Update(UpdateProposal::mls_decode(reader)?),
	ProposalType::REMOVE => Proposal::Remove(RemoveProposal::mls_decode(reader)?),
	#[cfg(feature = "psk")]
	ProposalType::PSK => Proposal::Psk(PreSharedKeyProposal::mls_decode(reader)?),
	ProposalType::RE_INIT => Proposal::ReInit(ReInitProposal::mls_decode(reader)?),
	ProposalType::EXTERNAL_INIT => {
	Proposal::ExternalInit(ExternalInit::mls_decode(reader)?)
	}
	ProposalType::GROUP_CONTEXT_EXTENSIONS => {
	Proposal::GroupContextExtensions(ExtensionList::mls_decode(reader)?)
	}
	#[cfg(feature = "custom_proposal")]
	custom => Proposal::Custom(CustomProposal {
	proposal_type: custom,
	data: mls_rs_codec::byte_vec::mls_decode(reader)?,
	}),
	// TODO fix test dependency on openssl loading codec with default features
	#[cfg(not(feature = "custom_proposal"))]
	_ => return Err(mls_rs_codec::Error::Custom(3)),
	})
	}
	}

	impl Proposal {
	pub fn proposal_type(&self) -> ProposalType {
	match self {
	Proposal::Add(_) => ProposalType::ADD,
	#[cfg(feature = "by_ref_proposal")]
	Proposal::Update(_) => ProposalType::UPDATE,
	Proposal::Remove(_) => ProposalType::REMOVE,
	#[cfg(feature = "psk")]
	Proposal::Psk(_) => ProposalType::PSK,
	Proposal::ReInit(_) => ProposalType::RE_INIT,
	Proposal::ExternalInit(_) => ProposalType::EXTERNAL_INIT,
	Proposal::GroupContextExtensions(_) => ProposalType::GROUP_CONTEXT_EXTENSIONS,
	#[cfg(feature = "custom_proposal")]
	Proposal::Custom(c) => c.proposal_type,
	}
	}
	}

	#[derive(Clone, Debug, PartialEq)]
	/// An enum that represents a borrowed version of [`Proposal`].
	pub enum BorrowedProposal<'a> {
	Add(&'a AddProposal),
	#[cfg(feature = "by_ref_proposal")]
	Update(&'a UpdateProposal),
	Remove(&'a RemoveProposal),
	#[cfg(feature = "psk")]
	Psk(&'a PreSharedKeyProposal),
	ReInit(&'a ReInitProposal),
	ExternalInit(&'a ExternalInit),
	GroupContextExtensions(&'a ExtensionList),
	#[cfg(feature = "custom_proposal")]
	Custom(&'a CustomProposal),
	}

	impl<'a> From<BorrowedProposal<'a>> for Proposal {
	fn from(value: BorrowedProposal<'a>) -> Self {
	match value {
	BorrowedProposal::Add(add) => Proposal::Add(alloc::boxed::Box::new(add.clone())),
	#[cfg(feature = "by_ref_proposal")]
	BorrowedProposal::Update(update) => Proposal::Update(update.clone()),
	BorrowedProposal::Remove(remove) => Proposal::Remove(remove.clone()),
	#[cfg(feature = "psk")]
	BorrowedProposal::Psk(psk) => Proposal::Psk(psk.clone()),
	BorrowedProposal::ReInit(reinit) => Proposal::ReInit(reinit.clone()),
	BorrowedProposal::ExternalInit(external) => Proposal::ExternalInit(external.clone()),
	BorrowedProposal::GroupContextExtensions(ext) => {
	Proposal::GroupContextExtensions(ext.clone())
	}
	#[cfg(feature = "custom_proposal")]
	BorrowedProposal::Custom(custom) => Proposal::Custom(custom.clone()),
	}
	}
	}

	impl BorrowedProposal<'_> {
	pub fn proposal_type(&self) -> ProposalType {
	match self {
	BorrowedProposal::Add(_) => ProposalType::ADD,
	#[cfg(feature = "by_ref_proposal")]
	BorrowedProposal::Update(_) => ProposalType::UPDATE,
	BorrowedProposal::Remove(_) => ProposalType::REMOVE,
	#[cfg(feature = "psk")]
	BorrowedProposal::Psk(_) => ProposalType::PSK,
	BorrowedProposal::ReInit(_) => ProposalType::RE_INIT,
	BorrowedProposal::ExternalInit(_) => ProposalType::EXTERNAL_INIT,
	BorrowedProposal::GroupContextExtensions(_) => ProposalType::GROUP_CONTEXT_EXTENSIONS,
	#[cfg(feature = "custom_proposal")]
	BorrowedProposal::Custom(c) => c.proposal_type,
	}
	}
	}

	impl<'a> From<&'a Proposal> for BorrowedProposal<'a> {
	fn from(p: &'a Proposal) -> Self {
	match p {
	Proposal::Add(p) => BorrowedProposal::Add(p),
	#[cfg(feature = "by_ref_proposal")]
	Proposal::Update(p) => BorrowedProposal::Update(p),
	Proposal::Remove(p) => BorrowedProposal::Remove(p),
	#[cfg(feature = "psk")]
	Proposal::Psk(p) => BorrowedProposal::Psk(p),
	Proposal::ReInit(p) => BorrowedProposal::ReInit(p),
	Proposal::ExternalInit(p) => BorrowedProposal::ExternalInit(p),
	Proposal::GroupContextExtensions(p) => BorrowedProposal::GroupContextExtensions(p),
	#[cfg(feature = "custom_proposal")]
	Proposal::Custom(p) => BorrowedProposal::Custom(p),
	}
	}
	}

	impl<'a> From<&'a AddProposal> for BorrowedProposal<'a> {
	fn from(p: &'a AddProposal) -> Self {
	Self::Add(p)
	}
	}

	#[cfg(feature = "by_ref_proposal")]
	impl<'a> From<&'a UpdateProposal> for BorrowedProposal<'a> {
	fn from(p: &'a UpdateProposal) -> Self {
	Self::Update(p)
	}
	}

	impl<'a> From<&'a RemoveProposal> for BorrowedProposal<'a> {
	fn from(p: &'a RemoveProposal) -> Self {
	Self::Remove(p)
	}
	}

	#[cfg(feature = "psk")]
	impl<'a> From<&'a PreSharedKeyProposal> for BorrowedProposal<'a> {
	fn from(p: &'a PreSharedKeyProposal) -> Self {
	Self::Psk(p)
	}
	}

	impl<'a> From<&'a ReInitProposal> for BorrowedProposal<'a> {
	fn from(p: &'a ReInitProposal) -> Self {
	Self::ReInit(p)
	}
	}

	impl<'a> From<&'a ExternalInit> for BorrowedProposal<'a> {
	fn from(p: &'a ExternalInit) -> Self {
	Self::ExternalInit(p)
	}
	}

	impl<'a> From<&'a ExtensionList> for BorrowedProposal<'a> {
	fn from(p: &'a ExtensionList) -> Self {
	Self::GroupContextExtensions(p)
	}
	}

	#[cfg(feature = "custom_proposal")]
	impl<'a> From<&'a CustomProposal> for BorrowedProposal<'a> {
	fn from(p: &'a CustomProposal) -> Self {
	Self::Custom(p)
	}
	}

	#[derive(Clone, Debug, PartialEq, MlsSize, MlsEncode, MlsDecode)]
	#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	#[repr(u8)]
	pub(crate) enum ProposalOrRef {
	Proposal(Box<Proposal>) = 1u8,
	#[cfg(feature = "by_ref_proposal")]
	Reference(ProposalRef) = 2u8,
	}

	impl From<Proposal> for ProposalOrRef {
	fn from(proposal: Proposal) -> Self {
	Self::Proposal(Box::new(proposal))
	}
	}

	#[cfg(feature = "by_ref_proposal")]
	impl From<ProposalRef> for ProposalOrRef {
	fn from(r: ProposalRef) -> Self {
	Self::Reference(r)
	}
	}