feat(sdk): improve token state transition functionalities in rs-sdk

packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/accessors.rs

@@ -189,7 +189,7 @@ impl TokenConfigurationV0Getters for TokenConfigurationV0 {
             ),
             (
                 "trade_mode_change_rules",
-                &self.marketplace_rules.trade_mode_change_rules(),
+                self.marketplace_rules.trade_mode_change_rules(),
             ),
             ("manual_minting_rules", &self.manual_minting_rules),
             ("manual_burning_rules", &self.manual_burning_rules),

packages/rs-sdk/src/platform/tokens/mod.rs

@@ -6,3 +6,5 @@ pub mod token_info;
 pub mod token_status;
 /// Token total supply query
 pub mod token_total_supply;
+/// Token state transitions
+pub mod transitions;

packages/rs-sdk/src/platform/tokens/transitions/burn.rs

@@ -0,0 +1,62 @@
+use crate::platform::transition::broadcast::BroadcastStateTransition;
+use crate::platform::transition::fungible_tokens::burn::TokenBurnTransitionBuilder;
+use crate::{Error, Sdk};
+use dpp::balances::credits::TokenAmount;
+use dpp::data_contract::group::GroupSumPower;
+use dpp::document::Document;
+use dpp::group::group_action_status::GroupActionStatus;
+use dpp::identity::signer::Signer;
+use dpp::identity::IdentityPublicKey;
+use dpp::platform_value::Identifier;
+use dpp::state_transition::proof_result::StateTransitionProofResult;
+
+pub enum BurnResult {
+    TokenBalance(Identifier, TokenAmount),
+    HistoricalDocument(Document),
+    GroupActionWithDocument(GroupSumPower, Option<Document>),
+    GroupActionWithBalance(GroupSumPower, GroupActionStatus, Option<TokenAmount>),
+}
+
+impl Sdk {
+    pub async fn token_burn<S: Signer>(
+        &self,
+        burn_tokens_transition_builder: TokenBurnTransitionBuilder<'_>,
+        signing_key: &IdentityPublicKey,
+        signer: &S,
+    ) -> Result<BurnResult, Error> {
+        let platform_version = self.version();
+
+        let state_transition = burn_tokens_transition_builder
+            .sign(self, signing_key, signer, platform_version, None)
+            .await?;
+
+        let proof_result = state_transition
+            .broadcast_and_wait::<StateTransitionProofResult>(self, None)
+            .await?;
+
+        match proof_result {
+            StateTransitionProofResult::VerifiedTokenBalance(owner_id, remaining_balance) => {
+                Ok(BurnResult::TokenBalance(owner_id, remaining_balance))
+            }
+            StateTransitionProofResult::VerifiedTokenActionWithDocument(doc) => {
+                // This means the token keeps burning history
+                Ok(BurnResult::HistoricalDocument(doc))
+            }
+            StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, doc) => {
+                // This means it's a group action with history
+                Ok(BurnResult::GroupActionWithDocument(power, doc))
+            }
+            StateTransitionProofResult::VerifiedTokenGroupActionWithTokenBalance(power, status, balance) => {
+                // Group action without history
+                Ok(BurnResult::GroupActionWithBalance(power, status, balance))
+            }
+            _ => Err(Error::DriveProofError(
+                drive::error::proof::ProofError::UnexpectedResultProof(
+                    "Expected VerifiedTokenBalance, VerifiedTokenActionWithDocument, VerifiedTokenGroupActionWithDocument, or VerifiedTokenGroupActionWithTokenBalance for burn transition".to_string(),
+                ),
+                vec![],
+                Default::default(),
+            )),
+        }
+    }
+}

packages/rs-sdk/src/platform/tokens/transitions/claim.rs

@@ -0,0 +1,57 @@
+use crate::platform::transition::broadcast::BroadcastStateTransition;
+use crate::platform::transition::fungible_tokens::claim::TokenClaimTransitionBuilder;
+use crate::{Error, Sdk};
+use dpp::data_contract::group::GroupSumPower;
+use dpp::document::Document;
+use dpp::identity::signer::Signer;
+use dpp::identity::IdentityPublicKey;
+use dpp::state_transition::proof_result::StateTransitionProofResult;
+
+pub enum ClaimResult {
+    Document(Document),
+    GroupActionWithDocument(GroupSumPower, Document),
+}
+
+impl Sdk {
+    pub async fn token_claim<S: Signer>(
+        &self,
+        claim_tokens_transition_builder: TokenClaimTransitionBuilder<'_>,
+        signing_key: &IdentityPublicKey,
+        signer: &S,
+    ) -> Result<ClaimResult, Error> {
+        let platform_version = self.version();
+
+        let state_transition = claim_tokens_transition_builder
+            .sign(self, signing_key, signer, platform_version, None)
+            .await?;
+
+        let proof_result = state_transition
+            .broadcast_and_wait::<StateTransitionProofResult>(self, None)
+            .await?;
+
+        match proof_result {
+            StateTransitionProofResult::VerifiedTokenActionWithDocument(document) => {
+                Ok(ClaimResult::Document(document))
+            }
+            StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, Some(document)) => {
+                Ok(ClaimResult::GroupActionWithDocument(power, document))
+            }
+            StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(_, None) => {
+                Err(Error::DriveProofError(
+                    drive::error::proof::ProofError::IncorrectProof(
+                        "Expected document in group action result".to_string(),
+                    ),
+                    vec![],
+                    Default::default(),
+                ))
+            }
+            _ => Err(Error::DriveProofError(
+                drive::error::proof::ProofError::UnexpectedResultProof(
+                    "Expected VerifiedTokenActionWithDocument or VerifiedTokenGroupActionWithDocument for claim transition".to_string(),
+                ),
+                vec![],
+                Default::default(),
+            )),
+        }
+    }
+}

packages/rs-sdk/src/platform/tokens/transitions/config_update.rs

@@ -0,0 +1,58 @@
+use crate::platform::transition::broadcast::BroadcastStateTransition;
+use crate::platform::transition::fungible_tokens::config_update::TokenConfigUpdateTransitionBuilder;
+use crate::{Error, Sdk};
+use dpp::data_contract::group::GroupSumPower;
+use dpp::document::Document;
+use dpp::identity::signer::Signer;
+use dpp::identity::IdentityPublicKey;
+use dpp::state_transition::proof_result::StateTransitionProofResult;
+
+pub enum ConfigUpdateResult {
+    Document(Document),
+    GroupActionWithDocument(GroupSumPower, Document),
+}
+
+impl Sdk {
+    pub async fn token_update_contract_token_configuration<S: Signer>(
+        &self,
+        config_update_transition_builder: TokenConfigUpdateTransitionBuilder<'_>,
+        signing_key: &IdentityPublicKey,
+        signer: &S,
+    ) -> Result<ConfigUpdateResult, Error> {
+        let platform_version = self.version();
+
+        let state_transition = config_update_transition_builder
+            .sign(self, signing_key, signer, platform_version, None)
+            .await?;
+
+        let proof_result = state_transition
+            .broadcast_and_wait::<StateTransitionProofResult>(self, None)
+            .await?;
+
+        match proof_result {
+            StateTransitionProofResult::VerifiedTokenActionWithDocument(document) => {
+                Ok(ConfigUpdateResult::Document(document))
+            }
+            StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, Some(document)) => {
+                Ok(ConfigUpdateResult::GroupActionWithDocument(power, document))
+            }
+            StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(_, None) => {
+                Err(Error::DriveProofError(
+                    drive::error::proof::ProofError::IncorrectProof(
+                        "Expected document in group action result".to_string(),
+                    ),
+                    vec![],
+                    Default::default(),
+                ))
+            }
+            _ => Err(Error::DriveProofError(
+                drive::error::proof::ProofError::UnexpectedResultProof(
+                    "Expected VerifiedTokenActionWithDocument or VerifiedTokenGroupActionWithDocument for config update transition"
+                        .to_string(),
+                ),
+                vec![],
+                Default::default(),
+            )),
+        }
+    }
+}

packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs

@@ -0,0 +1,50 @@
+use crate::platform::transition::broadcast::BroadcastStateTransition;
+use crate::platform::transition::fungible_tokens::destroy::TokenDestroyFrozenFundsTransitionBuilder;
+use crate::{Error, Sdk};
+use dpp::data_contract::group::GroupSumPower;
+use dpp::document::Document;
+use dpp::identity::signer::Signer;
+use dpp::identity::IdentityPublicKey;
+use dpp::state_transition::proof_result::StateTransitionProofResult;
+
+pub enum DestroyFrozenFundsResult {
+    HistoricalDocument(Document),
+    GroupActionWithDocument(GroupSumPower, Option<Document>),
+}
+
+impl Sdk {
+    pub async fn token_destroy_frozen_funds<S: Signer>(
+        &self,
+        destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder<'_>,
+        signing_key: &IdentityPublicKey,
+        signer: &S,
+    ) -> Result<DestroyFrozenFundsResult, Error> {
+        let platform_version = self.version();
+
+        let state_transition = destroy_frozen_funds_transition_builder
+            .sign(self, signing_key, signer, platform_version, None)
+            .await?;
+
+        let proof_result = state_transition
+            .broadcast_and_wait::<StateTransitionProofResult>(self, None)
+            .await?;
+
+        match proof_result {
+            StateTransitionProofResult::VerifiedTokenActionWithDocument(doc) => {
+                // DestroyFrozenFunds always keeps history
+                Ok(DestroyFrozenFundsResult::HistoricalDocument(doc))
+            }
+            StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, doc) => {
+                // Group action with history
+                Ok(DestroyFrozenFundsResult::GroupActionWithDocument(power, doc))
+            }
+            _ => Err(Error::DriveProofError(
+                drive::error::proof::ProofError::UnexpectedResultProof(
+                    "Expected VerifiedTokenActionWithDocument or VerifiedTokenGroupActionWithDocument for destroy frozen funds transition".to_string(),
+                ),
+                vec![],
+                Default::default(),
+            )),
+        }
+    }
+}

packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs

@@ -0,0 +1,55 @@
+use crate::platform::transition::broadcast::BroadcastStateTransition;
+use crate::platform::transition::fungible_tokens::purchase::TokenDirectPurchaseTransitionBuilder;
+use crate::{Error, Sdk};
+use dpp::balances::credits::TokenAmount;
+use dpp::identity::signer::Signer;
+use dpp::identity::IdentityPublicKey;
+use dpp::platform_value::Identifier;
+use dpp::state_transition::proof_result::StateTransitionProofResult;
+
+impl Sdk {
+    pub async fn token_purchase<S: Signer>(
+        &self,
+        purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder<'_>,
+        signing_key: &IdentityPublicKey,
+        signer: &S,
+    ) -> Result<DirectPurchaseResult, Error> {
+        let platform_version = self.version();
+
+        let state_transition = purchase_tokens_transition_builder
+            .sign(self, signing_key, signer, platform_version, None)
+            .await?;
+
+        let proof_result = state_transition
+            .broadcast_and_wait::<StateTransitionProofResult>(self, None)
+            .await?;
+
+        match proof_result {
+            StateTransitionProofResult::VerifiedTokenBalance(owner_id, balance) => {
+                Ok(DirectPurchaseResult::TokenBalance(owner_id, balance))
+            }
+            StateTransitionProofResult::VerifiedTokenActionWithDocument(doc) => {
+                Ok(DirectPurchaseResult::HistoricalDocument(doc))
+            }
+            StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, doc) => {
+                Ok(DirectPurchaseResult::GroupActionWithDocument(power, doc))
+            }
+            _ => Err(Error::DriveProofError(
+                drive::error::proof::ProofError::UnexpectedResultProof(
+                    "Expected VerifiedTokenBalance, VerifiedTokenActionWithDocument, or VerifiedTokenGroupActionWithDocument for direct purchase transition".to_string(),
+                ),
+                vec![],
+                Default::default(),
+            )),
+        }
+    }
+}
+
+pub enum DirectPurchaseResult {
+    TokenBalance(Identifier, TokenAmount),
+    HistoricalDocument(dpp::document::Document),
+    GroupActionWithDocument(
+        dpp::data_contract::group::GroupSumPower,
+        Option<dpp::document::Document>,
+    ),
+}

packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs

@@ -0,0 +1,49 @@
+use crate::platform::transition::broadcast::BroadcastStateTransition;
+use crate::platform::transition::fungible_tokens::emergency_action::TokenEmergencyActionTransitionBuilder;
+use crate::{Error, Sdk};
+use dpp::data_contract::group::GroupSumPower;
+use dpp::document::Document;
+use dpp::identity::signer::Signer;
+use dpp::identity::IdentityPublicKey;
+use dpp::state_transition::proof_result::StateTransitionProofResult;
+
+impl Sdk {
+    pub async fn token_emergency_action<S: Signer>(
+        &self,
+        emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder<'_>,
+        signing_key: &IdentityPublicKey,
+        signer: &S,
+    ) -> Result<EmergencyActionResult, Error> {
+        let platform_version = self.version();
+
+        let state_transition = emergency_action_transition_builder
+            .sign(self, signing_key, signer, platform_version, None)
+            .await?;
+
+        let proof_result = state_transition
+            .broadcast_and_wait::<StateTransitionProofResult>(self, None)
+            .await?;
+
+        match proof_result {
+            StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(
+                group_power,
+                document,
+            ) => Ok(EmergencyActionResult::GroupActionWithDocument(
+                group_power,
+                document,
+            )),
+            _ => Err(Error::DriveProofError(
+                drive::error::proof::ProofError::UnexpectedResultProof(
+                    "Expected VerifiedTokenGroupActionWithDocument for emergency action transition"
+                        .to_string(),
+                ),
+                vec![],
+                Default::default(),
+            )),
+        }
+    }
+}
+
+pub enum EmergencyActionResult {
+    GroupActionWithDocument(GroupSumPower, Option<Document>),
+}