more validation

Author: QuantumExplorer

packages/rs-dpp/src/data_contract/document_type/class_methods/try_from_schema/v1/mod.rs

@@ -28,6 +28,7 @@ use crate::consensus::basic::data_contract::ContestedUniqueIndexOnMutableDocumen
 use crate::consensus::basic::data_contract::ContestedUniqueIndexWithUniqueIndexError;
 #[cfg(any(test, feature = "validation"))]
 use crate::consensus::basic::data_contract::InvalidDocumentTypeNameError;
+use crate::consensus::basic::data_contract::RedundantDocumentPaidForByTokenWithContractId;
 #[cfg(feature = "validation")]
 use crate::consensus::basic::data_contract::TokenPaymentByBurningOnlyAllowedOnInternalTokenError;
 #[cfg(feature = "validation")]
@@ -564,7 +565,7 @@ impl DocumentTypeV1 {
                 .transpose()?
                 .map(|action_cost| {
                     // Extract an optional contract_id. Adjust the key if necessary.
-                    let contract_id = action_cost.get_optional_identifier("contractId")?;
+                    let target_contract_id = action_cost.get_optional_identifier("contractId")?;
                     // Extract token_contract_position as an integer, then convert it.
                     let token_contract_position =
                         action_cost.get_integer::<TokenContractPosition>("tokenPosition")?;
@@ -579,7 +580,8 @@ impl DocumentTypeV1 {
 
                     #[cfg(feature = "validation")]
                     if full_validation {
-                        if !token_configurations.contains_key(&token_contract_position) {
+                        // contract id is none if we are on our own contract
+                        if target_contract_id.is_none() && !token_configurations.contains_key(&token_contract_position) {
                             return Err(ProtocolError::ConsensusError(
                                 ConsensusError::BasicError(
                                     BasicError::InvalidTokenPositionError(
@@ -594,13 +596,22 @@ impl DocumentTypeV1 {
                         }
 
                         // If contractId is present and user tries to burn, bail out:
-                        if let Some(contract_id) = contract_id {
+                        if let Some(target_contract_id) = target_contract_id {
+                            if target_contract_id == data_contract_id {
+                                // we are in the same contract, but we set the data contract id
+                                return Err(ProtocolError::ConsensusError(
+                                    ConsensusError::BasicError(
+                                        BasicError::RedundantDocumentPaidForByTokenWithContractId(RedundantDocumentPaidForByTokenWithContractId::new(target_contract_id))
+                                    )
+                                        .into(),
+                                ));
+                            }
                             if effect == DocumentActionTokenEffect::BurnToken {
                                 return Err(ProtocolError::ConsensusError(
                                     ConsensusError::BasicError(
                                         BasicError::TokenPaymentByBurningOnlyAllowedOnInternalTokenError(
                                             TokenPaymentByBurningOnlyAllowedOnInternalTokenError::new(
-                                                contract_id,
+                                                target_contract_id,
                                                 token_contract_position,
                                                 key.to_string(),
                                             ),
@@ -620,7 +631,7 @@ impl DocumentTypeV1 {
                         .unwrap_or(GasFeesPaidBy::DocumentOwner);
 
                     Ok(DocumentActionTokenCost {
-                        contract_id,
+                        contract_id: target_contract_id,
                         token_contract_position,
                         token_amount,
                         effect,

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

@@ -23,11 +23,11 @@ use crate::consensus::basic::data_contract::{
     InvalidTokenDistributionFunctionInvalidParameterTupleError, InvalidTokenLanguageCodeError,
     InvalidTokenNameCharacterError, InvalidTokenNameLengthError, MainGroupIsNotDefinedError,
     NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError,
-    NonContiguousContractTokenPositionsError, SystemPropertyIndexAlreadyPresentError,
-    UndefinedIndexPropertyError, UniqueIndicesLimitReachedError,
-    UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError,
-    UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError,
-    UnknownTransferableTypeError,
+    NonContiguousContractTokenPositionsError, RedundantDocumentPaidForByTokenWithContractId,
+    SystemPropertyIndexAlreadyPresentError, UndefinedIndexPropertyError,
+    UniqueIndicesLimitReachedError, UnknownDocumentCreationRestrictionModeError,
+    UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError,
+    UnknownTradeModeError, UnknownTransferableTypeError,
 };
 use crate::consensus::basic::data_contract::{
     InvalidJsonSchemaRefError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError,
@@ -564,6 +564,9 @@ pub enum BasicError {
 
     #[error(transparent)]
     TokenNoteOnlyAllowedWhenProposerError(TokenNoteOnlyAllowedWhenProposerError),
+
+    #[error(transparent)]
+    RedundantDocumentPaidForByTokenWithContractId(RedundantDocumentPaidForByTokenWithContractId),
 }
 
 impl From<BasicError> for ConsensusError {

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

@@ -44,6 +44,7 @@ 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;
+mod redundant_document_paid_for_by_token_with_contract_id;
 mod system_property_index_already_present_error;
 mod token_decimals_over_limit_error;
 mod token_payment_by_burning_only_allowed_on_internal_token_error;
@@ -107,6 +108,7 @@ 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::*;
+pub use redundant_document_paid_for_by_token_with_contract_id::*;
 pub use token_decimals_over_limit_error::*;
 pub use token_payment_by_burning_only_allowed_on_internal_token_error::*;
 pub use unknown_document_action_token_effect_error::*;

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

@@ -0,0 +1,34 @@
+use crate::consensus::basic::BasicError;
+use crate::consensus::ConsensusError;
+use crate::errors::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("Document paid for by a token has a contractId {contract_id} set, which is redundant because it is targeting the current contract")]
+#[platform_serialize(unversioned)]
+pub struct RedundantDocumentPaidForByTokenWithContractId {
+    contract_id: Identifier,
+}
+
+impl RedundantDocumentPaidForByTokenWithContractId {
+    pub fn new(contract_id: Identifier) -> Self {
+        Self { contract_id }
+    }
+
+    pub fn contract_id(&self) -> Identifier {
+        self.contract_id
+    }
+}
+
+impl From<RedundantDocumentPaidForByTokenWithContractId> for ConsensusError {
+    fn from(err: RedundantDocumentPaidForByTokenWithContractId) -> Self {
+        Self::BasicError(BasicError::RedundantDocumentPaidForByTokenWithContractId(
+            err,
+        ))
+    }
+}

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::RedundantDocumentPaidForByTokenWithContractId(_) => 10272,
 
             // Group Errors: 10350-10399
             Self::GroupPositionDoesNotExistError(_) => 10350,

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, GroupRequiredPowerIsInvalidError, 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::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractTokenConfigurationUpdateError, DecimalsOverLimitError, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupRequiredPowerIsInvalidError, GroupTotalPowerLessThanRequiredError, InvalidDescriptionLengthError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordCharacterError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, InvalidTokenLanguageCodeError, InvalidTokenNameCharacterError, InvalidTokenNameLengthError, MainGroupIsNotDefinedError, NewTokensDestinationIdentityOptionRequiredError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, RedundantDocumentPaidForByTokenWithContractId, 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};
@@ -824,6 +824,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         BasicError::TokenNoteOnlyAllowedWhenProposerError(e) => {
             generic_consensus_error!(TokenNoteOnlyAllowedWhenProposerError, e).into()
         }
+        BasicError::RedundantDocumentPaidForByTokenWithContractId(e) => {
+            generic_consensus_error!(RedundantDocumentPaidForByTokenWithContractId, e).into()
+        }
     }
 }