fix(drive): mint to self if allowed and no destination id set

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

@@ -77,7 +77,7 @@ use crate::consensus::basic::group::GroupActionNotAllowedOnTransitionError;
 use crate::consensus::basic::overflow_error::OverflowError;
 use crate::consensus::basic::token::{
     ChoosingTokenMintRecipientNotAllowedError, ContractHasNoTokensError,
-    DestinationIdentityForTokenMintingNotSetError, InvalidActionIdError, InvalidTokenAmountError,
+    InvalidActionIdError, InvalidTokenAmountError,
     InvalidTokenConfigUpdateNoChangeError, InvalidTokenIdError, InvalidTokenNoteTooBigError,
     InvalidTokenPositionError, MissingDefaultLocalizationError, TokenTransferToOurselfError,
 };
@@ -478,9 +478,6 @@ pub enum BasicError {
     #[error(transparent)]
     InvalidActionIdError(InvalidActionIdError),
 
-    #[error(transparent)]
-    DestinationIdentityForTokenMintingNotSetError(DestinationIdentityForTokenMintingNotSetError),
-
     #[error(transparent)]
     ChoosingTokenMintRecipientNotAllowedError(ChoosingTokenMintRecipientNotAllowedError),
 

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

@@ -1,6 +1,5 @@
 mod choosing_token_mint_recipient_not_allowed_error;
 mod contract_has_no_tokens_error;
-mod destination_identity_for_token_minting_not_set_error;
 mod invalid_action_id_error;
 mod invalid_token_amount_error;
 mod invalid_token_config_update_no_change_error;
@@ -12,7 +11,6 @@ mod token_transfer_to_ourselves_error;
 
 pub use choosing_token_mint_recipient_not_allowed_error::*;
 pub use contract_has_no_tokens_error::*;
-pub use destination_identity_for_token_minting_not_set_error::*;
 pub use invalid_action_id_error::*;
 pub use invalid_token_amount_error::*;
 pub use invalid_token_config_update_no_change_error::*;

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

@@ -143,12 +143,11 @@ impl ErrorWithCode for BasicError {
             Self::InvalidTokenPositionError(_) => 10451,
             Self::InvalidActionIdError(_) => 10452,
             Self::ContractHasNoTokensError(_) => 10453,
-            Self::DestinationIdentityForTokenMintingNotSetError(_) => 10454,
-            Self::ChoosingTokenMintRecipientNotAllowedError(_) => 10455,
-            Self::TokenTransferToOurselfError(_) => 10456,
-            Self::InvalidTokenConfigUpdateNoChangeError(_) => 10457,
-            Self::InvalidTokenAmountError(_) => 10458,
-            Self::InvalidTokenNoteTooBigError(_) => 10459,
+            Self::ChoosingTokenMintRecipientNotAllowedError(_) => 10454,
+            Self::TokenTransferToOurselfError(_) => 10455,
+            Self::InvalidTokenConfigUpdateNoChangeError(_) => 10456,
+            Self::InvalidTokenAmountError(_) => 10457,
+            Self::InvalidTokenNoteTooBigError(_) => 10458,
 
             // Identity Errors: 10500-10599
             Self::DuplicatedIdentityPublicKeyBasicError(_) => 10500,

packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/token/mod.rs

@@ -427,6 +427,8 @@ mod token_tests {
                     platform_version,
                 );
 
+                let base_supply = contract.tokens().get(&0).unwrap().base_supply();
+
                 let documents_batch_create_transition = BatchTransition::new_token_mint_transition(
                     token_id,
                     identity.id(),
@@ -469,12 +471,7 @@ mod token_tests {
 
                 assert_matches!(
                     processing_result.execution_results().as_slice(),
-                    [StateTransitionExecutionResult::PaidConsensusError(
-                        ConsensusError::BasicError(
-                            BasicError::DestinationIdentityForTokenMintingNotSetError(_)
-                        ),
-                        _
-                    )]
+                    [StateTransitionExecutionResult::SuccessfulExecution(_, _)]
                 );
 
                 platform
@@ -483,6 +480,20 @@ mod token_tests {
                     .commit_transaction(transaction)
                     .unwrap()
                     .expect("expected to commit transaction");
+
+                let token_balance = platform
+                    .drive
+                    .fetch_identity_token_balance(
+                        token_id.to_buffer(),
+                        identity.id().to_buffer(),
+                        None,
+                        platform_version,
+                    )
+                    .expect("expected to fetch token balance");
+                assert_eq!(
+                    token_balance.expect("expected token balance") - base_supply,
+                    1337
+                );
             }
         }
 
@@ -714,6 +725,8 @@ mod token_tests {
                     platform_version,
                 );
 
+                let base_supply = contract.tokens().get(&0).unwrap().base_supply();
+
                 let documents_batch_create_transition = BatchTransition::new_token_mint_transition(
                     token_id,
                     identity.id(),
@@ -756,12 +769,7 @@ mod token_tests {
 
                 assert_matches!(
                     processing_result.execution_results().as_slice(),
-                    [StateTransitionExecutionResult::PaidConsensusError(
-                        ConsensusError::BasicError(
-                            BasicError::DestinationIdentityForTokenMintingNotSetError(_)
-                        ),
-                        _
-                    )]
+                    [StateTransitionExecutionResult::SuccessfulExecution(_, _)]
                 );
 
                 platform
@@ -770,6 +778,20 @@ mod token_tests {
                     .commit_transaction(transaction)
                     .unwrap()
                     .expect("expected to commit transaction");
+
+                let token_balance = platform
+                    .drive
+                    .fetch_identity_token_balance(
+                        token_id.to_buffer(),
+                        identity.id().to_buffer(),
+                        None,
+                        platform_version,
+                    )
+                    .expect("expected to fetch token balance");
+                assert_eq!(
+                    token_balance.expect("expected token balance") - base_supply,
+                    1337
+                );
             }
         }
 

packages/rs-drive/src/state_transition_action/batch/batched_transition/token_transition/token_mint_transition_action/v0/transformer.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 use grovedb::TransactionArg;
 use dpp::block::block_info::BlockInfo;
 use dpp::consensus::basic::BasicError;
-use dpp::consensus::basic::token::{ChoosingTokenMintRecipientNotAllowedError, DestinationIdentityForTokenMintingNotSetError};
+use dpp::consensus::basic::token::ChoosingTokenMintRecipientNotAllowedError;
 use dpp::identifier::Identifier;
 use dpp::state_transition::batch_transition::token_mint_transition::v0::TokenMintTransitionV0;
 use dpp::ProtocolError;
@@ -116,6 +116,7 @@ impl TokenMintTransitionActionV0 {
             }
         };
 
+        // First, validate that choosing recipient is allowed if a recipient is set
         if !base_action
             .token_configuration()?
             .distribution_rules()
@@ -143,6 +144,8 @@ impl TokenMintTransitionActionV0 {
             ));
         }
 
+        // If no recipient is set, use the default recipient. If no default recipient, use the minter ID
+        // We already validated that the minter is allowed to mint tokens
         let identity_balance_holder_id = match issued_to_identity_id.or_else(|| {
             base_action
                 .data_contract_fetch_info_ref()
@@ -157,29 +160,7 @@ impl TokenMintTransitionActionV0 {
                 })
         }) {
             Some(identity_balance_holder_id) => identity_balance_holder_id,
-            None => {
-                let bump_action =
-                    BumpIdentityDataContractNonceAction::from_borrowed_token_base_transition_action(
-                        &base_action,
-                        owner_id,
-                        0,
-                    );
-                let batched_action =
-                    BatchedTransitionAction::BumpIdentityDataContractNonce(bump_action);
-
-                return Ok((
-                    ConsensusValidationResult::new_with_data_and_errors(
-                        batched_action.into(),
-                        vec![BasicError::DestinationIdentityForTokenMintingNotSetError(
-                            DestinationIdentityForTokenMintingNotSetError::new(
-                                base_action.token_id(),
-                            ),
-                        )
-                        .into()],
-                    ),
-                    fee_result,
-                ));
-            }
+            None => owner_id,
         };
 
         Ok((
@@ -293,6 +274,7 @@ impl TokenMintTransitionActionV0 {
             }
         };
 
+        // First, validate that choosing recipient is allowed if a recipient is set
         if !base_action
             .token_configuration()?
             .distribution_rules()
@@ -320,6 +302,8 @@ impl TokenMintTransitionActionV0 {
             ));
         }
 
+        // If no recipient is set, use the default recipient. If no default recipient, use the minter ID
+        // We already validated that the minter is allowed to mint tokens
         let identity_balance_holder_id = match issued_to_identity_id.or_else(|| {
             base_action
                 .data_contract_fetch_info_ref()
@@ -334,29 +318,7 @@ impl TokenMintTransitionActionV0 {
                 })
         }) {
             Some(identity_balance_holder_id) => identity_balance_holder_id,
-            None => {
-                let bump_action =
-                    BumpIdentityDataContractNonceAction::from_borrowed_token_base_transition_action(
-                        &base_action,
-                        owner_id,
-                        0,
-                    );
-                let batched_action =
-                    BatchedTransitionAction::BumpIdentityDataContractNonce(bump_action);
-
-                return Ok((
-                    ConsensusValidationResult::new_with_data_and_errors(
-                        batched_action.into(),
-                        vec![BasicError::DestinationIdentityForTokenMintingNotSetError(
-                            DestinationIdentityForTokenMintingNotSetError::new(
-                                base_action.token_id(),
-                            ),
-                        )
-                        .into()],
-                    ),
-                    fee_result,
-                ));
-            }
+            None => owner_id,
         };
 
         Ok((

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

@@ -66,7 +66,7 @@ use dpp::consensus::basic::document::{ContestedDocumentsTemporarilyNotAllowedErr
 use dpp::consensus::basic::group::GroupActionNotAllowedOnTransitionError;
 use dpp::consensus::basic::identity::{DataContractBoundsNotPresentError, DisablingKeyIdAlsoBeingAddedInSameTransitionError, InvalidIdentityCreditWithdrawalTransitionAmountError, InvalidIdentityUpdateTransitionDisableKeysError, InvalidIdentityUpdateTransitionEmptyError, TooManyMasterPublicKeyError, WithdrawalOutputScriptNotAllowedWhenSigningWithOwnerKeyError};
 use dpp::consensus::basic::overflow_error::OverflowError;
-use dpp::consensus::basic::token::{ChoosingTokenMintRecipientNotAllowedError, ContractHasNoTokensError, DestinationIdentityForTokenMintingNotSetError, InvalidActionIdError, InvalidTokenAmountError, InvalidTokenConfigUpdateNoChangeError, InvalidTokenIdError, InvalidTokenNoteTooBigError, InvalidTokenPositionError, MissingDefaultLocalizationError, TokenTransferToOurselfError};
+use dpp::consensus::basic::token::{ChoosingTokenMintRecipientNotAllowedError, ContractHasNoTokensError, InvalidActionIdError, InvalidTokenAmountError, InvalidTokenConfigUpdateNoChangeError, InvalidTokenIdError, InvalidTokenNoteTooBigError, InvalidTokenPositionError, MissingDefaultLocalizationError, TokenTransferToOurselfError};
 use dpp::consensus::state::data_contract::data_contract_update_action_not_allowed_error::DataContractUpdateActionNotAllowedError;
 use dpp::consensus::state::data_contract::document_type_update_error::DocumentTypeUpdateError;
 use dpp::consensus::state::document::document_contest_currently_locked_error::DocumentContestCurrentlyLockedError;
@@ -677,9 +677,6 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue {
         BasicError::TokenTransferToOurselfError(e) => {
             generic_consensus_error!(TokenTransferToOurselfError, e).into()
         }
-        BasicError::DestinationIdentityForTokenMintingNotSetError(e) => {
-            generic_consensus_error!(DestinationIdentityForTokenMintingNotSetError, e).into()
-        }
         BasicError::ChoosingTokenMintRecipientNotAllowedError(e) => {
             generic_consensus_error!(ChoosingTokenMintRecipientNotAllowedError, e).into()
         }