feat(platform)!: improved token validation and token config update transition

packages/dapi-grpc/protos/platform/v0/platform.proto

@@ -1622,6 +1622,12 @@ message GetGroupActionsResponse {
       optional string public_note = 2; // Public note
     }
 
+    // Token config update event
+    message TokenConfigUpdateEvent {
+      bytes token_config_update_item = 1; // Token config update item
+      optional string public_note = 2; // Public note
+    }
+
     // Event associated with this action
     message GroupActionEvent {
       oneof event_type {
@@ -1661,6 +1667,7 @@ message GetGroupActionsResponse {
         DestroyFrozenFundsEvent destroy_frozen_funds = 5; // Destroy frozen funds
         TransferEvent transfer = 6;     // Transfer event details
         EmergencyActionEvent emergency_action = 7; // Emergency action details
+        TokenConfigUpdateEvent  token_config_update = 8; // Token configuration update details
       }
     }
 

packages/rs-dpp/src/data_contract/associated_token/mod.rs

@@ -1 +1,3 @@
 pub mod token_configuration;
+pub mod token_configuration_convention;
+pub mod token_configuration_item;

packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/mod.rs

@@ -1,33 +1,41 @@
 pub mod v0;
 
+use crate::balances::credits::TokenAmount;
 use crate::data_contract::associated_token::token_configuration::accessors::v0::{
     TokenConfigurationV0Getters, TokenConfigurationV0Setters,
 };
-use crate::data_contract::associated_token::token_configuration::v0::TokenConfigurationConventionV0;
 use crate::data_contract::associated_token::token_configuration::TokenConfiguration;
+use crate::data_contract::associated_token::token_configuration_convention::TokenConfigurationConvention;
 use crate::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers;
 use crate::data_contract::change_control_rules::ChangeControlRules;
 use crate::data_contract::GroupContractPosition;
 use platform_value::Identifier;
+use std::collections::BTreeSet;
 
 /// Implementing TokenConfigurationV0Getters for TokenConfiguration
 impl TokenConfigurationV0Getters for TokenConfiguration {
     /// Returns a reference to the conventions.
-    fn conventions(&self) -> &TokenConfigurationConventionV0 {
+    fn conventions(&self) -> &TokenConfigurationConvention {
         match self {
             TokenConfiguration::V0(v0) => v0.conventions(),
         }
     }
 
     /// Returns a mutable reference to the conventions.
-    fn conventions_mut(&mut self) -> &mut TokenConfigurationConventionV0 {
+    fn conventions_mut(&mut self) -> &mut TokenConfigurationConvention {
         match self {
             TokenConfiguration::V0(v0) => v0.conventions_mut(),
         }
     }
 
+    fn conventions_change_rules(&self) -> &ChangeControlRules {
+        match self {
+            TokenConfiguration::V0(v0) => v0.conventions_change_rules(),
+        }
+    }
+
     /// Returns the base supply.
-    fn base_supply(&self) -> u64 {
+    fn base_supply(&self) -> TokenAmount {
         match self {
             TokenConfiguration::V0(v0) => v0.base_supply(),
         }
@@ -141,17 +149,31 @@ impl TokenConfigurationV0Getters for TokenConfiguration {
             TokenConfiguration::V0(v0) => v0.main_control_group_can_be_modified(),
         }
     }
+
+    /// Returns all group positions used in the token configuration
+    fn all_used_group_positions(&self) -> BTreeSet<GroupContractPosition> {
+        match self {
+            TokenConfiguration::V0(v0) => v0.all_used_group_positions(),
+        }
+    }
 }
 
 /// Implementing TokenConfigurationV0Setters for TokenConfiguration
 impl TokenConfigurationV0Setters for TokenConfiguration {
     /// Sets the conventions.
-    fn set_conventions(&mut self, conventions: TokenConfigurationConventionV0) {
+    fn set_conventions(&mut self, conventions: TokenConfigurationConvention) {
         match self {
             TokenConfiguration::V0(v0) => v0.set_conventions(conventions),
         }
     }
 
+    /// Sets the conventions change rules.
+    fn set_conventions_change_rules(&mut self, rules: ChangeControlRules) {
+        match self {
+            TokenConfiguration::V0(v0) => v0.set_conventions_change_rules(rules),
+        }
+    }
+
     /// Sets the base supply.
     fn set_base_supply(&mut self, base_supply: u64) {
         match self {

packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/v0/mod.rs

@@ -1,17 +1,20 @@
 use crate::balances::credits::TokenAmount;
-use crate::data_contract::associated_token::token_configuration::v0::TokenConfigurationConventionV0;
+use crate::data_contract::associated_token::token_configuration_convention::TokenConfigurationConvention;
 use crate::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers;
 use crate::data_contract::change_control_rules::ChangeControlRules;
 use crate::data_contract::GroupContractPosition;
 use platform_value::Identifier;
+use std::collections::BTreeSet;
 
 /// Accessor trait for getters of `TokenConfigurationV0`
 pub trait TokenConfigurationV0Getters {
     /// Returns a reference to the conventions.
-    fn conventions(&self) -> &TokenConfigurationConventionV0;
+    fn conventions(&self) -> &TokenConfigurationConvention;
 
     /// Returns a mutable reference to the conventions.
-    fn conventions_mut(&mut self) -> &mut TokenConfigurationConventionV0;
+    fn conventions_mut(&mut self) -> &mut TokenConfigurationConvention;
+    /// Returns the new tokens destination identity rules.
+    fn conventions_change_rules(&self) -> &ChangeControlRules;
 
     /// Returns the base supply.
     fn base_supply(&self) -> TokenAmount;
@@ -56,12 +59,18 @@ pub trait TokenConfigurationV0Getters {
 
     /// Returns the main control group can be modified.
     fn main_control_group_can_be_modified(&self) -> &AuthorizedActionTakers;
+
+    /// Returns all group positions used in the token configuration
+    fn all_used_group_positions(&self) -> BTreeSet<GroupContractPosition>;
 }
 
 /// Accessor trait for setters of `TokenConfigurationV0`
 pub trait TokenConfigurationV0Setters {
     /// Sets the conventions.
-    fn set_conventions(&mut self, conventions: TokenConfigurationConventionV0);
+    fn set_conventions(&mut self, conventions: TokenConfigurationConvention);
+
+    /// Sets the conventions change rules.
+    fn set_conventions_change_rules(&mut self, rules: ChangeControlRules);
 
     /// Sets the base supply.
     fn set_base_supply(&mut self, base_supply: TokenAmount);

packages/rs-dpp/src/data_contract/associated_token/token_configuration/methods/apply_token_configuration_item/mod.rs

@@ -0,0 +1,18 @@
+use crate::data_contract::associated_token::token_configuration::TokenConfiguration;
+use crate::data_contract::associated_token::token_configuration_item::TokenConfigurationChangeItem;
+
+mod v0;
+
+impl TokenConfiguration {
+    /// Applies a `TokenConfigurationChangeItem` to this token configuration.
+    ///
+    /// # Parameters
+    /// - `change_item`: The change item to be applied.
+    ///
+    /// This method modifies the current `TokenConfigurationV0` instance in place.
+    pub fn apply_token_configuration_item(&mut self, change_item: TokenConfigurationChangeItem) {
+        match self {
+            TokenConfiguration::V0(v0) => v0.apply_token_configuration_item(change_item),
+        }
+    }
+}

packages/rs-dpp/src/data_contract/associated_token/token_configuration/methods/apply_token_configuration_item/v0/mod.rs

@@ -0,0 +1,116 @@
+use crate::data_contract::associated_token::token_configuration::v0::TokenConfigurationV0;
+use crate::data_contract::associated_token::token_configuration_item::TokenConfigurationChangeItem;
+impl TokenConfigurationV0 {
+    /// Applies a `TokenConfigurationChangeItem` to this token configuration.
+    ///
+    /// # Parameters
+    /// - `change_item`: The change item to be applied.
+    ///
+    /// This method modifies the current `TokenConfigurationV0` instance in place.
+    pub fn apply_token_configuration_item(&mut self, change_item: TokenConfigurationChangeItem) {
+        match change_item {
+            TokenConfigurationChangeItem::TokenConfigurationNoChange => {
+                // No changes are made
+            }
+            TokenConfigurationChangeItem::Conventions(conventions) => {
+                self.conventions = conventions;
+            }
+            TokenConfigurationChangeItem::ConventionsControlGroup(control_group) => {
+                self.conventions_change_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::ConventionsAdminGroup(admin_group) => {
+                self.conventions_change_rules
+                    .set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::MaxSupply(max_supply) => {
+                self.max_supply = max_supply;
+            }
+            TokenConfigurationChangeItem::MaxSupplyControlGroup(control_group) => {
+                self.max_supply_change_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::MaxSupplyAdminGroup(admin_group) => {
+                self.max_supply_change_rules
+                    .set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::NewTokensDestinationIdentity(identity) => {
+                self.new_tokens_destination_identity = identity;
+            }
+            TokenConfigurationChangeItem::NewTokensDestinationIdentityControlGroup(
+                control_group,
+            ) => {
+                self.new_tokens_destination_identity_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::NewTokensDestinationIdentityAdminGroup(admin_group) => {
+                self.new_tokens_destination_identity_rules
+                    .set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::MintingAllowChoosingDestination(allow) => {
+                self.minting_allow_choosing_destination = allow;
+            }
+            TokenConfigurationChangeItem::MintingAllowChoosingDestinationControlGroup(
+                control_group,
+            ) => {
+                self.minting_allow_choosing_destination_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::MintingAllowChoosingDestinationAdminGroup(
+                admin_group,
+            ) => {
+                self.minting_allow_choosing_destination_rules
+                    .set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::ManualMinting(control_group) => {
+                self.manual_minting_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::ManualMintingAdminGroup(admin_group) => {
+                self.manual_minting_rules
+                    .set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::ManualBurning(control_group) => {
+                self.manual_burning_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::ManualBurningAdminGroup(admin_group) => {
+                self.manual_burning_rules
+                    .set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::Freeze(control_group) => {
+                self.freeze_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::FreezeAdminGroup(admin_group) => {
+                self.freeze_rules.set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::Unfreeze(control_group) => {
+                self.unfreeze_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::UnfreezeAdminGroup(admin_group) => {
+                self.unfreeze_rules.set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::DestroyFrozenFunds(control_group) => {
+                self.destroy_frozen_funds_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::DestroyFrozenFundsAdminGroup(admin_group) => {
+                self.destroy_frozen_funds_rules
+                    .set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::EmergencyAction(control_group) => {
+                self.emergency_action_rules
+                    .set_authorized_to_make_change_action_takers(control_group);
+            }
+            TokenConfigurationChangeItem::EmergencyActionAdminGroup(admin_group) => {
+                self.emergency_action_rules
+                    .set_admin_action_takers(admin_group);
+            }
+            TokenConfigurationChangeItem::MainControlGroup(main_group) => {
+                self.main_control_group = main_group;
+            }
+        }
+    }
+}

packages/rs-dpp/src/data_contract/associated_token/token_configuration/methods/authorized_action_takers_for_configuration_item/mod.rs

@@ -0,0 +1,25 @@
+use crate::data_contract::associated_token::token_configuration::TokenConfiguration;
+use crate::data_contract::associated_token::token_configuration_item::TokenConfigurationChangeItem;
+use crate::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers;
+
+mod v0;
+
+impl TokenConfiguration {
+    /// Returns the authorized action takers for a specific `TokenConfigurationChangeItem`.
+    ///
+    /// # Parameters
+    /// - `change_item`: The change item for which to retrieve the authorized action takers.
+    ///
+    /// # Returns
+    /// - `AuthorizedActionTakers`: The authorized action takers for the given change item.
+    pub fn authorized_action_takers_for_configuration_item(
+        &self,
+        change_item: &TokenConfigurationChangeItem,
+    ) -> AuthorizedActionTakers {
+        match self {
+            TokenConfiguration::V0(v0) => {
+                v0.authorized_action_takers_for_configuration_item(change_item)
+            }
+        }
+    }
+}