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/check_tx_verification/v0/mod.rs

@@ -64,7 +64,7 @@ pub(super) fn state_transition_to_execution_event_for_check_tx_v0<'a, C: CoreRPC
             }
 
             // Only Data contract update does not have basic structure validation
-            if state_transition.has_basic_structure_validation() {
+            if state_transition.has_basic_structure_validation(platform_version) {
                 // First we validate the basic structure
                 let result = state_transition.validate_basic_structure(platform_version)?;
 

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;
@@ -105,7 +105,7 @@ pub(super) fn process_state_transition_v0<'a, C: CoreRPCLike>(
     }
 
     // Only Data contract state transitions and Masternode vote do not have basic structure validation
-    if state_transition.has_basic_structure_validation() {
+    if state_transition.has_basic_structure_validation(platform_version) {
         // We validate basic structure validation after verifying the identity,
         // this is structure validation that does not require state and is already checked on check_tx
         let consensus_result = state_transition.validate_basic_structure(platform_version)?;
@@ -333,7 +333,7 @@ pub(crate) trait StateTransitionBasicStructureValidationV0 {
 
     /// True if the state transition has basic structure validation.
     /// Currently only data contract update does not
-    fn has_basic_structure_validation(&self) -> bool {
+    fn has_basic_structure_validation(&self, _platform_version: &PlatformVersion) -> bool {
         true
     }
 }
@@ -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,66 @@ impl StateTransitionBasicStructureValidationV0 for StateTransition {
             StateTransition::IdentityCreditTransfer(st) => {
                 st.validate_basic_structure(platform_version)
             }
+            StateTransition::DataContractCreate(st) => {
+                if platform_version
+                    .drive_abci
+                    .validation_and_processing
+                    .state_transitions
+                    .contract_create_state_transition
+                    .basic_structure
+                    .is_some()
+                {
+                    st.validate_basic_structure(platform_version)
+                } else {
+                    Ok(SimpleConsensusValidationResult::new())
+                }
+            }
+            StateTransition::DataContractUpdate(st) => {
+                if platform_version
+                    .drive_abci
+                    .validation_and_processing
+                    .state_transitions
+                    .contract_update_state_transition
+                    .basic_structure
+                    .is_some()
+                {
+                    st.validate_basic_structure(platform_version)
+                } else {
+                    Ok(SimpleConsensusValidationResult::new())
+                }
+            }
         }
     }
-    fn has_basic_structure_validation(&self) -> bool {
-        !matches!(
-            self,
-            StateTransition::DataContractCreate(_)
-                | StateTransition::DataContractUpdate(_)
-                | StateTransition::MasternodeVote(_)
-        )
+    fn has_basic_structure_validation(&self, platform_version: &PlatformVersion) -> bool {
+        match self {
+            StateTransition::DataContractCreate(_) => {
+                // Added in protocol version 9 (version 2.0)
+                platform_version
+                    .drive_abci
+                    .validation_and_processing
+                    .state_transitions
+                    .contract_create_state_transition
+                    .basic_structure
+                    .is_some()
+            }
+            StateTransition::DataContractUpdate(_) => {
+                // Added in protocol version 9  (version 2.0)
+                platform_version
+                    .drive_abci
+                    .validation_and_processing
+                    .state_transitions
+                    .contract_update_state_transition
+                    .basic_structure
+                    .is_some()
+            }
+            StateTransition::Batch(_)
+            | StateTransition::IdentityCreate(_)
+            | StateTransition::IdentityTopUp(_)
+            | StateTransition::IdentityCreditWithdrawal(_)
+            | StateTransition::IdentityUpdate(_)
+            | StateTransition::IdentityCreditTransfer(_) => true,
+            StateTransition::MasternodeVote(_) => false,
+        }
     }
 }
 

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

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

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

@@ -1,25 +1,16 @@
 use crate::error::Error;
-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::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 crate::execution::types::state_transition_execution_context::StateTransitionExecutionContext;
+use crate::execution::validation::state_transition::data_contract_create::advanced_structure::v1::DataContractCreatedStateTransitionAdvancedStructureValidationV1;
+use dpp::consensus::basic::data_contract::InvalidDataContractVersionError;
+use dpp::data_contract::INITIAL_DATA_CONTRACT_VERSION;
 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,8 +19,8 @@ impl DataContractCreatedStateTransitionAdvancedStructureValidationV0
     fn validate_advanced_structure_v0(
         &self,
         execution_context: &mut StateTransitionExecutionContext,
-        platform_version: &PlatformVersion,
     ) -> Result<ConsensusValidationResult<StateTransitionAction>, Error> {
+        // Moved this to basic structure validation in protocol version 9
         if self.data_contract().version() != INITIAL_DATA_CONTRACT_VERSION {
             let bump_action = StateTransitionAction::BumpIdentityNonceAction(
                 BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self),
@@ -45,110 +36,7 @@ impl DataContractCreatedStateTransitionAdvancedStructureValidationV0
             ));
         }
 
-        // Validate data contract id
-        let generated_id = DataContract::generate_data_contract_id_v0(
-            self.data_contract().owner_id(),
-            self.identity_nonce(),
-        );
-
-        // This hash will only take 1 block (64 bytes)
-        execution_context.add_operation(ValidationOperation::DoubleSha256(1));
-
-        if generated_id != self.data_contract().id() {
-            let bump_action = StateTransitionAction::BumpIdentityNonceAction(
-                BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self),
-            );
-
-            return Ok(ConsensusValidationResult::new_with_data_and_errors(
-                bump_action,
-                vec![
-                    BasicError::InvalidDataContractIdError(InvalidDataContractIdError::new(
-                        generated_id.to_vec(),
-                        self.data_contract().id().to_vec(),
-                    ))
-                    .into(),
-                ],
-            ));
-        }
-
-        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())
+        self.validate_advanced_structure_v1(execution_context)
     }
 }
 
@@ -168,54 +56,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 +89,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!(