feat(context): introduce GroupRequest and ContextGroupId types for group management

crates/context/config/src/lib.rs

@@ -12,8 +12,8 @@ pub mod types;
 
 use repr::Repr;
 use types::{
-    Application, BlockHeight, Capability, ContextId, ContextIdentity, ProposalId,
-    SignedRevealPayload, SignerId,
+    AppKey, Application, BlockHeight, Capability, ContextGroupId, ContextId, ContextIdentity,
+    ProposalId, SignedRevealPayload, SignerId,
 };
 
 pub type Timestamp = u64;
@@ -47,6 +47,8 @@ impl<'a> Request<'a> {
 pub enum RequestKind<'a> {
     #[serde(borrow)]
     Context(ContextRequest<'a>),
+    #[serde(borrow)]
+    Group(GroupRequest<'a>),
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -103,6 +105,58 @@ pub enum ContextRequestKind<'a> {
     UpdateProxyContract,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
+#[non_exhaustive]
+pub struct GroupRequest<'a> {
+    pub group_id: Repr<ContextGroupId>,
+
+    #[serde(borrow, flatten)]
+    pub kind: GroupRequestKind<'a>,
+}
+
+impl<'a> GroupRequest<'a> {
+    #[must_use]
+    pub const fn new(group_id: Repr<ContextGroupId>, kind: GroupRequestKind<'a>) -> Self {
+        GroupRequest { group_id, kind }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "scope", content = "params")]
+#[serde(deny_unknown_fields)]
+#[expect(clippy::exhaustive_enums, reason = "Considered to be exhaustive")]
+pub enum GroupRequestKind<'a> {
+    Create {
+        app_key: Repr<AppKey>,
+        #[serde(borrow)]
+        target_application: Application<'a>,
+    },
+    Delete,
+    AddMembers {
+        members: Cow<'a, [Repr<SignerId>]>,
+    },
+    RemoveMembers {
+        members: Cow<'a, [Repr<SignerId>]>,
+    },
+    RegisterContext {
+        context_id: Repr<ContextId>,
+    },
+    UnregisterContext {
+        context_id: Repr<ContextId>,
+    },
+    SetTargetApplication {
+        #[serde(borrow)]
+        target_application: Application<'a>,
+    },
+    /// Pre-approve a specific context to register via its proxy contract.
+    /// Must be called by a group admin before the proxy path is exercised.
+    ApproveContextRegistration {
+        context_id: Repr<ContextId>,
+    },
+}
+
 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 #[serde(tag = "scope", content = "params")]
 #[serde(deny_unknown_fields)]
@@ -156,6 +210,12 @@ pub enum ProposalAction {
     DeleteProposal {
         proposal_id: Repr<ProposalId>,
     },
+    RegisterInGroup {
+        group_id: Repr<ContextGroupId>,
+    },
+    UnregisterFromGroup {
+        group_id: Repr<ContextGroupId>,
+    },
 }
 
 // The proposal the user makes specifying the receiving account and actions they want to execute (1 tx)

crates/context/config/src/types.rs

@@ -226,6 +226,98 @@ impl From<[u8; 32]> for ContextIdentity {
     }
 }
 
+#[derive(
+    Eq,
+    Ord,
+    Copy,
+    Debug,
+    Deserialize,
+    Clone,
+    PartialEq,
+    PartialOrd,
+    BorshSerialize,
+    BorshDeserialize,
+    Serialize,
+    Hash,
+)]
+pub struct ContextGroupId(Identity);
+
+impl ContextGroupId {
+    pub fn to_bytes(&self) -> [u8; 32] {
+        self.0.to_bytes()
+    }
+}
+
+impl ReprBytes for ContextGroupId {
+    type EncodeBytes<'a> = [u8; 32];
+    type DecodeBytes = [u8; 32];
+
+    type Error = LengthMismatch;
+
+    fn as_bytes(&self) -> Self::EncodeBytes<'_> {
+        self.0.as_bytes()
+    }
+
+    fn from_bytes<F>(f: F) -> repr::Result<Self, Self::Error>
+    where
+        F: FnOnce(&mut Self::DecodeBytes) -> Bs58Result<usize>,
+    {
+        ReprBytes::from_bytes(f).map(Self)
+    }
+}
+
+impl From<[u8; 32]> for ContextGroupId {
+    fn from(value: [u8; 32]) -> Self {
+        Self(Identity(value))
+    }
+}
+
+#[derive(
+    Eq,
+    Ord,
+    Copy,
+    Debug,
+    Deserialize,
+    Clone,
+    PartialEq,
+    PartialOrd,
+    BorshSerialize,
+    BorshDeserialize,
+    Serialize,
+    Hash,
+)]
+pub struct AppKey(Identity);
+
+impl AppKey {
+    pub fn to_bytes(&self) -> [u8; 32] {
+        self.0.to_bytes()
+    }
+}
+
+impl ReprBytes for AppKey {
+    type EncodeBytes<'a> = [u8; 32];
+    type DecodeBytes = [u8; 32];
+
+    type Error = LengthMismatch;
+
+    fn as_bytes(&self) -> Self::EncodeBytes<'_> {
+        self.0.as_bytes()
+    }
+
+    fn from_bytes<F>(f: F) -> repr::Result<Self, Self::Error>
+    where
+        F: FnOnce(&mut Self::DecodeBytes) -> Bs58Result<usize>,
+    {
+        ReprBytes::from_bytes(f).map(Self)
+    }
+}
+
+impl From<[u8; 32]> for AppKey {
+    fn from(value: [u8; 32]) -> Self {
+        Self(Identity(value))
+    }
+}
+
 #[derive(Eq, Ord, Copy, Debug, Clone, PartialEq, PartialOrd, BorshSerialize, BorshDeserialize)]
 pub struct BlobId(Identity);