feat(platform): group action proofs

packages/rs-dpp/src/data_contract/group/v0/mod.rs

@@ -88,7 +88,7 @@ impl GroupMethodsV0 for GroupV0 {
         &self,
         platform_version: &PlatformVersion,
     ) -> Result<SimpleConsensusValidationResult, ProtocolError> {
-        let max_group_members = platform_version.system_limits.max_contract_group_size;
+        let max_group_members = platform_version.system_limits.max_contract_group_size as u32;
         const GROUP_POWER_LIMIT: GroupMemberPower = u16::MAX as GroupMemberPower;
 
         // Check the number of members does not exceed the maximum allowed

packages/rs-dpp/src/group/group_action/mod.rs

@@ -1,9 +1,12 @@
 pub mod v0;
 
+use crate::data_contract::TokenContractPosition;
+use crate::group::action_event::GroupActionEvent;
 use crate::group::group_action::v0::GroupActionV0;
 use crate::ProtocolError;
 use bincode::{Decode, Encode};
 use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
+use platform_value::Identifier;
 
 #[derive(
     Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize,
@@ -12,3 +15,28 @@ use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
 pub enum GroupAction {
     V0(GroupActionV0),
 }
+
+pub trait GroupActionAccessors {
+    fn contract_id(&self) -> Identifier;
+    fn token_contract_position(&self) -> TokenContractPosition;
+    fn event(&self) -> &GroupActionEvent;
+}
+impl GroupActionAccessors for GroupAction {
+    fn contract_id(&self) -> Identifier {
+        match self {
+            GroupAction::V0(inner) => inner.contract_id(),
+        }
+    }
+
+    fn token_contract_position(&self) -> TokenContractPosition {
+        match self {
+            GroupAction::V0(inner) => inner.token_contract_position(),
+        }
+    }
+
+    fn event(&self) -> &GroupActionEvent {
+        match self {
+            GroupAction::V0(inner) => inner.event(),
+        }
+    }
+}

packages/rs-dpp/src/group/group_action/v0/mod.rs

@@ -1,12 +1,31 @@
+use crate::data_contract::TokenContractPosition;
 use crate::group::action_event::GroupActionEvent;
+use crate::group::group_action::GroupActionAccessors;
 use crate::ProtocolError;
 use bincode::{Decode, Encode};
 use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
+use platform_value::Identifier;
 
 #[derive(
     Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize,
 )]
 #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version
 pub struct GroupActionV0 {
+    pub contract_id: Identifier,
+    pub token_contract_position: TokenContractPosition,
     pub event: GroupActionEvent,
 }
+
+impl GroupActionAccessors for GroupActionV0 {
+    fn contract_id(&self) -> Identifier {
+        self.contract_id
+    }
+
+    fn token_contract_position(&self) -> TokenContractPosition {
+        self.token_contract_position
+    }
+
+    fn event(&self) -> &GroupActionEvent {
+        &self.event
+    }
+}

packages/rs-dpp/src/group/group_action_status.rs

@@ -1,6 +1,6 @@
 use anyhow::bail;
 
-#[derive(Debug, PartialEq, PartialOrd, Clone, Eq)]
+#[derive(Debug, PartialEq, PartialOrd, Clone, Copy, Eq)]
 pub enum GroupActionStatus {
     ActionActive,
     ActionClosed,

packages/rs-dpp/src/state_transition/proof_result.rs

@@ -1,6 +1,8 @@
 use crate::balances::credits::TokenAmount;
+use crate::data_contract::group::GroupSumPower;
 use crate::data_contract::DataContract;
 use crate::document::Document;
+use crate::group::group_action_status::GroupActionStatus;
 use crate::identity::{Identity, PartialIdentity};
 use crate::tokens::info::IdentityTokenInfo;
 use crate::tokens::status::TokenStatus;
@@ -23,6 +25,18 @@ pub enum StateTransitionProofResult {
     VerifiedBalanceTransfer(PartialIdentity, PartialIdentity), //from/to
     VerifiedDocuments(BTreeMap<Identifier, Option<Document>>),
     VerifiedTokenActionWithDocument(Document),
+    VerifiedTokenGroupActionWithDocument(GroupSumPower, Option<Document>),
+    VerifiedTokenGroupActionWithTokenBalance(GroupSumPower, GroupActionStatus, Option<TokenAmount>),
+    VerifiedTokenGroupActionWithTokenIdentityInfo(
+        GroupSumPower,
+        GroupActionStatus,
+        Option<IdentityTokenInfo>,
+    ),
+    VerifiedTokenGroupActionWithTokenPricingSchedule(
+        GroupSumPower,
+        GroupActionStatus,
+        Option<TokenPricingSchedule>,
+    ),
     VerifiedMasternodeVote(Vote),
     VerifiedNextDistribution(Vote),
 }

packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs

@@ -88,13 +88,16 @@ impl<C> Platform<C> {
         // Add burn token group action
         let action_id = Identifier::new([32; 32]);
         let group_action = GroupAction::V0(GroupActionV0 {
+            contract_id: DATA_CONTRACT_ID,
+            token_contract_position: 2,
             event: GroupActionEvent::TokenEvent(TokenEvent::Burn(10, Some("world on fire".into()))),
         });
 
         self.drive.add_group_action(
             DATA_CONTRACT_ID,
             2,
             Some(group_action),
+            false,
             action_id,
             IDENTITY_ID_1,
             1,