fix(platform): force allow choosing minting destination if no default minting destination recipient (#2586)

Author: QuantumExplorer

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

@@ -20,11 +20,12 @@ use crate::consensus::basic::data_contract::{
     InvalidTokenDistributionFunctionIncoherenceError,
     InvalidTokenDistributionFunctionInvalidParameterError,
     InvalidTokenDistributionFunctionInvalidParameterTupleError,
-    NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError,
-    SystemPropertyIndexAlreadyPresentError, UndefinedIndexPropertyError,
-    UniqueIndicesLimitReachedError, UnknownDocumentCreationRestrictionModeError,
-    UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError,
-    UnknownTradeModeError, UnknownTransferableTypeError,
+    NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError,
+    NonContiguousContractTokenPositionsError, SystemPropertyIndexAlreadyPresentError,
+    UndefinedIndexPropertyError, UniqueIndicesLimitReachedError,
+    UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError,
+    UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError,
+    UnknownTransferableTypeError,
 };
 use crate::consensus::basic::data_contract::{
     InvalidJsonSchemaRefError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError,
@@ -531,6 +532,11 @@ pub enum BasicError {
 
     #[error(transparent)]
     InvalidDescriptionLengthError(InvalidDescriptionLengthError),
+
+    #[error(transparent)]
+    NewTokensDestinationIdentityOptionRequiredError(
+        NewTokensDestinationIdentityOptionRequiredError,
+    ),
 }
 
 impl From<BasicError> for ConsensusError {

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

@@ -35,6 +35,7 @@ mod invalid_token_distribution_function_incoherence_error;
 mod invalid_token_distribution_function_invalid_parameter_error;
 mod invalid_token_distribution_function_invalid_parameter_tuple_error;
 mod keywords_over_limit;
+mod new_tokens_destination_identity_option_required_error;
 mod non_contiguous_contract_group_positions_error;
 mod non_contiguous_contract_token_positions_error;
 mod system_property_index_already_present_error;
@@ -90,6 +91,7 @@ pub use invalid_token_distribution_function_incoherence_error::*;
 pub use invalid_token_distribution_function_invalid_parameter_error::*;
 pub use invalid_token_distribution_function_invalid_parameter_tuple_error::*;
 pub use keywords_over_limit::*;
+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::*;
 pub use token_payment_by_burning_only_allowed_on_internal_token_error::*;

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

@@ -0,0 +1,43 @@
+use crate::consensus::basic::BasicError;
+use crate::consensus::ConsensusError;
+use crate::data_contract::TokenContractPosition;
+use crate::ProtocolError;
+use bincode::{Decode, Encode};
+use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
+use platform_value::Identifier;
+use thiserror::Error;
+
+#[derive(
+    Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize,
+)]
+#[error("token configuration requires a new tokens destination identity if choosing destination is not allowed for contract {contract_id} at position {token_position}")]
+#[platform_serialize(unversioned)]
+pub struct NewTokensDestinationIdentityOptionRequiredError {
+    contract_id: Identifier,
+    token_position: TokenContractPosition,
+}
+
+impl NewTokensDestinationIdentityOptionRequiredError {
+    pub fn new(contract_id: Identifier, token_position: TokenContractPosition) -> Self {
+        Self {
+            contract_id,
+            token_position,
+        }
+    }
+
+    pub fn contract_id(&self) -> &Identifier {
+        &self.contract_id
+    }
+
+    pub fn token_position(&self) -> TokenContractPosition {
+        self.token_position
+    }
+}
+
+impl From<NewTokensDestinationIdentityOptionRequiredError> for ConsensusError {
+    fn from(err: NewTokensDestinationIdentityOptionRequiredError) -> Self {
+        Self::BasicError(BasicError::NewTokensDestinationIdentityOptionRequiredError(
+            err,
+        ))
+    }
+}

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

@@ -110,6 +110,7 @@ impl ErrorWithCode for BasicError {
             Self::DuplicateKeywordsError(_) => 10263,
             Self::InvalidKeywordLengthError(_) => 10264,
             Self::InvalidDescriptionLengthError(_) => 10265,
+            Self::NewTokensDestinationIdentityOptionRequiredError(_) => 10266,
 
             // Group Errors: 10350-10399
             Self::GroupPositionDoesNotExistError(_) => 10350,

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

@@ -2,7 +2,8 @@ use crate::error::Error;
 use dpp::consensus::basic::data_contract::{
     DuplicateKeywordsError, InvalidDataContractVersionError, InvalidDescriptionLengthError,
     InvalidKeywordLengthError, InvalidTokenBaseSupplyError,
-    NonContiguousContractTokenPositionsError, TooManyKeywordsError,
+    NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractTokenPositionsError,
+    TooManyKeywordsError,
 };
 use dpp::consensus::basic::BasicError;
 use dpp::consensus::ConsensusError;
@@ -97,6 +98,23 @@ impl DataContractCreateStateTransitionBasicStructureValidationV0 for DataContrac
                     return Ok(validation_result);
                 }
             }
+
+            if token_configuration
+                .distribution_rules()
+                .new_tokens_destination_identity()
+                .is_none()
+                && !token_configuration
+                    .distribution_rules()
+                    .minting_allow_choosing_destination()
+            {
+                return Ok(SimpleConsensusValidationResult::new_with_error(
+                    NewTokensDestinationIdentityOptionRequiredError::new(
+                        self.data_contract().id(),
+                        *token_contract_position,
+                    )
+                    .into(),
+                ));
+            }
         }
 
         // Validate there are no more than 20 keywords

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

@@ -1,6 +1,7 @@
 use crate::error::Error;
 use dpp::consensus::basic::data_contract::{
-    InvalidTokenBaseSupplyError, NonContiguousContractTokenPositionsError,
+    InvalidTokenBaseSupplyError, NewTokensDestinationIdentityOptionRequiredError,
+    NonContiguousContractTokenPositionsError,
 };
 use dpp::data_contract::associated_token::token_configuration::accessors::v0::TokenConfigurationV0Getters;
 use dpp::data_contract::associated_token::token_distribution_rules::accessors::v0::TokenDistributionRulesV0Getters;
@@ -82,6 +83,23 @@ impl DataContractUpdateStateTransitionBasicStructureValidationV0 for DataContrac
                     return Ok(validation_result);
                 }
             }
+
+            if token_configuration
+                .distribution_rules()
+                .new_tokens_destination_identity()
+                .is_none()
+                && !token_configuration
+                    .distribution_rules()
+                    .minting_allow_choosing_destination()
+            {
+                return Ok(SimpleConsensusValidationResult::new_with_error(
+                    NewTokensDestinationIdentityOptionRequiredError::new(
+                        self.data_contract().id(),
+                        *token_contract_position,
+                    )
+                    .into(),
+                ));
+            }
         }
 
         Ok(SimpleConsensusValidationResult::new())

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, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupTotalPowerLessThanRequiredError, InvalidDescriptionLengthError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError};
+use dpp::consensus::basic::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractTokenConfigurationUpdateError, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupTotalPowerLessThanRequiredError, InvalidDescriptionLengthError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, 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};
@@ -789,6 +789,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         BasicError::InvalidDescriptionLengthError(e) => {
             generic_consensus_error!(InvalidDescriptionLengthError, e).into()
         }
+        BasicError::NewTokensDestinationIdentityOptionRequiredError(e) => {
+            generic_consensus_error!(NewTokensDestinationIdentityOptionRequiredError, e).into()
+        }
     }
 }