feat(platform): allow new tokens on contract update and refactor contract struct validations

packages/rs-dpp/src/data_contract/methods/validate_update/mod.rs

@@ -1,3 +1,4 @@
+use crate::block::block_info::BlockInfo;
 use crate::prelude::DataContract;
 use platform_version::version::PlatformVersion;
 
@@ -10,6 +11,7 @@ impl DataContractUpdateValidationMethodsV0 for DataContract {
     fn validate_update(
         &self,
         data_contract: &DataContract,
+        block_info: &BlockInfo,
         platform_version: &PlatformVersion,
     ) -> Result<SimpleConsensusValidationResult, ProtocolError> {
         match platform_version
@@ -18,7 +20,7 @@ impl DataContractUpdateValidationMethodsV0 for DataContract {
             .methods
             .validate_update
         {
-            0 => self.validate_update_v0(data_contract, platform_version),
+            0 => self.validate_update_v0(data_contract, block_info, platform_version),
             version => Err(ProtocolError::UnknownVersionMismatch {
                 method: "DataContract::validate_update".to_string(),
                 known_versions: vec![0],

packages/rs-drive-abci/src/execution/validation/state_transition/processor/v0/mod.rs

@@ -21,9 +21,9 @@ use drive::grovedb::TransactionArg;
 use drive::state_transition_action::StateTransitionAction;
 use std::collections::BTreeMap;
 
-use crate::execution::types::state_transition_execution_context::{StateTransitionExecutionContext};
+use crate::execution::types::state_transition_execution_context::StateTransitionExecutionContext;
 use crate::execution::validation::state_transition::common::validate_simple_pre_check_balance::ValidateSimplePreCheckBalance;
-use crate::execution::validation::state_transition::common::validate_state_transition_identity_signed::{ValidateStateTransitionIdentitySignature};
+use crate::execution::validation::state_transition::common::validate_state_transition_identity_signed::ValidateStateTransitionIdentitySignature;
 use crate::execution::validation::state_transition::identity_create::{StateTransitionStateValidationForIdentityCreateTransitionV0, StateTransitionStructureKnownInStateValidationForIdentityCreateTransitionV0};
 use crate::execution::validation::state_transition::identity_top_up::StateTransitionIdentityTopUpTransitionActionTransformer;
 use crate::execution::validation::state_transition::state_transitions::identity_update::advanced_structure::v0::IdentityUpdateStateTransitionIdentityAndSignaturesValidationV0;
@@ -516,9 +516,7 @@ impl StateTransitionBasicStructureValidationV0 for StateTransition {
         platform_version: &PlatformVersion,
     ) -> Result<SimpleConsensusValidationResult, Error> {
         match self {
-            StateTransition::DataContractCreate(_)
-            | StateTransition::DataContractUpdate(_)
-            | StateTransition::MasternodeVote(_) => {
+            StateTransition::MasternodeVote(_) => {
                 // no basic structure validation
                 Ok(SimpleConsensusValidationResult::new())
             }
@@ -532,15 +530,16 @@ impl StateTransitionBasicStructureValidationV0 for StateTransition {
             StateTransition::IdentityCreditTransfer(st) => {
                 st.validate_basic_structure(platform_version)
             }
+            StateTransition::DataContractCreate(st) => {
+                st.validate_basic_structure(platform_version)
+            }
+            StateTransition::DataContractUpdate(st) => {
+                st.validate_basic_structure(platform_version)
+            }
         }
     }
     fn has_basic_structure_validation(&self) -> bool {
-        !matches!(
-            self,
-            StateTransition::DataContractCreate(_)
-                | StateTransition::DataContractUpdate(_)
-                | StateTransition::MasternodeVote(_)
-        )
+        !matches!(self, StateTransition::MasternodeVote(_))
     }
 }
 

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

@@ -3,23 +3,17 @@ use crate::execution::types::execution_operation::ValidationOperation;
 use crate::execution::types::state_transition_execution_context::{
     StateTransitionExecutionContext, StateTransitionExecutionContextMethodsV0,
 };
-use dpp::consensus::basic::data_contract::{
-    InvalidDataContractIdError, InvalidDataContractVersionError, InvalidTokenBaseSupplyError,
-    NonContiguousContractTokenPositionsError,
-};
+use dpp::consensus::basic::data_contract::InvalidDataContractIdError;
 use dpp::consensus::basic::BasicError;
-use dpp::data_contract::associated_token::token_configuration::accessors::v0::TokenConfigurationV0Getters;
-use dpp::data_contract::{TokenContractPosition, INITIAL_DATA_CONTRACT_VERSION};
 use dpp::prelude::DataContract;
 use dpp::state_transition::data_contract_create_transition::accessors::DataContractCreateTransitionAccessorsV0;
 use dpp::state_transition::data_contract_create_transition::DataContractCreateTransition;
 use dpp::validation::ConsensusValidationResult;
-use dpp::version::PlatformVersion;
 use drive::state_transition_action::system::bump_identity_nonce_action::BumpIdentityNonceAction;
 use drive::state_transition_action::StateTransitionAction;
 
 pub(in crate::execution::validation::state_transition::state_transitions::data_contract_create) trait DataContractCreatedStateTransitionAdvancedStructureValidationV0 {
-    fn validate_advanced_structure_v0(&self, execution_context: &mut StateTransitionExecutionContext, platform_version: &PlatformVersion) -> Result<ConsensusValidationResult<StateTransitionAction>, Error>;
+    fn validate_advanced_structure_v0(&self, execution_context: &mut StateTransitionExecutionContext) -> Result<ConsensusValidationResult<StateTransitionAction>, Error>;
 }
 
 impl DataContractCreatedStateTransitionAdvancedStructureValidationV0
@@ -28,23 +22,7 @@ impl DataContractCreatedStateTransitionAdvancedStructureValidationV0
     fn validate_advanced_structure_v0(
         &self,
         execution_context: &mut StateTransitionExecutionContext,
-        platform_version: &PlatformVersion,
     ) -> Result<ConsensusValidationResult<StateTransitionAction>, Error> {
-        if self.data_contract().version() != INITIAL_DATA_CONTRACT_VERSION {
-            let bump_action = StateTransitionAction::BumpIdentityNonceAction(
-                BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self),
-            );
-
-            return Ok(ConsensusValidationResult::new_with_data_and_errors(
-                bump_action,
-                vec![InvalidDataContractVersionError::new(
-                    INITIAL_DATA_CONTRACT_VERSION,
-                    self.data_contract().version(),
-                )
-                .into()],
-            ));
-        }
-
         // Validate data contract id
         let generated_id = DataContract::generate_data_contract_id_v0(
             self.data_contract().owner_id(),
@@ -71,83 +49,6 @@ impl DataContractCreatedStateTransitionAdvancedStructureValidationV0
             ));
         }
 
-        let groups = self.data_contract().groups();
-        if !groups.is_empty() {
-            let validation_result = DataContract::validate_groups(groups, platform_version)?;
-
-            if !validation_result.is_valid() {
-                let bump_action = StateTransitionAction::BumpIdentityNonceAction(
-                    BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self),
-                );
-
-                return Ok(ConsensusValidationResult::new_with_data_and_errors(
-                    bump_action,
-                    validation_result.errors,
-                ));
-            }
-        }
-
-        for (expected_position, (token_contract_position, token_configuration)) in
-            self.data_contract().tokens().iter().enumerate()
-        {
-            if expected_position as TokenContractPosition != *token_contract_position {
-                let bump_action = StateTransitionAction::BumpIdentityNonceAction(
-                    BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self),
-                );
-
-                return Ok(ConsensusValidationResult::new_with_data_and_errors(
-                    bump_action,
-                    vec![NonContiguousContractTokenPositionsError::new(
-                        expected_position as TokenContractPosition,
-                        *token_contract_position,
-                    )
-                    .into()],
-                ));
-            }
-
-            if token_configuration.base_supply() > i64::MAX as u64 {
-                let bump_action = StateTransitionAction::BumpIdentityNonceAction(
-                    BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self),
-                );
-
-                return Ok(ConsensusValidationResult::new_with_data_and_errors(
-                    bump_action,
-                    vec![
-                        InvalidTokenBaseSupplyError::new(token_configuration.base_supply()).into(),
-                    ],
-                ));
-            }
-
-            let validation_result = token_configuration
-                .conventions()
-                .validate_localizations(platform_version)?;
-            if !validation_result.is_valid() {
-                let bump_action = StateTransitionAction::BumpIdentityNonceAction(
-                    BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self),
-                );
-
-                return Ok(ConsensusValidationResult::new_with_data_and_errors(
-                    bump_action,
-                    validation_result.errors,
-                ));
-            }
-
-            let validation_result = token_configuration.validate_token_config_groups_exist(
-                self.data_contract().groups(),
-                platform_version,
-            )?;
-            if !validation_result.is_valid() {
-                let bump_action = StateTransitionAction::BumpIdentityNonceAction(
-                    BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self),
-                );
-
-                return Ok(ConsensusValidationResult::new_with_data_and_errors(
-                    bump_action,
-                    validation_result.errors,
-                ));
-            }
-        }
-
         Ok(ConsensusValidationResult::default())
     }
 }
@@ -168,54 +69,6 @@ mod tests {
         use platform_version::version::PlatformVersion;
         use platform_version::{DefaultForPlatformVersion, TryIntoPlatformVersioned};
 
-        #[test]
-        fn should_return_invalid_result_if_contract_version_is_not_initial() {
-            let platform_version = PlatformVersion::latest();
-            let identity_nonce = IdentityNonce::default();
-
-            let mut data_contract =
-                get_data_contract_fixture(None, identity_nonce, platform_version.protocol_version)
-                    .data_contract_owned();
-
-            data_contract.set_version(6);
-
-            let identity_id = data_contract.owner_id();
-
-            let data_contract_for_serialization = data_contract
-                .try_into_platform_versioned(platform_version)
-                .expect("failed to convert data contract");
-
-            let transition: DataContractCreateTransition = DataContractCreateTransitionV0 {
-                data_contract: data_contract_for_serialization,
-                identity_nonce,
-                user_fee_increase: 0,
-                signature_public_key_id: 0,
-                signature: Default::default(),
-            }
-            .into();
-
-            let mut execution_context =
-                StateTransitionExecutionContext::default_for_platform_version(platform_version)
-                    .expect("failed to create execution context");
-
-            let result = transition
-                .validate_advanced_structure_v0(&mut execution_context, platform_version)
-                .expect("failed to validate advanced structure");
-
-            assert_matches!(execution_context.operations_slice(), []);
-
-            assert_matches!(
-                result.data,
-                Some(StateTransitionAction::BumpIdentityNonceAction(action))
-                if action.identity_id() == identity_id && action.identity_nonce() == identity_nonce
-            );
-
-            assert_matches!(
-                result.errors.as_slice(),
-                [ConsensusError::BasicError(BasicError::InvalidDataContractVersionError(e))] if e.expected_version() == INITIAL_DATA_CONTRACT_VERSION && e.version() == 6
-            );
-        }
-
         #[test]
         fn should_return_invalid_result_if_contract_id_is_not_valid() {
             let platform_version = PlatformVersion::latest();
@@ -249,7 +102,7 @@ mod tests {
                     .expect("failed to create execution context");
 
             let result = transition
-                .validate_advanced_structure_v0(&mut execution_context, platform_version)
+                .validate_advanced_structure_v0(&mut execution_context)
                 .expect("failed to validate advanced structure");
 
             assert_matches!(

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

@@ -0,0 +1 @@
+pub(crate) mod v0;