fix(dpp): handle MainGroupIsNotDefinedError in token configuration (#2594)

Author: QuantumExplorer

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

@@ -150,7 +150,7 @@ impl TokenConfigurationV0Getters for TokenConfiguration {
     }
 
     /// Returns all group positions used in the token configuration
-    fn all_used_group_positions(&self) -> BTreeSet<GroupContractPosition> {
+    fn all_used_group_positions(&self) -> (BTreeSet<GroupContractPosition>, bool) {
         match self {
             TokenConfiguration::V0(v0) => v0.all_used_group_positions(),
         }

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

@@ -69,7 +69,7 @@ pub trait TokenConfigurationV0Getters {
     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>;
+    fn all_used_group_positions(&self) -> (BTreeSet<GroupContractPosition>, bool);
 
     /// Returns all the change contract rules, including those from the distribution rules
     fn all_change_control_rules(&self) -> Vec<(&str, &ChangeControlRules)>;

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

@@ -1,4 +1,6 @@
-use crate::consensus::basic::data_contract::GroupPositionDoesNotExistError;
+use crate::consensus::basic::data_contract::{
+    GroupPositionDoesNotExistError, MainGroupIsNotDefinedError,
+};
 use crate::data_contract::associated_token::token_configuration::accessors::v0::TokenConfigurationV0Getters;
 use crate::data_contract::associated_token::token_configuration::TokenConfiguration;
 use crate::data_contract::group::Group;
@@ -16,7 +18,7 @@ impl TokenConfiguration {
         let validation_result = SimpleConsensusValidationResult::new();
 
         // Collect all group positions used in the token configuration
-        let group_positions = self.all_used_group_positions();
+        let (group_positions, uses_main_group) = self.all_used_group_positions();
 
         // Check that all referenced group positions exist in the provided groups map
         for group_position in group_positions {
@@ -27,6 +29,12 @@ impl TokenConfiguration {
             }
         }
 
+        if uses_main_group && self.main_control_group().is_none() {
+            return SimpleConsensusValidationResult::new_with_error(
+                MainGroupIsNotDefinedError::new().into(),
+            );
+        }
+
         // If a main group is defined in the token configuration, verify its existence
         if let Some(main_group_position) = self.main_control_group() {
             if !groups.contains_key(&main_group_position) {

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

@@ -114,8 +114,9 @@ impl TokenConfigurationV0Getters for TokenConfigurationV0 {
     }
 
     /// Returns all group positions used in the token configuration
-    fn all_used_group_positions(&self) -> BTreeSet<GroupContractPosition> {
+    fn all_used_group_positions(&self) -> (BTreeSet<GroupContractPosition>, bool) {
         let mut group_positions = BTreeSet::new();
+        let mut uses_main_group = false;
 
         // Add the main control group if it exists
         if let Some(main_group_position) = self.main_control_group {
@@ -126,6 +127,8 @@ impl TokenConfigurationV0Getters for TokenConfigurationV0 {
         let mut add_from_authorized_action_takers = |authorized_takers: &AuthorizedActionTakers| {
             if let AuthorizedActionTakers::Group(group_position) = authorized_takers {
                 group_positions.insert(*group_position);
+            } else if let AuthorizedActionTakers::MainGroup = authorized_takers {
+                uses_main_group = true;
             }
         };
 
@@ -157,7 +160,7 @@ impl TokenConfigurationV0Getters for TokenConfigurationV0 {
         // Add positions from the `main_control_group_can_be_modified` field
         add_from_authorized_action_takers(&self.main_control_group_can_be_modified);
 
-        group_positions
+        (group_positions, uses_main_group)
     }
 
     fn all_change_control_rules(&self) -> Vec<(&str, &ChangeControlRules)> {

packages/rs-dpp/src/errors/consensus/basic/basic_error.rs

@@ -21,7 +21,7 @@ use crate::consensus::basic::data_contract::{
     InvalidTokenDistributionFunctionIncoherenceError,
     InvalidTokenDistributionFunctionInvalidParameterError,
     InvalidTokenDistributionFunctionInvalidParameterTupleError, InvalidTokenLanguageCodeError,
-    InvalidTokenNameCharacterError, InvalidTokenNameLengthError,
+    InvalidTokenNameCharacterError, InvalidTokenNameLengthError, MainGroupIsNotDefinedError,
     NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError,
     NonContiguousContractTokenPositionsError, SystemPropertyIndexAlreadyPresentError,
     UndefinedIndexPropertyError, UniqueIndicesLimitReachedError,
@@ -554,6 +554,9 @@ pub enum BasicError {
 
     #[error(transparent)]
     InvalidTokenLanguageCodeError(InvalidTokenLanguageCodeError),
+
+    #[error(transparent)]
+    MainGroupIsNotDefinedError(MainGroupIsNotDefinedError),
 }
 
 impl From<BasicError> for ConsensusError {

packages/rs-dpp/src/errors/consensus/basic/data_contract/main_group_is_not_defined.rs

@@ -0,0 +1,31 @@
+use crate::consensus::basic::BasicError;
+use crate::consensus::ConsensusError;
+use crate::ProtocolError;
+use bincode::{Decode, Encode};
+use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
+use thiserror::Error;
+
+#[derive(
+    Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize,
+)]
+#[error("Main group is not defined.")]
+#[platform_serialize(unversioned)]
+pub struct MainGroupIsNotDefinedError;
+
+impl Default for MainGroupIsNotDefinedError {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl MainGroupIsNotDefinedError {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl From<MainGroupIsNotDefinedError> for ConsensusError {
+    fn from(err: MainGroupIsNotDefinedError) -> Self {
+        Self::BasicError(BasicError::MainGroupIsNotDefinedError(err))
+    }
+}

packages/rs-dpp/src/errors/consensus/basic/data_contract/mod.rs

@@ -39,6 +39,7 @@ mod invalid_token_language_code_error;
 mod invalid_token_name_character_error;
 mod invalid_token_name_length_error;
 mod keywords_over_limit;
+mod main_group_is_not_defined;
 mod new_tokens_destination_identity_option_required_error;
 mod non_contiguous_contract_group_positions_error;
 mod non_contiguous_contract_token_positions_error;
@@ -100,6 +101,7 @@ pub use invalid_token_language_code_error::*;
 pub use invalid_token_name_character_error::*;
 pub use invalid_token_name_length_error::*;
 pub use keywords_over_limit::*;
+pub use main_group_is_not_defined::*;
 pub use new_tokens_destination_identity_option_required_error::*;
 pub use non_contiguous_contract_group_positions_error::*;
 pub use non_contiguous_contract_token_positions_error::*;

packages/rs-dpp/src/errors/consensus/codes.rs

@@ -116,6 +116,7 @@ impl ErrorWithCode for BasicError {
             Self::InvalidKeywordCharacterError(_) => 10269,
             Self::InvalidKeywordLengthError(_) => 10270,
             Self::DecimalsOverLimitError(_) => 10271,
+            Self::MainGroupIsNotDefinedError(_) => 10272,
 
             // Group Errors: 10350-10399
             Self::GroupPositionDoesNotExistError(_) => 10350,

packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/mod.rs

@@ -1861,6 +1861,119 @@ mod tests {
                 assert_eq!(token_balance, None);
             }
 
+            #[test]
+            fn test_data_contract_creation_with_single_token_setting_authorization_to_non_defined_main_group(
+            ) {
+                let platform_version = PlatformVersion::latest();
+                let mut platform = TestPlatformBuilder::new()
+                    .build_with_mock_rpc()
+                    .set_genesis_state();
+
+                let platform_state = platform.state.load();
+
+                let (identity, signer, key) =
+                    setup_identity(&mut platform, 958, dash_to_credits!(1.0));
+
+                let (identity_2, _, _) = setup_identity(&mut platform, 564, dash_to_credits!(0.1));
+
+                let mut data_contract = json_document_to_contract_with_ids(
+                    "tests/supporting_files/contract/basic-token/basic-token.json",
+                    None,
+                    None,
+                    false, //no need to validate the data contracts in tests for drive
+                    platform_version,
+                )
+                .expect("expected to get json based contract");
+
+                let identity_id = identity.id();
+
+                {
+                    let groups = data_contract.groups_mut().expect("expected tokens");
+                    groups.insert(
+                        0,
+                        Group::V0(GroupV0 {
+                            members: [(identity.id(), 1), (identity_2.id(), 1)].into(),
+                            required_power: 2,
+                        }),
+                    );
+                    let token_config = data_contract
+                        .tokens_mut()
+                        .expect("expected tokens")
+                        .get_mut(&0)
+                        .expect("expected first token");
+                    token_config.set_manual_minting_rules(ChangeControlRules::V0(
+                        ChangeControlRulesV0 {
+                            authorized_to_make_change: AuthorizedActionTakers::MainGroup,
+                            // We have no group at position 1, we should get an error
+                            admin_action_takers: AuthorizedActionTakers::MainGroup,
+                            changing_authorized_action_takers_to_no_one_allowed: false,
+                            changing_admin_action_takers_to_no_one_allowed: false,
+                            self_changing_admin_action_takers_allowed: false,
+                        },
+                    ));
+                }
+
+                let data_contract_id = DataContract::generate_data_contract_id_v0(identity_id, 1);
+
+                let token_id = calculate_token_id(data_contract_id.as_bytes(), 0);
+
+                let data_contract_create_transition =
+                    DataContractCreateTransition::new_from_data_contract(
+                        data_contract,
+                        1,
+                        &identity.into_partial_identity_info(),
+                        key.id(),
+                        &signer,
+                        platform_version,
+                        None,
+                    )
+                    .expect("expect to create documents batch transition");
+
+                let data_contract_create_serialized_transition = data_contract_create_transition
+                    .serialize_to_bytes()
+                    .expect("expected documents batch serialized state transition");
+
+                let transaction = platform.drive.grove.start_transaction();
+
+                let processing_result = platform
+                    .platform
+                    .process_raw_state_transitions(
+                        &[data_contract_create_serialized_transition.clone()],
+                        &platform_state,
+                        &BlockInfo::default(),
+                        &transaction,
+                        platform_version,
+                        false,
+                        None,
+                    )
+                    .expect("expected to process state transition");
+
+                assert_matches!(
+                    processing_result.execution_results().as_slice(),
+                    [StateTransitionExecutionResult::UnpaidConsensusError(
+                        ConsensusError::BasicError(BasicError::MainGroupIsNotDefinedError(_)),
+                    )]
+                );
+
+                platform
+                    .drive
+                    .grove
+                    .commit_transaction(transaction)
+                    .unwrap()
+                    .expect("expected to commit transaction");
+
+                let token_balance = platform
+                    .drive
+                    .fetch_identity_token_balance(
+                        token_id,
+                        identity_id.to_buffer(),
+                        None,
+                        platform_version,
+                    )
+                    .expect("expected to fetch token balance");
+                assert_eq!(token_balance, None);
+            }
+
             #[test]
             fn test_data_contract_creation_with_single_token_setting_identifier_that_does_not_exist(
             ) {

packages/wasm-dpp/src/errors/consensus/consensus_error.rs

@@ -61,7 +61,7 @@ use dpp::consensus::state::data_trigger::DataTriggerError::{
   DataTriggerConditionError, DataTriggerExecutionError, DataTriggerInvalidResultError,
 };
 use wasm_bindgen::{JsError, JsValue};
-use dpp::consensus::basic::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractTokenConfigurationUpdateError, DecimalsOverLimitError, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupTotalPowerLessThanRequiredError, InvalidDescriptionLengthError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordCharacterError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, InvalidTokenLanguageCodeError, InvalidTokenNameCharacterError, InvalidTokenNameLengthError, NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError};
+use dpp::consensus::basic::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractTokenConfigurationUpdateError, DecimalsOverLimitError, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupTotalPowerLessThanRequiredError, InvalidDescriptionLengthError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordCharacterError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, InvalidTokenLanguageCodeError, InvalidTokenNameCharacterError, InvalidTokenNameLengthError, MainGroupIsNotDefinedError, NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError};
 use dpp::consensus::basic::document::{ContestedDocumentsTemporarilyNotAllowedError, DocumentCreationNotAllowedError, DocumentFieldMaxSizeExceededError, MaxDocumentsTransitionsExceededError, MissingPositionsInDocumentTypePropertiesError};
 use dpp::consensus::basic::group::GroupActionNotAllowedOnTransitionError;
 use dpp::consensus::basic::identity::{DataContractBoundsNotPresentError, DisablingKeyIdAlsoBeingAddedInSameTransitionError, InvalidIdentityCreditWithdrawalTransitionAmountError, InvalidIdentityUpdateTransitionDisableKeysError, InvalidIdentityUpdateTransitionEmptyError, TooManyMasterPublicKeyError, WithdrawalOutputScriptNotAllowedWhenSigningWithOwnerKeyError};
@@ -807,6 +807,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         BasicError::InvalidTokenLanguageCodeError(e) => {
             generic_consensus_error!(InvalidTokenLanguageCodeError, e).into()
         }
+        BasicError::MainGroupIsNotDefinedError(e) => {
+            generic_consensus_error!(MainGroupIsNotDefinedError, e).into()
+        }
     }
 }