From 95d5c59fd658a4b706b4c49a6db803410adc780a Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Tue, 3 Jun 2025 18:51:53 +0200 Subject: [PATCH 1/8] feat: add token state transition functionalities --- packages/rs-sdk/src/platform/tokens/mod.rs | 2 + .../src/platform/tokens/transitions/burn.rs | 62 ++++++++++++++++ .../src/platform/tokens/transitions/claim.rs | 57 +++++++++++++++ .../tokens/transitions/config_update.rs | 58 +++++++++++++++ .../transitions/destroy_frozen_funds.rs | 50 +++++++++++++ .../tokens/transitions/direct_purchase.rs | 52 ++++++++++++++ .../tokens/transitions/emergency_action.rs | 47 +++++++++++++ .../src/platform/tokens/transitions/freeze.rs | 70 +++++++++++++++++++ .../src/platform/tokens/transitions/mint.rs | 62 ++++++++++++++++ .../src/platform/tokens/transitions/mod.rs | 23 ++++++ .../set_price_for_direct_purchase.rs | 59 ++++++++++++++++ .../platform/tokens/transitions/transfer.rs | 55 +++++++++++++++ .../platform/tokens/transitions/unfreeze.rs | 70 +++++++++++++++++++ 13 files changed, 667 insertions(+) create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/burn.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/claim.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/config_update.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/freeze.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/mint.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/mod.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/transfer.rs create mode 100644 packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs diff --git a/packages/rs-sdk/src/platform/tokens/mod.rs b/packages/rs-sdk/src/platform/tokens/mod.rs index fd044283835..04e37531eed 100644 --- a/packages/rs-sdk/src/platform/tokens/mod.rs +++ b/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; diff --git a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs new file mode 100644 index 00000000000..c2dcf3952ff --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs @@ -0,0 +1,62 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::platform_value::Identifier; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::balances::credits::TokenAmount; +use dpp::document::Document; +use dpp::data_contract::group::GroupSumPower; +use dpp::group::group_action_status::GroupActionStatus; +use crate::platform::transition::fungible_tokens::burn::TokenBurnTransitionBuilder; + +pub enum BurnResult { + TokenBalance(Identifier, TokenAmount), + HistoricalDocument(Document), + GroupActionWithDocument(GroupSumPower, Option), + GroupActionWithBalance(GroupSumPower, GroupActionStatus, Option), +} + +impl Sdk { + pub async fn burn_tokens<'a, S: Signer>( + &self, + burn_tokens_transition_builder: TokenBurnTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + 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::(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(), + )), + } + } +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs new file mode 100644 index 00000000000..0ce989e5511 --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs @@ -0,0 +1,57 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::document::Document; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::data_contract::group::GroupSumPower; +use crate::platform::transition::fungible_tokens::claim::TokenClaimTransitionBuilder; + +pub enum ClaimResult { + Document(Document), + GroupActionWithDocument(GroupSumPower, Document), +} + +impl Sdk { + pub async fn claim_tokens<'a, S: Signer>( + &self, + claim_tokens_transition_builder: TokenClaimTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + 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::(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(), + )), + } + } +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs new file mode 100644 index 00000000000..97b3a975ab6 --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs @@ -0,0 +1,58 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::document::Document; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::data_contract::group::GroupSumPower; +use crate::platform::transition::fungible_tokens::config_update::TokenConfigUpdateTransitionBuilder; + +pub enum ConfigUpdateResult { + Document(Document), + GroupActionWithDocument(GroupSumPower, Document), +} + +impl Sdk { + pub async fn update_token_config<'a, S: Signer>( + &self, + config_update_transition_builder: TokenConfigUpdateTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + 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::(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(), + )), + } + } +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs new file mode 100644 index 00000000000..fa1a8968cea --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs @@ -0,0 +1,50 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::document::Document; +use dpp::data_contract::group::GroupSumPower; +use crate::platform::transition::fungible_tokens::destroy::TokenDestroyFrozenFundsTransitionBuilder; + +pub enum DestroyFrozenFundsResult { + HistoricalDocument(Document), + GroupActionWithDocument(GroupSumPower, Option), +} + +impl Sdk { + pub async fn destroy_frozen_funds<'a, S: Signer>( + &self, + destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + 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::(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(), + )), + } + } +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs new file mode 100644 index 00000000000..cd4bad3e544 --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs @@ -0,0 +1,52 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::platform_value::Identifier; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::balances::credits::TokenAmount; +use crate::platform::transition::fungible_tokens::purchase::TokenDirectPurchaseTransitionBuilder; + +impl Sdk { + pub async fn purchase_tokens<'a, S: Signer>( + &self, + purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + 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::(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), +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs new file mode 100644 index 00000000000..b5816a7114a --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs @@ -0,0 +1,47 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::document::Document; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::data_contract::group::GroupSumPower; +use crate::platform::transition::fungible_tokens::emergency_action::TokenEmergencyActionTransitionBuilder; + +impl Sdk { + pub async fn emergency_token_action<'a, S: Signer>( + &self, + emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + 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::(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), +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs new file mode 100644 index 00000000000..d90893a21cd --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs @@ -0,0 +1,70 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::platform_value::Identifier; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::tokens::info::IdentityTokenInfo; +use dpp::document::Document; +use dpp::data_contract::group::GroupSumPower; +use crate::platform::transition::fungible_tokens::freeze::TokenFreezeTransitionBuilder; + +pub enum FreezeResult { + IdentityInfo(Identifier, IdentityTokenInfo), + HistoricalDocument(Document), + GroupActionWithDocument(GroupSumPower, Option), + GroupActionWithIdentityInfo(GroupSumPower, IdentityTokenInfo), +} + +impl Sdk { + pub async fn freeze_tokens<'a, S: Signer>( + &self, + freeze_tokens_transition_builder: TokenFreezeTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + let platform_version = self.version(); + + let state_transition = freeze_tokens_transition_builder + .sign(self, signing_key, signer, &platform_version, None) + .await?; + + let proof_result = state_transition + .broadcast_and_wait::(self, None) + .await?; + + match proof_result { + StateTransitionProofResult::VerifiedTokenIdentityInfo(owner_id_result, info) => { + Ok(FreezeResult::IdentityInfo(owner_id_result, info)) + } + StateTransitionProofResult::VerifiedTokenActionWithDocument(doc) => { + // This means the token keeps freezing history + Ok(FreezeResult::HistoricalDocument(doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, doc) => { + // This means it's a group action with history + Ok(FreezeResult::GroupActionWithDocument(power, doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithTokenIdentityInfo(power, _, Some(info)) => { + // Group action without history + Ok(FreezeResult::GroupActionWithIdentityInfo(power, info)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithTokenIdentityInfo(_, _, None) => { + Err(Error::DriveProofError( + drive::error::proof::ProofError::IncorrectProof( + "Expected token identity info in group action result".to_string(), + ), + vec![], + Default::default(), + )) + } + _ => Err(Error::DriveProofError( + drive::error::proof::ProofError::UnexpectedResultProof( + "Expected VerifiedTokenIdentityInfo, VerifiedTokenActionWithDocument, or VerifiedTokenGroupActionWithTokenIdentityInfo for freeze transition".to_string(), + ), + vec![], + Default::default(), + )), + } + } +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs new file mode 100644 index 00000000000..b6d9fe55810 --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs @@ -0,0 +1,62 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::platform_value::Identifier; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::balances::credits::TokenAmount; +use dpp::document::Document; +use dpp::data_contract::group::GroupSumPower; +use dpp::group::group_action_status::GroupActionStatus; +use crate::platform::transition::fungible_tokens::mint::TokenMintTransitionBuilder; + +pub enum MintResult { + TokenBalance(Identifier, TokenAmount), + HistoricalDocument(Document), + GroupActionWithDocument(GroupSumPower, Option), + GroupActionWithBalance(GroupSumPower, GroupActionStatus, Option), +} + +impl Sdk { + pub async fn mint_tokens<'a, S: Signer>( + &self, + mint_tokens_transition_builder: TokenMintTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + let platform_version = self.version(); + + let state_transition = mint_tokens_transition_builder + .sign(self, signing_key, signer, &platform_version, None) + .await?; + + let proof_result = state_transition + .broadcast_and_wait::(self, None) + .await?; + + match proof_result { + StateTransitionProofResult::VerifiedTokenBalance(recipient_id_result, new_balance) => { + Ok(MintResult::TokenBalance(recipient_id_result, new_balance)) + } + StateTransitionProofResult::VerifiedTokenActionWithDocument(doc) => { + // This means the token keeps minting history + Ok(MintResult::HistoricalDocument(doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, doc) => { + // This means it's a group action with history + Ok(MintResult::GroupActionWithDocument(power, doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithTokenBalance(power, status, balance) => { + // Group action without history + Ok(MintResult::GroupActionWithBalance(power, status, balance)) + } + _ => Err(Error::DriveProofError( + drive::error::proof::ProofError::UnexpectedResultProof( + "Expected VerifiedTokenBalance, VerifiedTokenActionWithDocument, VerifiedTokenGroupActionWithDocument, or VerifiedTokenGroupActionWithTokenBalance for mint transition".to_string(), + ), + vec![], + Default::default(), + )), + } + } +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mod.rs b/packages/rs-sdk/src/platform/tokens/transitions/mod.rs new file mode 100644 index 00000000000..718480a8a34 --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/mod.rs @@ -0,0 +1,23 @@ +pub mod burn; +pub mod claim; +pub mod config_update; +pub mod destroy_frozen_funds; +pub mod direct_purchase; +pub mod emergency_action; +pub mod freeze; +pub mod mint; +pub mod set_price_for_direct_purchase; +pub mod transfer; +pub mod unfreeze; + +pub use burn::BurnResult; +pub use claim::ClaimResult; +pub use config_update::ConfigUpdateResult; +pub use destroy_frozen_funds::DestroyFrozenFundsResult; +pub use direct_purchase::DirectPurchaseResult; +pub use emergency_action::EmergencyActionResult; +pub use freeze::FreezeResult; +pub use mint::MintResult; +pub use set_price_for_direct_purchase::SetPriceResult; +pub use transfer::TransferResult; +pub use unfreeze::UnfreezeResult; \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs new file mode 100644 index 00000000000..0a7febc1631 --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs @@ -0,0 +1,59 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::platform_value::Identifier; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::tokens::token_pricing_schedule::TokenPricingSchedule; +use dpp::document::Document; +use dpp::data_contract::group::GroupSumPower; +use dpp::group::group_action_status::GroupActionStatus; +use crate::platform::transition::fungible_tokens::set_price::TokenChangeDirectPurchasePriceTransitionBuilder; + +pub enum SetPriceResult { + PricingSchedule(Identifier, Option), + HistoricalDocument(Document), + GroupActionWithDocument(GroupSumPower, Option), + GroupActionWithPricingSchedule(GroupSumPower, GroupActionStatus, Option), +} + +impl Sdk { + pub async fn set_token_price_for_direct_purchase<'a, S: Signer>( + &self, + set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + let platform_version = self.version(); + + let state_transition = set_price_transition_builder + .sign(self, signing_key, signer, &platform_version, None) + .await?; + + let proof_result = state_transition + .broadcast_and_wait::(self, None) + .await?; + + match proof_result { + StateTransitionProofResult::VerifiedTokenPricingSchedule(owner_id, schedule) => { + Ok(SetPriceResult::PricingSchedule(owner_id, schedule)) + } + StateTransitionProofResult::VerifiedTokenActionWithDocument(doc) => { + Ok(SetPriceResult::HistoricalDocument(doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, doc) => { + Ok(SetPriceResult::GroupActionWithDocument(power, doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithTokenPricingSchedule(power, status, schedule) => { + Ok(SetPriceResult::GroupActionWithPricingSchedule(power, status, schedule)) + } + _ => Err(Error::DriveProofError( + drive::error::proof::ProofError::UnexpectedResultProof( + "Expected VerifiedTokenPricingSchedule, VerifiedTokenActionWithDocument, VerifiedTokenGroupActionWithDocument, or VerifiedTokenGroupActionWithTokenPricingSchedule for set price transition".to_string(), + ), + vec![], + Default::default(), + )), + } + } +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs new file mode 100644 index 00000000000..eab6877250b --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs @@ -0,0 +1,55 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use std::collections::BTreeMap; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::balances::credits::TokenAmount; +use dpp::platform_value::Identifier; +use dpp::document::Document; +use dpp::data_contract::group::GroupSumPower; +use crate::platform::transition::fungible_tokens::transfer::TokenTransferTransitionBuilder; + +pub enum TransferResult { + IdentitiesBalances(BTreeMap), + HistoricalDocument(Document), + GroupActionWithDocument(GroupSumPower, Option), +} + +impl Sdk { + pub async fn transfer_tokens<'a, S: Signer>( + &self, + transfer_tokens_transition_builder: TokenTransferTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + let platform_version = self.version(); + + let state_transition = transfer_tokens_transition_builder + .sign(self, signing_key, signer, &platform_version, None) + .await?; + + let proof_result = state_transition + .broadcast_and_wait::(self, None) + .await?; + + match proof_result { + StateTransitionProofResult::VerifiedTokenIdentitiesBalances(balances) => { + Ok(TransferResult::IdentitiesBalances(balances)) + } + StateTransitionProofResult::VerifiedTokenActionWithDocument(doc) => { + Ok(TransferResult::HistoricalDocument(doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, doc) => { + Ok(TransferResult::GroupActionWithDocument(power, doc)) + } + _ => Err(Error::DriveProofError( + drive::error::proof::ProofError::UnexpectedResultProof( + "Expected VerifiedTokenIdentitiesBalances, VerifiedTokenActionWithDocument, or VerifiedTokenGroupActionWithDocument for transfer transition".to_string(), + ), + vec![], + Default::default(), + )), + } + } +} \ No newline at end of file diff --git a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs new file mode 100644 index 00000000000..058b1dc9490 --- /dev/null +++ b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs @@ -0,0 +1,70 @@ +use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::{Error, Sdk}; +use dpp::identity::signer::Signer; +use dpp::identity::IdentityPublicKey; +use dpp::platform_value::Identifier; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use dpp::tokens::info::IdentityTokenInfo; +use dpp::document::Document; +use dpp::data_contract::group::GroupSumPower; +use crate::platform::transition::fungible_tokens::unfreeze::TokenUnfreezeTransitionBuilder; + +pub enum UnfreezeResult { + IdentityInfo(Identifier, IdentityTokenInfo), + HistoricalDocument(Document), + GroupActionWithDocument(GroupSumPower, Option), + GroupActionWithIdentityInfo(GroupSumPower, IdentityTokenInfo), +} + +impl Sdk { + pub async fn unfreeze_tokens<'a, S: Signer>( + &self, + unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder<'a>, + signing_key: &IdentityPublicKey, + signer: &S, + ) -> Result { + let platform_version = self.version(); + + let state_transition = unfreeze_tokens_transition_builder + .sign(self, signing_key, signer, &platform_version, None) + .await?; + + let proof_result = state_transition + .broadcast_and_wait::(self, None) + .await?; + + match proof_result { + StateTransitionProofResult::VerifiedTokenIdentityInfo(owner_id_result, info) => { + Ok(UnfreezeResult::IdentityInfo(owner_id_result, info)) + } + StateTransitionProofResult::VerifiedTokenActionWithDocument(doc) => { + // This means the token keeps freezing history + Ok(UnfreezeResult::HistoricalDocument(doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(power, doc) => { + // This means it's a group action with history + Ok(UnfreezeResult::GroupActionWithDocument(power, doc)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithTokenIdentityInfo(power, _, Some(info)) => { + // Group action without history + Ok(UnfreezeResult::GroupActionWithIdentityInfo(power, info)) + } + StateTransitionProofResult::VerifiedTokenGroupActionWithTokenIdentityInfo(_, _, None) => { + Err(Error::DriveProofError( + drive::error::proof::ProofError::IncorrectProof( + "Expected token identity info in group action result".to_string(), + ), + vec![], + Default::default(), + )) + } + _ => Err(Error::DriveProofError( + drive::error::proof::ProofError::UnexpectedResultProof( + "Expected VerifiedTokenIdentityInfo, VerifiedTokenActionWithDocument, or VerifiedTokenGroupActionWithTokenIdentityInfo for unfreeze transition".to_string(), + ), + vec![], + Default::default(), + )), + } + } +} \ No newline at end of file From 605ac58edc6c69115a967beafd7e2c6bf1b25ddc Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Tue, 3 Jun 2025 22:22:39 +0200 Subject: [PATCH 2/8] changed name of functions --- .../src/platform/tokens/transitions/burn.rs | 14 +++++------ .../src/platform/tokens/transitions/claim.rs | 8 +++---- .../tokens/transitions/config_update.rs | 8 +++---- .../transitions/destroy_frozen_funds.rs | 10 ++++---- .../tokens/transitions/direct_purchase.rs | 13 ++++++---- .../tokens/transitions/emergency_action.rs | 24 ++++++++++--------- .../src/platform/tokens/transitions/freeze.rs | 10 ++++---- .../src/platform/tokens/transitions/mint.rs | 14 +++++------ .../src/platform/tokens/transitions/mod.rs | 2 +- .../set_price_for_direct_purchase.rs | 18 ++++++++------ .../platform/tokens/transitions/transfer.rs | 16 ++++++------- .../platform/tokens/transitions/unfreeze.rs | 10 ++++---- 12 files changed, 78 insertions(+), 69 deletions(-) diff --git a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs index c2dcf3952ff..832d0630beb 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs @@ -1,14 +1,14 @@ 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; -use dpp::balances::credits::TokenAmount; -use dpp::document::Document; -use dpp::data_contract::group::GroupSumPower; -use dpp::group::group_action_status::GroupActionStatus; -use crate::platform::transition::fungible_tokens::burn::TokenBurnTransitionBuilder; pub enum BurnResult { TokenBalance(Identifier, TokenAmount), @@ -18,7 +18,7 @@ pub enum BurnResult { } impl Sdk { - pub async fn burn_tokens<'a, S: Signer>( + pub async fn token_burn<'a, S: Signer>( &self, burn_tokens_transition_builder: TokenBurnTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -59,4 +59,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs index 0ce989e5511..80d638a0974 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs @@ -1,11 +1,11 @@ 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; -use dpp::data_contract::group::GroupSumPower; -use crate::platform::transition::fungible_tokens::claim::TokenClaimTransitionBuilder; pub enum ClaimResult { Document(Document), @@ -13,7 +13,7 @@ pub enum ClaimResult { } impl Sdk { - pub async fn claim_tokens<'a, S: Signer>( + pub async fn token_claim<'a, S: Signer>( &self, claim_tokens_transition_builder: TokenClaimTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -54,4 +54,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs index 97b3a975ab6..9c51554c47e 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs @@ -1,11 +1,11 @@ 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; -use dpp::data_contract::group::GroupSumPower; -use crate::platform::transition::fungible_tokens::config_update::TokenConfigUpdateTransitionBuilder; pub enum ConfigUpdateResult { Document(Document), @@ -13,7 +13,7 @@ pub enum ConfigUpdateResult { } impl Sdk { - pub async fn update_token_config<'a, S: Signer>( + pub async fn token_update_contract_token_configuration<'a, S: Signer>( &self, config_update_transition_builder: TokenConfigUpdateTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -55,4 +55,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs index fa1a8968cea..bcc4bc5047f 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs @@ -1,11 +1,11 @@ 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; -use dpp::document::Document; -use dpp::data_contract::group::GroupSumPower; -use crate::platform::transition::fungible_tokens::destroy::TokenDestroyFrozenFundsTransitionBuilder; pub enum DestroyFrozenFundsResult { HistoricalDocument(Document), @@ -13,7 +13,7 @@ pub enum DestroyFrozenFundsResult { } impl Sdk { - pub async fn destroy_frozen_funds<'a, S: Signer>( + pub async fn token_destroy_frozen_funds<'a, S: Signer>( &self, destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -47,4 +47,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs index cd4bad3e544..c6caff6048c 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs @@ -1,14 +1,14 @@ 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; -use dpp::balances::credits::TokenAmount; -use crate::platform::transition::fungible_tokens::purchase::TokenDirectPurchaseTransitionBuilder; impl Sdk { - pub async fn purchase_tokens<'a, S: Signer>( + pub async fn token_purchase<'a, S: Signer>( &self, purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -48,5 +48,8 @@ impl Sdk { pub enum DirectPurchaseResult { TokenBalance(Identifier, TokenAmount), HistoricalDocument(dpp::document::Document), - GroupActionWithDocument(dpp::data_contract::group::GroupSumPower, Option), -} \ No newline at end of file + GroupActionWithDocument( + dpp::data_contract::group::GroupSumPower, + Option, + ), +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs index b5816a7114a..fe5ab8cee55 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs @@ -1,14 +1,14 @@ 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; -use dpp::data_contract::group::GroupSumPower; -use crate::platform::transition::fungible_tokens::emergency_action::TokenEmergencyActionTransitionBuilder; impl Sdk { - pub async fn emergency_token_action<'a, S: Signer>( + pub async fn token_emergency_action<'a, S: Signer>( &self, emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -25,15 +25,17 @@ impl Sdk { .await?; match proof_result { - StateTransitionProofResult::VerifiedTokenGroupActionWithDocument(group_power, document) => { - Ok(EmergencyActionResult::GroupActionWithDocument( - group_power, - document, - )) - } + 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(), + "Expected VerifiedTokenGroupActionWithDocument for emergency action transition" + .to_string(), ), vec![], Default::default(), @@ -44,4 +46,4 @@ impl Sdk { pub enum EmergencyActionResult { GroupActionWithDocument(GroupSumPower, Option), -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs index d90893a21cd..f994548ca9b 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs @@ -1,13 +1,13 @@ use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::platform::transition::fungible_tokens::freeze::TokenFreezeTransitionBuilder; 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::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; use dpp::tokens::info::IdentityTokenInfo; -use dpp::document::Document; -use dpp::data_contract::group::GroupSumPower; -use crate::platform::transition::fungible_tokens::freeze::TokenFreezeTransitionBuilder; pub enum FreezeResult { IdentityInfo(Identifier, IdentityTokenInfo), @@ -17,7 +17,7 @@ pub enum FreezeResult { } impl Sdk { - pub async fn freeze_tokens<'a, S: Signer>( + pub async fn token_freeze<'a, S: Signer>( &self, freeze_tokens_transition_builder: TokenFreezeTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -67,4 +67,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs index b6d9fe55810..8868ccceae1 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs @@ -1,14 +1,14 @@ use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::platform::transition::fungible_tokens::mint::TokenMintTransitionBuilder; 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; -use dpp::balances::credits::TokenAmount; -use dpp::document::Document; -use dpp::data_contract::group::GroupSumPower; -use dpp::group::group_action_status::GroupActionStatus; -use crate::platform::transition::fungible_tokens::mint::TokenMintTransitionBuilder; pub enum MintResult { TokenBalance(Identifier, TokenAmount), @@ -18,7 +18,7 @@ pub enum MintResult { } impl Sdk { - pub async fn mint_tokens<'a, S: Signer>( + pub async fn token_mint<'a, S: Signer>( &self, mint_tokens_transition_builder: TokenMintTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -59,4 +59,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mod.rs b/packages/rs-sdk/src/platform/tokens/transitions/mod.rs index 718480a8a34..45d98001c18 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/mod.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/mod.rs @@ -20,4 +20,4 @@ pub use freeze::FreezeResult; pub use mint::MintResult; pub use set_price_for_direct_purchase::SetPriceResult; pub use transfer::TransferResult; -pub use unfreeze::UnfreezeResult; \ No newline at end of file +pub use unfreeze::UnfreezeResult; diff --git a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs index 0a7febc1631..cb21e50730e 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs @@ -1,24 +1,28 @@ use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::platform::transition::fungible_tokens::set_price::TokenChangeDirectPurchasePriceTransitionBuilder; use crate::{Error, Sdk}; +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; use dpp::tokens::token_pricing_schedule::TokenPricingSchedule; -use dpp::document::Document; -use dpp::data_contract::group::GroupSumPower; -use dpp::group::group_action_status::GroupActionStatus; -use crate::platform::transition::fungible_tokens::set_price::TokenChangeDirectPurchasePriceTransitionBuilder; pub enum SetPriceResult { PricingSchedule(Identifier, Option), HistoricalDocument(Document), GroupActionWithDocument(GroupSumPower, Option), - GroupActionWithPricingSchedule(GroupSumPower, GroupActionStatus, Option), + GroupActionWithPricingSchedule( + GroupSumPower, + GroupActionStatus, + Option, + ), } impl Sdk { - pub async fn set_token_price_for_direct_purchase<'a, S: Signer>( + pub async fn token_set_price_for_direct_purchase<'a, S: Signer>( &self, set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -56,4 +60,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs index eab6877250b..6dc3f286595 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs @@ -1,14 +1,14 @@ use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::platform::transition::fungible_tokens::transfer::TokenTransferTransitionBuilder; use crate::{Error, Sdk}; +use dpp::balances::credits::TokenAmount; +use dpp::data_contract::group::GroupSumPower; +use dpp::document::Document; use dpp::identity::signer::Signer; use dpp::identity::IdentityPublicKey; -use std::collections::BTreeMap; -use dpp::state_transition::proof_result::StateTransitionProofResult; -use dpp::balances::credits::TokenAmount; use dpp::platform_value::Identifier; -use dpp::document::Document; -use dpp::data_contract::group::GroupSumPower; -use crate::platform::transition::fungible_tokens::transfer::TokenTransferTransitionBuilder; +use dpp::state_transition::proof_result::StateTransitionProofResult; +use std::collections::BTreeMap; pub enum TransferResult { IdentitiesBalances(BTreeMap), @@ -17,7 +17,7 @@ pub enum TransferResult { } impl Sdk { - pub async fn transfer_tokens<'a, S: Signer>( + pub async fn token_transfer<'a, S: Signer>( &self, transfer_tokens_transition_builder: TokenTransferTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -52,4 +52,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs index 058b1dc9490..e0fe3685648 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs @@ -1,13 +1,13 @@ use crate::platform::transition::broadcast::BroadcastStateTransition; +use crate::platform::transition::fungible_tokens::unfreeze::TokenUnfreezeTransitionBuilder; 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::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; use dpp::tokens::info::IdentityTokenInfo; -use dpp::document::Document; -use dpp::data_contract::group::GroupSumPower; -use crate::platform::transition::fungible_tokens::unfreeze::TokenUnfreezeTransitionBuilder; pub enum UnfreezeResult { IdentityInfo(Identifier, IdentityTokenInfo), @@ -17,7 +17,7 @@ pub enum UnfreezeResult { } impl Sdk { - pub async fn unfreeze_tokens<'a, S: Signer>( + pub async fn token_unfreeze_identity<'a, S: Signer>( &self, unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder<'a>, signing_key: &IdentityPublicKey, @@ -67,4 +67,4 @@ impl Sdk { )), } } -} \ No newline at end of file +} From 2b6093207ef1c43cf1591f648418056ede46b251 Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Tue, 3 Jun 2025 22:50:45 +0200 Subject: [PATCH 3/8] elided --- packages/rs-sdk/src/platform/tokens/transitions/burn.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/claim.rs | 4 ++-- .../rs-sdk/src/platform/tokens/transitions/config_update.rs | 4 ++-- .../src/platform/tokens/transitions/destroy_frozen_funds.rs | 4 ++-- .../rs-sdk/src/platform/tokens/transitions/direct_purchase.rs | 4 ++-- .../src/platform/tokens/transitions/emergency_action.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/freeze.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/mint.rs | 4 ++-- .../tokens/transitions/set_price_for_direct_purchase.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/transfer.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs | 4 ++-- 11 files changed, 22 insertions(+), 22 deletions(-) diff --git a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs index 832d0630beb..d35c6fae007 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs @@ -18,9 +18,9 @@ pub enum BurnResult { } impl Sdk { - pub async fn token_burn<'a, S: Signer>( + pub async fn token_burn( &self, - burn_tokens_transition_builder: TokenBurnTransitionBuilder<'a>, + burn_tokens_transition_builder: TokenBurnTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs index 80d638a0974..fb671bfe17e 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs @@ -13,9 +13,9 @@ pub enum ClaimResult { } impl Sdk { - pub async fn token_claim<'a, S: Signer>( + pub async fn token_claim( &self, - claim_tokens_transition_builder: TokenClaimTransitionBuilder<'a>, + claim_tokens_transition_builder: TokenClaimTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs index 9c51554c47e..47185acb0f2 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs @@ -13,9 +13,9 @@ pub enum ConfigUpdateResult { } impl Sdk { - pub async fn token_update_contract_token_configuration<'a, S: Signer>( + pub async fn token_update_contract_token_configuration( &self, - config_update_transition_builder: TokenConfigUpdateTransitionBuilder<'a>, + config_update_transition_builder: TokenConfigUpdateTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs index bcc4bc5047f..d9b17320399 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs @@ -13,9 +13,9 @@ pub enum DestroyFrozenFundsResult { } impl Sdk { - pub async fn token_destroy_frozen_funds<'a, S: Signer>( + pub async fn token_destroy_frozen_funds( &self, - destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder<'a>, + destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs index c6caff6048c..e900c8408f8 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs @@ -8,9 +8,9 @@ use dpp::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; impl Sdk { - pub async fn token_purchase<'a, S: Signer>( + pub async fn token_purchase( &self, - purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder<'a>, + purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs index fe5ab8cee55..187fd5dd19a 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs @@ -8,9 +8,9 @@ use dpp::identity::IdentityPublicKey; use dpp::state_transition::proof_result::StateTransitionProofResult; impl Sdk { - pub async fn token_emergency_action<'a, S: Signer>( + pub async fn token_emergency_action( &self, - emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder<'a>, + emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs index f994548ca9b..fa3cc466130 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs @@ -17,9 +17,9 @@ pub enum FreezeResult { } impl Sdk { - pub async fn token_freeze<'a, S: Signer>( + pub async fn token_freeze( &self, - freeze_tokens_transition_builder: TokenFreezeTransitionBuilder<'a>, + freeze_tokens_transition_builder: TokenFreezeTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs index 8868ccceae1..746ab463904 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs @@ -18,9 +18,9 @@ pub enum MintResult { } impl Sdk { - pub async fn token_mint<'a, S: Signer>( + pub async fn token_mint( &self, - mint_tokens_transition_builder: TokenMintTransitionBuilder<'a>, + mint_tokens_transition_builder: TokenMintTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs index cb21e50730e..fe1bfc01fd7 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs @@ -22,9 +22,9 @@ pub enum SetPriceResult { } impl Sdk { - pub async fn token_set_price_for_direct_purchase<'a, S: Signer>( + pub async fn token_set_price_for_direct_purchase( &self, - set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder<'a>, + set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs index 6dc3f286595..5ddfc79f338 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs @@ -17,9 +17,9 @@ pub enum TransferResult { } impl Sdk { - pub async fn token_transfer<'a, S: Signer>( + pub async fn token_transfer( &self, - transfer_tokens_transition_builder: TokenTransferTransitionBuilder<'a>, + transfer_tokens_transition_builder: TokenTransferTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs index e0fe3685648..4a92ef9a7cb 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs @@ -17,9 +17,9 @@ pub enum UnfreezeResult { } impl Sdk { - pub async fn token_unfreeze_identity<'a, S: Signer>( + pub async fn token_unfreeze_identity( &self, - unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder<'a>, + unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { From a1c28df5f97d7513f0ed956278db96e07f444cad Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Tue, 3 Jun 2025 23:13:40 +0200 Subject: [PATCH 4/8] fixes --- .../associated_token/token_configuration/v0/accessors.rs | 2 +- packages/rs-sdk/src/platform/tokens/transitions/burn.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/claim.rs | 4 ++-- .../rs-sdk/src/platform/tokens/transitions/config_update.rs | 4 ++-- .../src/platform/tokens/transitions/destroy_frozen_funds.rs | 4 ++-- .../rs-sdk/src/platform/tokens/transitions/direct_purchase.rs | 4 ++-- .../src/platform/tokens/transitions/emergency_action.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/freeze.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/mint.rs | 4 ++-- .../tokens/transitions/set_price_for_direct_purchase.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/transfer.rs | 4 ++-- packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs | 4 ++-- 12 files changed, 23 insertions(+), 23 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/accessors.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/accessors.rs index 1b2519affab..509889fc541 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/accessors.rs +++ b/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), diff --git a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs index d35c6fae007..6fde16faeab 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs @@ -20,14 +20,14 @@ pub enum BurnResult { impl Sdk { pub async fn token_burn( &self, - burn_tokens_transition_builder: TokenBurnTransitionBuilder, + burn_tokens_transition_builder: TokenBurnTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = burn_tokens_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs index fb671bfe17e..d97b366b2dc 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs @@ -15,14 +15,14 @@ pub enum ClaimResult { impl Sdk { pub async fn token_claim( &self, - claim_tokens_transition_builder: TokenClaimTransitionBuilder, + claim_tokens_transition_builder: TokenClaimTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = claim_tokens_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs index 47185acb0f2..7da334b9fdc 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs @@ -15,14 +15,14 @@ pub enum ConfigUpdateResult { impl Sdk { pub async fn token_update_contract_token_configuration( &self, - config_update_transition_builder: TokenConfigUpdateTransitionBuilder, + config_update_transition_builder: TokenConfigUpdateTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = config_update_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs index d9b17320399..6aad0529688 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs @@ -15,14 +15,14 @@ pub enum DestroyFrozenFundsResult { impl Sdk { pub async fn token_destroy_frozen_funds( &self, - destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder, + destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = destroy_frozen_funds_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs index e900c8408f8..7ea86267192 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs @@ -10,14 +10,14 @@ use dpp::state_transition::proof_result::StateTransitionProofResult; impl Sdk { pub async fn token_purchase( &self, - purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder, + purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = purchase_tokens_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs index 187fd5dd19a..189c1f6f1c2 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs @@ -10,14 +10,14 @@ use dpp::state_transition::proof_result::StateTransitionProofResult; impl Sdk { pub async fn token_emergency_action( &self, - emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder, + emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = emergency_action_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs index fa3cc466130..5a038d84a01 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs @@ -19,14 +19,14 @@ pub enum FreezeResult { impl Sdk { pub async fn token_freeze( &self, - freeze_tokens_transition_builder: TokenFreezeTransitionBuilder, + freeze_tokens_transition_builder: TokenFreezeTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = freeze_tokens_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs index 746ab463904..9ffbf88a90b 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs @@ -20,14 +20,14 @@ pub enum MintResult { impl Sdk { pub async fn token_mint( &self, - mint_tokens_transition_builder: TokenMintTransitionBuilder, + mint_tokens_transition_builder: TokenMintTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = mint_tokens_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs index fe1bfc01fd7..acfe5aa3a34 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs @@ -24,14 +24,14 @@ pub enum SetPriceResult { impl Sdk { pub async fn token_set_price_for_direct_purchase( &self, - set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder, + set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = set_price_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs index 5ddfc79f338..b5482774753 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs @@ -19,14 +19,14 @@ pub enum TransferResult { impl Sdk { pub async fn token_transfer( &self, - transfer_tokens_transition_builder: TokenTransferTransitionBuilder, + transfer_tokens_transition_builder: TokenTransferTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = transfer_tokens_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs index 4a92ef9a7cb..ab3cb9f842c 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs @@ -19,14 +19,14 @@ pub enum UnfreezeResult { impl Sdk { pub async fn token_unfreeze_identity( &self, - unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder, + unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder<'_>, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { let platform_version = self.version(); let state_transition = unfreeze_tokens_transition_builder - .sign(self, signing_key, signer, &platform_version, None) + .sign(self, signing_key, signer, platform_version, None) .await?; let proof_result = state_transition From fda9945f53e2e01a1650d73adbaa695cc2425049 Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Tue, 3 Jun 2025 23:55:15 +0200 Subject: [PATCH 5/8] added documentation --- .../src/platform/tokens/transitions/burn.rs | 38 +++++++++++++ .../src/platform/tokens/transitions/claim.rs | 34 +++++++++++ .../tokens/transitions/config_update.rs | 35 ++++++++++++ .../transitions/destroy_frozen_funds.rs | 33 +++++++++++ .../tokens/transitions/direct_purchase.rs | 56 ++++++++++++++++--- .../tokens/transitions/emergency_action.rs | 42 ++++++++++++-- .../src/platform/tokens/transitions/freeze.rs | 38 +++++++++++++ .../src/platform/tokens/transitions/mint.rs | 37 ++++++++++++ .../src/platform/tokens/transitions/mod.rs | 27 +++++++++ .../set_price_for_direct_purchase.rs | 38 +++++++++++++ .../platform/tokens/transitions/transfer.rs | 36 ++++++++++++ .../platform/tokens/transitions/unfreeze.rs | 37 ++++++++++++ 12 files changed, 438 insertions(+), 13 deletions(-) diff --git a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs index 6fde16faeab..352ca7deb89 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs @@ -1,3 +1,8 @@ +//! Token burning operations for the Dash Platform SDK. +//! +//! This module provides functionality to permanently remove tokens from +//! circulation by burning them. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::burn::TokenBurnTransitionBuilder; use crate::{Error, Sdk}; @@ -10,14 +15,47 @@ use dpp::identity::IdentityPublicKey; use dpp::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; +/// Result types returned from burning token operations. +/// +/// This enum represents the different possible outcomes when burning tokens, +/// depending on the token configuration and whether it's a group action. pub enum BurnResult { + /// Standard burn result containing owner ID and remaining balance. TokenBalance(Identifier, TokenAmount), + /// Burn result with historical tracking via document storage. HistoricalDocument(Document), + /// Group-based burn action with optional document for history. GroupActionWithDocument(GroupSumPower, Option), + /// Group-based burn action with balance and status information. GroupActionWithBalance(GroupSumPower, GroupActionStatus, Option), } impl Sdk { + /// Burns tokens to permanently remove them from circulation. + /// + /// This method broadcasts a burn transition to destroy a specified amount + /// of tokens. The result varies based on token configuration: + /// - Standard tokens return the owner's remaining balance + /// - Tokens with history tracking return documents + /// - Group-managed tokens include group power and action status + /// + /// # Arguments + /// + /// * `burn_tokens_transition_builder` - Builder containing burn parameters including amount + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `BurnResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type + /// - Insufficient token balance for burning pub async fn token_burn( &self, burn_tokens_transition_builder: TokenBurnTransitionBuilder<'_>, diff --git a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs index d97b366b2dc..4484e0dd793 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs @@ -1,3 +1,8 @@ +//! Token claiming operations for the Dash Platform SDK. +//! +//! This module provides functionality to claim ownership of tokens that have +//! been allocated or made available for claiming. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::claim::TokenClaimTransitionBuilder; use crate::{Error, Sdk}; @@ -7,12 +12,41 @@ use dpp::identity::signer::Signer; use dpp::identity::IdentityPublicKey; use dpp::state_transition::proof_result::StateTransitionProofResult; +/// Result types returned from claiming token operations. +/// +/// This enum represents the different possible outcomes when claiming tokens, +/// depending on whether it's a standard claim or a group action. pub enum ClaimResult { + /// Standard claim result containing the claim document. Document(Document), + /// Group-based claim action with document and group power information. GroupActionWithDocument(GroupSumPower, Document), } impl Sdk { + /// Claims tokens for a specific identity. + /// + /// This method broadcasts a claim transition to acquire ownership of tokens + /// that have been allocated or made available for claiming. The result + /// includes a document that records the claim details. + /// + /// # Arguments + /// + /// * `claim_tokens_transition_builder` - Builder containing claim parameters + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `ClaimResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type + /// - A group action result is missing the expected document pub async fn token_claim( &self, claim_tokens_transition_builder: TokenClaimTransitionBuilder<'_>, diff --git a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs index 7da334b9fdc..8b1f8069530 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs @@ -1,3 +1,8 @@ +//! Token configuration update operations for the Dash Platform SDK. +//! +//! This module provides functionality to update token contract configuration +//! settings after initial deployment. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::config_update::TokenConfigUpdateTransitionBuilder; use crate::{Error, Sdk}; @@ -7,12 +12,42 @@ use dpp::identity::signer::Signer; use dpp::identity::IdentityPublicKey; use dpp::state_transition::proof_result::StateTransitionProofResult; +/// Result types returned from token configuration update operations. +/// +/// This enum represents the different possible outcomes when updating token +/// configuration, always returning a document with the updated settings. pub enum ConfigUpdateResult { + /// Standard configuration update result containing the updated configuration document. Document(Document), + /// Group-based configuration update action with document and group power information. GroupActionWithDocument(GroupSumPower, Document), } impl Sdk { + /// Updates the configuration of a token contract. + /// + /// This method broadcasts a configuration update transition to modify token + /// settings such as minting rules, transfer restrictions, or other contract + /// parameters. The result always includes a document with the updated + /// configuration details. + /// + /// # Arguments + /// + /// * `config_update_transition_builder` - Builder containing configuration update parameters + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `ConfigUpdateResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type + /// - A group action result is missing the expected document pub async fn token_update_contract_token_configuration( &self, config_update_transition_builder: TokenConfigUpdateTransitionBuilder<'_>, diff --git a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs index 6aad0529688..b181a3eeac7 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs @@ -1,3 +1,8 @@ +//! Token frozen funds destruction operations for the Dash Platform SDK. +//! +//! This module provides functionality to permanently destroy frozen tokens, +//! removing them from circulation entirely. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::destroy::TokenDestroyFrozenFundsTransitionBuilder; use crate::{Error, Sdk}; @@ -7,12 +12,40 @@ use dpp::identity::signer::Signer; use dpp::identity::IdentityPublicKey; use dpp::state_transition::proof_result::StateTransitionProofResult; +/// Result types returned from destroying frozen funds operations. +/// +/// This enum represents the different possible outcomes when destroying frozen funds, +/// always including historical tracking. pub enum DestroyFrozenFundsResult { + /// Destruction result with historical tracking via document storage. HistoricalDocument(Document), + /// Group-based destruction action with optional document for history. GroupActionWithDocument(GroupSumPower, Option), } impl Sdk { + /// Destroys frozen tokens permanently. + /// + /// This method broadcasts a destroy frozen funds transition to permanently + /// remove frozen tokens from circulation. This operation always maintains + /// a historical record of the destruction. + /// + /// # Arguments + /// + /// * `destroy_frozen_funds_transition_builder` - Builder containing destruction parameters + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `DestroyFrozenFundsResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type pub async fn token_destroy_frozen_funds( &self, destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder<'_>, diff --git a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs index 7ea86267192..26c5a09e378 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs @@ -1,3 +1,8 @@ +//! Direct token purchase operations for the Dash Platform SDK. +//! +//! This module provides functionality to purchase tokens directly at +//! previously set prices. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::purchase::TokenDirectPurchaseTransitionBuilder; use crate::{Error, Sdk}; @@ -7,7 +12,49 @@ use dpp::identity::IdentityPublicKey; use dpp::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; +/// Result types returned from direct token purchase operations. +/// +/// This enum represents the different possible outcomes when purchasing tokens, +/// depending on the token configuration and whether it's a group action. +pub enum DirectPurchaseResult { + /// Standard purchase result containing purchaser ID and new balance. + TokenBalance(Identifier, TokenAmount), + /// Purchase result with historical tracking via document storage. + HistoricalDocument(dpp::document::Document), + /// Group-based purchase action with optional document for history. + GroupActionWithDocument( + dpp::data_contract::group::GroupSumPower, + Option, + ), +} + impl Sdk { + /// Purchases tokens directly at the configured price. + /// + /// This method broadcasts a direct purchase transition to buy tokens at + /// the price set by the token owner. The purchase uses platform credits + /// as payment. The result varies based on token configuration: + /// - Standard tokens return the purchaser's new balance + /// - Tokens with history tracking return documents + /// - Group-managed tokens include group power information + /// + /// # Arguments + /// + /// * `purchase_tokens_transition_builder` - Builder containing purchase parameters including amount + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `DirectPurchaseResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type + /// - Insufficient credits for the purchase pub async fn token_purchase( &self, purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder<'_>, @@ -44,12 +91,3 @@ impl Sdk { } } } - -pub enum DirectPurchaseResult { - TokenBalance(Identifier, TokenAmount), - HistoricalDocument(dpp::document::Document), - GroupActionWithDocument( - dpp::data_contract::group::GroupSumPower, - Option, - ), -} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs index 189c1f6f1c2..e0a017e5749 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs @@ -1,3 +1,8 @@ +//! Emergency action operations for token management. +//! +//! This module provides functionality for executing emergency actions on tokens, +//! typically requiring group authorization for critical interventions. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::emergency_action::TokenEmergencyActionTransitionBuilder; use crate::{Error, Sdk}; @@ -7,7 +12,40 @@ use dpp::identity::signer::Signer; use dpp::identity::IdentityPublicKey; use dpp::state_transition::proof_result::StateTransitionProofResult; +/// Result type returned from emergency action operations. +/// +/// Emergency actions always require group authorization and may include +/// a document recording the action details. +pub enum EmergencyActionResult { + /// Emergency action result with group power and optional document for history. + GroupActionWithDocument(GroupSumPower, Option), +} + impl Sdk { + /// Executes an emergency action on a token contract. + /// + /// This method broadcasts an emergency action transition for critical token + /// management operations that require group authorization. Emergency actions + /// are typically used for scenarios like halting trading, recovering from + /// critical bugs, or other urgent interventions. + /// + /// # Arguments + /// + /// * `emergency_action_transition_builder` - Builder containing emergency action parameters + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing an `EmergencyActionResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type + /// - The group authorization is insufficient pub async fn token_emergency_action( &self, emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder<'_>, @@ -43,7 +81,3 @@ impl Sdk { } } } - -pub enum EmergencyActionResult { - GroupActionWithDocument(GroupSumPower, Option), -} diff --git a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs index 5a038d84a01..339c6b8ba67 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs @@ -1,3 +1,8 @@ +//! Token freezing operations for the Dash Platform SDK. +//! +//! This module provides functionality to freeze tokens, temporarily preventing +//! their transfer or use until they are unfrozen. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::freeze::TokenFreezeTransitionBuilder; use crate::{Error, Sdk}; @@ -9,14 +14,47 @@ use dpp::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; use dpp::tokens::info::IdentityTokenInfo; +/// Result types returned from freezing token operations. +/// +/// This enum represents the different possible outcomes when freezing tokens, +/// depending on the token configuration and whether it's a group action. pub enum FreezeResult { + /// Standard freeze result containing identity and token information. IdentityInfo(Identifier, IdentityTokenInfo), + /// Freeze result with historical tracking via document storage. HistoricalDocument(Document), + /// Group-based freeze action with optional document for history. GroupActionWithDocument(GroupSumPower, Option), + /// Group-based freeze action with identity token information. GroupActionWithIdentityInfo(GroupSumPower, IdentityTokenInfo), } impl Sdk { + /// Freezes tokens for a specific identity. + /// + /// This method broadcasts a freeze transition to temporarily lock tokens, + /// preventing their transfer until they are unfrozen. The result varies + /// based on token configuration: + /// - Standard tokens return identity info + /// - Tokens with history tracking return documents + /// - Group-managed tokens include group power information + /// + /// # Arguments + /// + /// * `freeze_tokens_transition_builder` - Builder containing freeze parameters + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `FreezeResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type pub async fn token_freeze( &self, freeze_tokens_transition_builder: TokenFreezeTransitionBuilder<'_>, diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs index 9ffbf88a90b..8564f7c5b4d 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs @@ -1,3 +1,8 @@ +//! Token minting operations for the Dash Platform SDK. +//! +//! This module provides functionality to mint new tokens, increasing the +//! total supply of a token according to its configured minting rules. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::mint::TokenMintTransitionBuilder; use crate::{Error, Sdk}; @@ -10,14 +15,46 @@ use dpp::identity::IdentityPublicKey; use dpp::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; +/// Result types returned from minting token operations. +/// +/// This enum represents the different possible outcomes when minting tokens, +/// depending on the token configuration and whether it's a group action. pub enum MintResult { + /// Standard mint result containing recipient identity and new balance. TokenBalance(Identifier, TokenAmount), + /// Mint result with historical tracking via document storage. HistoricalDocument(Document), + /// Group-based mint action with optional document for history. GroupActionWithDocument(GroupSumPower, Option), + /// Group-based mint action with balance and status information. GroupActionWithBalance(GroupSumPower, GroupActionStatus, Option), } impl Sdk { + /// Mints new tokens according to the token's configuration. + /// + /// This method broadcasts a mint transition to create new tokens and allocate + /// them to the specified recipient. The result varies based on token configuration: + /// - Standard tokens return the recipient's new balance + /// - Tokens with history tracking return documents + /// - Group-managed tokens include group power and action status + /// + /// # Arguments + /// + /// * `mint_tokens_transition_builder` - Builder containing mint parameters including amount and recipient + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `MintResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type pub async fn token_mint( &self, mint_tokens_transition_builder: TokenMintTransitionBuilder<'_>, diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mod.rs b/packages/rs-sdk/src/platform/tokens/transitions/mod.rs index 45d98001c18..f5c0a927ea1 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/mod.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/mod.rs @@ -1,13 +1,40 @@ +//! Token state transition modules for the Dash Platform SDK. +//! +//! This module provides various token state transitions that allow for managing +//! fungible tokens on the Dash Platform. Each submodule implements a specific +//! type of token operation. + +/// Token burning operations for permanently removing tokens from circulation. pub mod burn; + +/// Token claiming operations for acquiring ownership of unclaimed tokens. pub mod claim; + +/// Token configuration updates for modifying token contract settings. pub mod config_update; + +/// Operations for destroying frozen token funds. pub mod destroy_frozen_funds; + +/// Direct token purchasing functionality for buying tokens at set prices. pub mod direct_purchase; + +/// Emergency action operations for critical token management scenarios. pub mod emergency_action; + +/// Token freezing operations to temporarily lock token transfers. pub mod freeze; + +/// Token minting operations for creating new tokens. pub mod mint; + +/// Price setting operations for tokens available for direct purchase. pub mod set_price_for_direct_purchase; + +/// Token transfer operations between identities. pub mod transfer; + +/// Token unfreezing operations to restore transfer capabilities. pub mod unfreeze; pub use burn::BurnResult; diff --git a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs index acfe5aa3a34..40277dfa7fb 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs @@ -1,3 +1,8 @@ +//! Token price setting operations for direct purchase functionality. +//! +//! This module provides functionality to set or update pricing schedules +//! for tokens that can be purchased directly. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::set_price::TokenChangeDirectPurchasePriceTransitionBuilder; use crate::{Error, Sdk}; @@ -10,10 +15,18 @@ use dpp::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; use dpp::tokens::token_pricing_schedule::TokenPricingSchedule; +/// Result types returned from setting token price operations. +/// +/// This enum represents the different possible outcomes when setting token prices, +/// depending on the token configuration and whether it's a group action. pub enum SetPriceResult { + /// Standard price setting result containing owner ID and pricing schedule. PricingSchedule(Identifier, Option), + /// Price setting result with historical tracking via document storage. HistoricalDocument(Document), + /// Group-based price setting action with optional document for history. GroupActionWithDocument(GroupSumPower, Option), + /// Group-based price setting action with pricing schedule and status. GroupActionWithPricingSchedule( GroupSumPower, GroupActionStatus, @@ -22,6 +35,31 @@ pub enum SetPriceResult { } impl Sdk { + /// Sets or updates the pricing schedule for direct token purchases. + /// + /// This method broadcasts a set price transition to define how tokens can be + /// purchased directly. The pricing schedule can include fixed prices or + /// dynamic pricing rules. The result varies based on token configuration: + /// - Standard tokens return the pricing schedule + /// - Tokens with history tracking return documents + /// - Group-managed tokens include group power and action status + /// + /// # Arguments + /// + /// * `set_price_transition_builder` - Builder containing pricing parameters + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `SetPriceResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type pub async fn token_set_price_for_direct_purchase( &self, set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder<'_>, diff --git a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs index b5482774753..84e3b147a8a 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs @@ -1,3 +1,8 @@ +//! Token transfer operations for the Dash Platform SDK. +//! +//! This module provides functionality to transfer tokens between identities +//! on the Dash Platform. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::transfer::TokenTransferTransitionBuilder; use crate::{Error, Sdk}; @@ -10,13 +15,44 @@ use dpp::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; use std::collections::BTreeMap; +/// Result types returned from token transfer operations. +/// +/// This enum represents the different possible outcomes when transferring tokens, +/// depending on the token configuration and whether it's a group action. pub enum TransferResult { + /// Standard transfer result containing updated balances for affected identities. IdentitiesBalances(BTreeMap), + /// Transfer result with historical tracking via document storage. HistoricalDocument(Document), + /// Group-based transfer action with optional document for history. GroupActionWithDocument(GroupSumPower, Option), } impl Sdk { + /// Transfers tokens from one identity to one or more recipients. + /// + /// This method broadcasts a transfer transition to move tokens between identities. + /// The result varies based on token configuration: + /// - Standard tokens return updated balances for all affected identities + /// - Tokens with history tracking return documents + /// - Group-managed tokens include group power information + /// + /// # Arguments + /// + /// * `transfer_tokens_transition_builder` - Builder containing transfer parameters including recipients and amounts + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing a `TransferResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type pub async fn token_transfer( &self, transfer_tokens_transition_builder: TokenTransferTransitionBuilder<'_>, diff --git a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs index ab3cb9f842c..ca17cead0e6 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs @@ -1,3 +1,8 @@ +//! Token unfreezing operations for the Dash Platform SDK. +//! +//! This module provides functionality to unfreeze previously frozen tokens, +//! restoring their transfer capabilities. + use crate::platform::transition::broadcast::BroadcastStateTransition; use crate::platform::transition::fungible_tokens::unfreeze::TokenUnfreezeTransitionBuilder; use crate::{Error, Sdk}; @@ -9,14 +14,46 @@ use dpp::platform_value::Identifier; use dpp::state_transition::proof_result::StateTransitionProofResult; use dpp::tokens::info::IdentityTokenInfo; +/// Result types returned from unfreezing token operations. +/// +/// This enum represents the different possible outcomes when unfreezing tokens, +/// depending on the token configuration and whether it's a group action. pub enum UnfreezeResult { + /// Standard unfreeze result containing identity and token information. IdentityInfo(Identifier, IdentityTokenInfo), + /// Unfreeze result with historical tracking via document storage. HistoricalDocument(Document), + /// Group-based unfreeze action with optional document for history. GroupActionWithDocument(GroupSumPower, Option), + /// Group-based unfreeze action with identity token information. GroupActionWithIdentityInfo(GroupSumPower, IdentityTokenInfo), } impl Sdk { + /// Unfreezes tokens for a specific identity. + /// + /// This method broadcasts an unfreeze transition to restore transfer capabilities + /// for previously frozen tokens. The result varies based on token configuration: + /// - Standard tokens return identity info + /// - Tokens with history tracking return documents + /// - Group-managed tokens include group power information + /// + /// # Arguments + /// + /// * `unfreeze_tokens_transition_builder` - Builder containing unfreeze parameters + /// * `signing_key` - The identity public key for signing the transition + /// * `signer` - Implementation of the Signer trait for cryptographic signing + /// + /// # Returns + /// + /// Returns a `Result` containing an `UnfreezeResult` on success, or an `Error` on failure. + /// + /// # Errors + /// + /// This function will return an error if: + /// - The transition signing fails + /// - Broadcasting the transition fails + /// - The proof verification returns an unexpected result type pub async fn token_unfreeze_identity( &self, unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder<'_>, From 23ecbc5cf580c7625ec2153219464c50ff602552 Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Wed, 4 Jun 2025 03:33:55 +0200 Subject: [PATCH 6/8] changed builders so they could be more easily passed through ffi --- .../fungible_tokens => tokens/builders}/burn.rs | 11 ++++++----- .../fungible_tokens => tokens/builders}/claim.rs | 11 ++++++----- .../builders}/config_update.rs | 11 ++++++----- .../builders}/destroy.rs | 11 ++++++----- .../builders}/emergency_action.rs | 15 ++++++++------- .../fungible_tokens => tokens/builders}/freeze.rs | 11 ++++++----- .../fungible_tokens => tokens/builders}/mint.rs | 11 ++++++----- .../fungible_tokens => tokens/builders}/mod.rs | 0 .../builders}/purchase.rs | 11 ++++++----- .../builders}/set_price.rs | 11 ++++++----- .../builders}/transfer.rs | 11 ++++++----- .../builders}/unfreeze.rs | 11 ++++++----- packages/rs-sdk/src/platform/tokens/mod.rs | 1 + .../src/platform/tokens/transitions/burn.rs | 4 ++-- .../src/platform/tokens/transitions/claim.rs | 4 ++-- .../platform/tokens/transitions/config_update.rs | 4 ++-- .../tokens/transitions/destroy_frozen_funds.rs | 4 ++-- .../tokens/transitions/direct_purchase.rs | 4 ++-- .../tokens/transitions/emergency_action.rs | 4 ++-- .../src/platform/tokens/transitions/freeze.rs | 4 ++-- .../src/platform/tokens/transitions/mint.rs | 4 ++-- .../transitions/set_price_for_direct_purchase.rs | 4 ++-- .../src/platform/tokens/transitions/transfer.rs | 4 ++-- .../src/platform/tokens/transitions/unfreeze.rs | 4 ++-- packages/rs-sdk/src/platform/transition.rs | 1 - 25 files changed, 91 insertions(+), 80 deletions(-) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/burn.rs (95%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/claim.rs (95%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/config_update.rs (95%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/destroy.rs (95%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/emergency_action.rs (94%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/freeze.rs (95%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/mint.rs (96%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/mod.rs (100%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/purchase.rs (94%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/set_price.rs (95%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/transfer.rs (96%) rename packages/rs-sdk/src/platform/{transition/fungible_tokens => tokens/builders}/unfreeze.rs (95%) diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/burn.rs b/packages/rs-sdk/src/platform/tokens/builders/burn.rs similarity index 95% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/burn.rs rename to packages/rs-sdk/src/platform/tokens/builders/burn.rs index 7b06623b6d1..fec6d03de6c 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/burn.rs @@ -14,10 +14,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token burn transitions -pub struct TokenBurnTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenBurnTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, owner_id: Identifier, amount: TokenAmount, @@ -27,17 +28,17 @@ pub struct TokenBurnTransitionBuilder<'a> { using_group_info: Option, } -impl<'a> TokenBurnTransitionBuilder<'a> { +impl TokenBurnTransitionBuilder { /// Creates a new `TokenBurnTransitionBuilder` /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `owner_id` - The identifier of the token owner /// * `amount` - The amount of tokens to burn pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, owner_id: Identifier, amount: TokenAmount, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/claim.rs b/packages/rs-sdk/src/platform/tokens/builders/claim.rs similarity index 95% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/claim.rs rename to packages/rs-sdk/src/platform/tokens/builders/claim.rs index fee09ec1364..aaef5a0c1bb 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/claim.rs @@ -13,10 +13,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token claim transitions -pub struct TokenClaimTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenClaimTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, owner_id: Identifier, distribution_type: TokenDistributionType, @@ -25,12 +26,12 @@ pub struct TokenClaimTransitionBuilder<'a> { user_fee_increase: Option, } -impl<'a> TokenClaimTransitionBuilder<'a> { +impl TokenClaimTransitionBuilder { /// Start building a claim tokens transition for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `owner_id` - The identifier of the state transition owner /// * `distribution_type` - The token distribution type @@ -39,7 +40,7 @@ impl<'a> TokenClaimTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, owner_id: Identifier, distribution_type: TokenDistributionType, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/config_update.rs b/packages/rs-sdk/src/platform/tokens/builders/config_update.rs similarity index 95% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/config_update.rs rename to packages/rs-sdk/src/platform/tokens/builders/config_update.rs index 41609d437e9..10cc1508acb 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/config_update.rs @@ -14,10 +14,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token config_update transitions -pub struct TokenConfigUpdateTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenConfigUpdateTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, owner_id: Identifier, update_token_configuration_item: TokenConfigurationChangeItem, @@ -27,12 +28,12 @@ pub struct TokenConfigUpdateTransitionBuilder<'a> { user_fee_increase: Option, } -impl<'a> TokenConfigUpdateTransitionBuilder<'a> { +impl TokenConfigUpdateTransitionBuilder { /// Start building a config_update tokens transition for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `owner_id` - The identifier of the state transition owner /// * `update_token_configuration_item` - The token configuration change item @@ -42,7 +43,7 @@ impl<'a> TokenConfigUpdateTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, owner_id: Identifier, update_token_configuration_item: TokenConfigurationChangeItem, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/destroy.rs b/packages/rs-sdk/src/platform/tokens/builders/destroy.rs similarity index 95% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/destroy.rs rename to packages/rs-sdk/src/platform/tokens/builders/destroy.rs index 3eb22186586..947d51c3019 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/destroy.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/destroy.rs @@ -13,10 +13,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token destroy funds transitions -pub struct TokenDestroyFrozenFundsTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenDestroyFrozenFundsTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, frozen_identity_id: Identifier, @@ -26,12 +27,12 @@ pub struct TokenDestroyFrozenFundsTransitionBuilder<'a> { using_group_info: Option, } -impl<'a> TokenDestroyFrozenFundsTransitionBuilder<'a> { +impl TokenDestroyFrozenFundsTransitionBuilder { /// Start building a mint tokens request for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `actor_id` - The identifier of the actor /// * `frozen_identity_id` - The identifier of the frozen identity @@ -40,7 +41,7 @@ impl<'a> TokenDestroyFrozenFundsTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, frozen_identity_id: Identifier, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs similarity index 94% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/emergency_action.rs rename to packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs index 14640c1826c..75abb02dd66 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs @@ -14,10 +14,11 @@ use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::tokens::emergency_action::TokenEmergencyAction; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast emergency action transitions -pub struct TokenEmergencyActionTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenEmergencyActionTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, action: TokenEmergencyAction, @@ -27,12 +28,12 @@ pub struct TokenEmergencyActionTransitionBuilder<'a> { using_group_info: Option, } -impl<'a> TokenEmergencyActionTransitionBuilder<'a> { +impl TokenEmergencyActionTransitionBuilder { /// Start building a pause tokens request for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `actor_id` - The identifier of the actor /// @@ -40,7 +41,7 @@ impl<'a> TokenEmergencyActionTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn pause( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, ) -> Self { @@ -62,7 +63,7 @@ impl<'a> TokenEmergencyActionTransitionBuilder<'a> { /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `actor_id` - The identifier of the actor /// @@ -70,7 +71,7 @@ impl<'a> TokenEmergencyActionTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn resume( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, ) -> Self { diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/freeze.rs b/packages/rs-sdk/src/platform/tokens/builders/freeze.rs similarity index 95% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/freeze.rs rename to packages/rs-sdk/src/platform/tokens/builders/freeze.rs index de1d862e47a..00324b25c25 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/freeze.rs @@ -13,10 +13,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token freeze transitions -pub struct TokenFreezeTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenFreezeTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, freeze_identity_id: Identifier, @@ -26,12 +27,12 @@ pub struct TokenFreezeTransitionBuilder<'a> { using_group_info: Option, } -impl<'a> TokenFreezeTransitionBuilder<'a> { +impl TokenFreezeTransitionBuilder { /// Start building a mint tokens request for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `actor_id` - The identifier of the actor /// * `freeze_identity_id` - The identifier of the frozen identity @@ -40,7 +41,7 @@ impl<'a> TokenFreezeTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, freeze_identity_id: Identifier, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/mint.rs b/packages/rs-sdk/src/platform/tokens/builders/mint.rs similarity index 96% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/mint.rs rename to packages/rs-sdk/src/platform/tokens/builders/mint.rs index 5b66cd5e9eb..87f34e25547 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/mint.rs @@ -14,10 +14,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token mint transitions -pub struct TokenMintTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenMintTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, issuer_id: Identifier, amount: TokenAmount, @@ -28,12 +29,12 @@ pub struct TokenMintTransitionBuilder<'a> { using_group_info: Option, } -impl<'a> TokenMintTransitionBuilder<'a> { +impl TokenMintTransitionBuilder { /// Start building a mint tokens request for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `issuer_id` - The identifier of the issuer /// * `amount` - The amount of tokens to mint @@ -42,7 +43,7 @@ impl<'a> TokenMintTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, issuer_id: Identifier, amount: TokenAmount, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/mod.rs b/packages/rs-sdk/src/platform/tokens/builders/mod.rs similarity index 100% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/mod.rs rename to packages/rs-sdk/src/platform/tokens/builders/mod.rs diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/purchase.rs b/packages/rs-sdk/src/platform/tokens/builders/purchase.rs similarity index 94% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/purchase.rs rename to packages/rs-sdk/src/platform/tokens/builders/purchase.rs index c85ae32144f..fbbfe5db5d0 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/purchase.rs @@ -14,10 +14,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token purchase transitions -pub struct TokenDirectPurchaseTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenDirectPurchaseTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, amount: TokenAmount, @@ -26,12 +27,12 @@ pub struct TokenDirectPurchaseTransitionBuilder<'a> { user_fee_increase: Option, } -impl<'a> TokenDirectPurchaseTransitionBuilder<'a> { +impl TokenDirectPurchaseTransitionBuilder { /// Start building a purchase tokens request for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `issuer_id` - The identifier of the issuer /// * `amount` - The amount of tokens to purchase @@ -40,7 +41,7 @@ impl<'a> TokenDirectPurchaseTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, amount: TokenAmount, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/set_price.rs b/packages/rs-sdk/src/platform/tokens/builders/set_price.rs similarity index 95% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/set_price.rs rename to packages/rs-sdk/src/platform/tokens/builders/set_price.rs index 51ff261d4e7..b0a1533ad64 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/set_price.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/set_price.rs @@ -14,10 +14,11 @@ use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::tokens::token_pricing_schedule::TokenPricingSchedule; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token change direct purchase price transitions -pub struct TokenChangeDirectPurchasePriceTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenChangeDirectPurchasePriceTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, token_pricing_schedule: Option, @@ -27,12 +28,12 @@ pub struct TokenChangeDirectPurchasePriceTransitionBuilder<'a> { using_group_info: Option, } -impl<'a> TokenChangeDirectPurchasePriceTransitionBuilder<'a> { +impl TokenChangeDirectPurchasePriceTransitionBuilder { /// Start building a change direct purchase price tokens request for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `issuer_id` - The identifier of the issuer /// * `amount` - The amount of tokens to change direct purchase price @@ -41,7 +42,7 @@ impl<'a> TokenChangeDirectPurchasePriceTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, issuer_id: Identifier, token_pricing_schedule: Option, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/transfer.rs b/packages/rs-sdk/src/platform/tokens/builders/transfer.rs similarity index 96% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/transfer.rs rename to packages/rs-sdk/src/platform/tokens/builders/transfer.rs index 372eda2af43..6fc489ad386 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/transfer.rs @@ -13,10 +13,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::{calculate_token_id, PrivateEncryptedNote, SharedEncryptedNote}; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token transfer transitions -pub struct TokenTransferTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenTransferTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, issuer_id: Identifier, amount: TokenAmount, @@ -28,12 +29,12 @@ pub struct TokenTransferTransitionBuilder<'a> { user_fee_increase: Option, } -impl<'a> TokenTransferTransitionBuilder<'a> { +impl TokenTransferTransitionBuilder { /// Start building a mint tokens request for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `sender_id` - The identifier of the sender /// * `recipient_id` - The identifier of the recipient @@ -43,7 +44,7 @@ impl<'a> TokenTransferTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, sender_id: Identifier, recipient_id: Identifier, diff --git a/packages/rs-sdk/src/platform/transition/fungible_tokens/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs similarity index 95% rename from packages/rs-sdk/src/platform/transition/fungible_tokens/unfreeze.rs rename to packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs index 7f87891110b..96e01e9ca4d 100644 --- a/packages/rs-sdk/src/platform/transition/fungible_tokens/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs @@ -13,10 +13,11 @@ use dpp::state_transition::batch_transition::BatchTransition; use dpp::state_transition::StateTransition; use dpp::tokens::calculate_token_id; use dpp::version::PlatformVersion; +use std::sync::Arc; /// A builder to configure and broadcast token unfreeze transitions -pub struct TokenUnfreezeTransitionBuilder<'a> { - data_contract: &'a DataContract, +pub struct TokenUnfreezeTransitionBuilder { + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, unfreeze_identity_id: Identifier, @@ -26,12 +27,12 @@ pub struct TokenUnfreezeTransitionBuilder<'a> { using_group_info: Option, } -impl<'a> TokenUnfreezeTransitionBuilder<'a> { +impl TokenUnfreezeTransitionBuilder { /// Start building a mint tokens request for the provided DataContract. /// /// # Arguments /// - /// * `data_contract` - A reference to the data contract + /// * `data_contract` - An Arc to the data contract /// * `token_position` - The position of the token in the contract /// * `actor_id` - The identifier of the actor /// * `unfreeze_identity_id` - The identifier of the identity to unfreeze @@ -40,7 +41,7 @@ impl<'a> TokenUnfreezeTransitionBuilder<'a> { /// /// * `Self` - The new builder instance pub fn new( - data_contract: &'a DataContract, + data_contract: Arc, token_position: TokenContractPosition, actor_id: Identifier, unfreeze_identity_id: Identifier, diff --git a/packages/rs-sdk/src/platform/tokens/mod.rs b/packages/rs-sdk/src/platform/tokens/mod.rs index 04e37531eed..f6950b3d815 100644 --- a/packages/rs-sdk/src/platform/tokens/mod.rs +++ b/packages/rs-sdk/src/platform/tokens/mod.rs @@ -1,3 +1,4 @@ +pub mod builders; /// Identity token balances queries pub mod identity_token_balances; /// Identity token balances queries diff --git a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs index 352ca7deb89..4a7e9549568 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs @@ -3,8 +3,8 @@ //! This module provides functionality to permanently remove tokens from //! circulation by burning them. +use crate::platform::tokens::builders::burn::TokenBurnTransitionBuilder; 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; @@ -58,7 +58,7 @@ impl Sdk { /// - Insufficient token balance for burning pub async fn token_burn( &self, - burn_tokens_transition_builder: TokenBurnTransitionBuilder<'_>, + burn_tokens_transition_builder: TokenBurnTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs index 4484e0dd793..0987f9b3b4e 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs @@ -3,8 +3,8 @@ //! This module provides functionality to claim ownership of tokens that have //! been allocated or made available for claiming. +use crate::platform::tokens::builders::claim::TokenClaimTransitionBuilder; 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; @@ -49,7 +49,7 @@ impl Sdk { /// - A group action result is missing the expected document pub async fn token_claim( &self, - claim_tokens_transition_builder: TokenClaimTransitionBuilder<'_>, + claim_tokens_transition_builder: TokenClaimTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs index 8b1f8069530..a818083f4d3 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs @@ -3,8 +3,8 @@ //! This module provides functionality to update token contract configuration //! settings after initial deployment. +use crate::platform::tokens::builders::config_update::TokenConfigUpdateTransitionBuilder; 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; @@ -50,7 +50,7 @@ impl Sdk { /// - A group action result is missing the expected document pub async fn token_update_contract_token_configuration( &self, - config_update_transition_builder: TokenConfigUpdateTransitionBuilder<'_>, + config_update_transition_builder: TokenConfigUpdateTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs index b181a3eeac7..1a59cd5c187 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs @@ -3,8 +3,8 @@ //! This module provides functionality to permanently destroy frozen tokens, //! removing them from circulation entirely. +use crate::platform::tokens::builders::destroy::TokenDestroyFrozenFundsTransitionBuilder; 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; @@ -48,7 +48,7 @@ impl Sdk { /// - The proof verification returns an unexpected result type pub async fn token_destroy_frozen_funds( &self, - destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder<'_>, + destroy_frozen_funds_transition_builder: TokenDestroyFrozenFundsTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs index 26c5a09e378..ee794079af9 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs @@ -3,8 +3,8 @@ //! This module provides functionality to purchase tokens directly at //! previously set prices. +use crate::platform::tokens::builders::purchase::TokenDirectPurchaseTransitionBuilder; 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; @@ -57,7 +57,7 @@ impl Sdk { /// - Insufficient credits for the purchase pub async fn token_purchase( &self, - purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder<'_>, + purchase_tokens_transition_builder: TokenDirectPurchaseTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs index e0a017e5749..34eb9ce231d 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs @@ -3,8 +3,8 @@ //! This module provides functionality for executing emergency actions on tokens, //! typically requiring group authorization for critical interventions. +use crate::platform::tokens::builders::emergency_action::TokenEmergencyActionTransitionBuilder; 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; @@ -48,7 +48,7 @@ impl Sdk { /// - The group authorization is insufficient pub async fn token_emergency_action( &self, - emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder<'_>, + emergency_action_transition_builder: TokenEmergencyActionTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs index 339c6b8ba67..37f90e3f210 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs @@ -3,8 +3,8 @@ //! This module provides functionality to freeze tokens, temporarily preventing //! their transfer or use until they are unfrozen. +use crate::platform::tokens::builders::freeze::TokenFreezeTransitionBuilder; use crate::platform::transition::broadcast::BroadcastStateTransition; -use crate::platform::transition::fungible_tokens::freeze::TokenFreezeTransitionBuilder; use crate::{Error, Sdk}; use dpp::data_contract::group::GroupSumPower; use dpp::document::Document; @@ -57,7 +57,7 @@ impl Sdk { /// - The proof verification returns an unexpected result type pub async fn token_freeze( &self, - freeze_tokens_transition_builder: TokenFreezeTransitionBuilder<'_>, + freeze_tokens_transition_builder: TokenFreezeTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs index 8564f7c5b4d..3eaaba9746d 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs @@ -3,8 +3,8 @@ //! This module provides functionality to mint new tokens, increasing the //! total supply of a token according to its configured minting rules. +use crate::platform::tokens::builders::mint::TokenMintTransitionBuilder; use crate::platform::transition::broadcast::BroadcastStateTransition; -use crate::platform::transition::fungible_tokens::mint::TokenMintTransitionBuilder; use crate::{Error, Sdk}; use dpp::balances::credits::TokenAmount; use dpp::data_contract::group::GroupSumPower; @@ -57,7 +57,7 @@ impl Sdk { /// - The proof verification returns an unexpected result type pub async fn token_mint( &self, - mint_tokens_transition_builder: TokenMintTransitionBuilder<'_>, + mint_tokens_transition_builder: TokenMintTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs index 40277dfa7fb..eb9da4b7ec1 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs @@ -3,8 +3,8 @@ //! This module provides functionality to set or update pricing schedules //! for tokens that can be purchased directly. +use crate::platform::tokens::builders::set_price::TokenChangeDirectPurchasePriceTransitionBuilder; use crate::platform::transition::broadcast::BroadcastStateTransition; -use crate::platform::transition::fungible_tokens::set_price::TokenChangeDirectPurchasePriceTransitionBuilder; use crate::{Error, Sdk}; use dpp::data_contract::group::GroupSumPower; use dpp::document::Document; @@ -62,7 +62,7 @@ impl Sdk { /// - The proof verification returns an unexpected result type pub async fn token_set_price_for_direct_purchase( &self, - set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder<'_>, + set_price_transition_builder: TokenChangeDirectPurchasePriceTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs index 84e3b147a8a..1c4736e0245 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs @@ -3,8 +3,8 @@ //! This module provides functionality to transfer tokens between identities //! on the Dash Platform. +use crate::platform::tokens::builders::transfer::TokenTransferTransitionBuilder; use crate::platform::transition::broadcast::BroadcastStateTransition; -use crate::platform::transition::fungible_tokens::transfer::TokenTransferTransitionBuilder; use crate::{Error, Sdk}; use dpp::balances::credits::TokenAmount; use dpp::data_contract::group::GroupSumPower; @@ -55,7 +55,7 @@ impl Sdk { /// - The proof verification returns an unexpected result type pub async fn token_transfer( &self, - transfer_tokens_transition_builder: TokenTransferTransitionBuilder<'_>, + transfer_tokens_transition_builder: TokenTransferTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs index ca17cead0e6..44cf6cd4490 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs @@ -3,8 +3,8 @@ //! This module provides functionality to unfreeze previously frozen tokens, //! restoring their transfer capabilities. +use crate::platform::tokens::builders::unfreeze::TokenUnfreezeTransitionBuilder; use crate::platform::transition::broadcast::BroadcastStateTransition; -use crate::platform::transition::fungible_tokens::unfreeze::TokenUnfreezeTransitionBuilder; use crate::{Error, Sdk}; use dpp::data_contract::group::GroupSumPower; use dpp::document::Document; @@ -56,7 +56,7 @@ impl Sdk { /// - The proof verification returns an unexpected result type pub async fn token_unfreeze_identity( &self, - unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder<'_>, + unfreeze_tokens_transition_builder: TokenUnfreezeTransitionBuilder, signing_key: &IdentityPublicKey, signer: &S, ) -> Result { diff --git a/packages/rs-sdk/src/platform/transition.rs b/packages/rs-sdk/src/platform/transition.rs index 7d2dde58f13..c82a494d2df 100644 --- a/packages/rs-sdk/src/platform/transition.rs +++ b/packages/rs-sdk/src/platform/transition.rs @@ -17,4 +17,3 @@ pub mod waitable; pub mod withdraw_from_identity; pub use txid::TxId; -pub mod fungible_tokens; From f28666c9b4a92b64800d320b86c983d9a862c103 Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Wed, 4 Jun 2025 09:58:16 +0200 Subject: [PATCH 7/8] added options --- .../src/platform/tokens/builders/burn.rs | 37 +++++++++----- .../src/platform/tokens/builders/claim.rs | 37 +++++++++----- .../platform/tokens/builders/config_update.rs | 39 ++++++++++----- .../src/platform/tokens/builders/destroy.rs | 39 ++++++++++----- .../tokens/builders/emergency_action.rs | 42 ++++++++++------ .../src/platform/tokens/builders/freeze.rs | 39 ++++++++++----- .../src/platform/tokens/builders/mint.rs | 41 ++++++++++------ .../src/platform/tokens/builders/purchase.rs | 37 +++++++++----- .../src/platform/tokens/builders/set_price.rs | 39 ++++++++++----- .../src/platform/tokens/builders/transfer.rs | 49 ++++++++++++------- .../src/platform/tokens/builders/unfreeze.rs | 39 ++++++++++----- .../src/platform/tokens/transitions/burn.rs | 6 ++- .../src/platform/tokens/transitions/claim.rs | 6 ++- .../tokens/transitions/config_update.rs | 6 ++- .../transitions/destroy_frozen_funds.rs | 6 ++- .../tokens/transitions/direct_purchase.rs | 6 ++- .../tokens/transitions/emergency_action.rs | 15 ++++-- .../src/platform/tokens/transitions/freeze.rs | 2 +- .../src/platform/tokens/transitions/mint.rs | 2 +- .../set_price_for_direct_purchase.rs | 2 +- .../platform/tokens/transitions/transfer.rs | 6 ++- .../platform/tokens/transitions/unfreeze.rs | 2 +- 22 files changed, 330 insertions(+), 167 deletions(-) diff --git a/packages/rs-sdk/src/platform/tokens/builders/burn.rs b/packages/rs-sdk/src/platform/tokens/builders/burn.rs index fec6d03de6c..e6bbdbb25e6 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/burn.rs @@ -18,14 +18,15 @@ use std::sync::Arc; /// A builder to configure and broadcast token burn transitions pub struct TokenBurnTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - owner_id: Identifier, - amount: TokenAmount, - public_note: Option, - settings: Option, - user_fee_increase: Option, - using_group_info: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub owner_id: Identifier, + pub amount: TokenAmount, + pub public_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub using_group_info: Option, + pub signing_options: Option, } impl TokenBurnTransitionBuilder { @@ -52,6 +53,7 @@ impl TokenBurnTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, + signing_options: None, } } @@ -111,6 +113,20 @@ impl TokenBurnTransitionBuilder { self } + /// Adds signing options to the token burn transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token burn transition /// /// # Arguments @@ -124,12 +140,11 @@ impl TokenBurnTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -158,7 +173,7 @@ impl TokenBurnTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/claim.rs b/packages/rs-sdk/src/platform/tokens/builders/claim.rs index aaef5a0c1bb..52a2089d71b 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/claim.rs @@ -17,13 +17,14 @@ use std::sync::Arc; /// A builder to configure and broadcast token claim transitions pub struct TokenClaimTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - owner_id: Identifier, - distribution_type: TokenDistributionType, - public_note: Option, - settings: Option, - user_fee_increase: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub owner_id: Identifier, + pub distribution_type: TokenDistributionType, + pub public_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub signing_options: Option, } impl TokenClaimTransitionBuilder { @@ -45,8 +46,6 @@ impl TokenClaimTransitionBuilder { owner_id: Identifier, distribution_type: TokenDistributionType, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -55,6 +54,7 @@ impl TokenClaimTransitionBuilder { public_note: None, settings: None, user_fee_increase: None, + signing_options: None, } } @@ -100,6 +100,20 @@ impl TokenClaimTransitionBuilder { self } + /// Adds signing options to the token claim transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token claim transition /// /// # Arguments @@ -113,12 +127,11 @@ impl TokenClaimTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -146,7 +159,7 @@ impl TokenClaimTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/config_update.rs b/packages/rs-sdk/src/platform/tokens/builders/config_update.rs index 10cc1508acb..4cbc16f6835 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/config_update.rs @@ -18,14 +18,15 @@ use std::sync::Arc; /// A builder to configure and broadcast token config_update transitions pub struct TokenConfigUpdateTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - owner_id: Identifier, - update_token_configuration_item: TokenConfigurationChangeItem, - public_note: Option, - using_group_info: Option, - settings: Option, - user_fee_increase: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub owner_id: Identifier, + pub update_token_configuration_item: TokenConfigurationChangeItem, + pub public_note: Option, + pub using_group_info: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub signing_options: Option, } impl TokenConfigUpdateTransitionBuilder { @@ -48,8 +49,6 @@ impl TokenConfigUpdateTransitionBuilder { owner_id: Identifier, update_token_configuration_item: TokenConfigurationChangeItem, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -59,6 +58,7 @@ impl TokenConfigUpdateTransitionBuilder { using_group_info: None, settings: None, user_fee_increase: None, + signing_options: None, } } @@ -121,6 +121,20 @@ impl TokenConfigUpdateTransitionBuilder { self } + /// Adds signing options to the token config_update transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token config_update transition /// /// # Arguments @@ -134,12 +148,11 @@ impl TokenConfigUpdateTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -168,7 +181,7 @@ impl TokenConfigUpdateTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/destroy.rs b/packages/rs-sdk/src/platform/tokens/builders/destroy.rs index 947d51c3019..97996b0309d 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/destroy.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/destroy.rs @@ -17,14 +17,15 @@ use std::sync::Arc; /// A builder to configure and broadcast token destroy funds transitions pub struct TokenDestroyFrozenFundsTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - actor_id: Identifier, - frozen_identity_id: Identifier, - public_note: Option, - settings: Option, - user_fee_increase: Option, - using_group_info: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub actor_id: Identifier, + pub frozen_identity_id: Identifier, + pub public_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub using_group_info: Option, + pub signing_options: Option, } impl TokenDestroyFrozenFundsTransitionBuilder { @@ -46,8 +47,6 @@ impl TokenDestroyFrozenFundsTransitionBuilder { actor_id: Identifier, frozen_identity_id: Identifier, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -57,6 +56,7 @@ impl TokenDestroyFrozenFundsTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, + signing_options: None, } } @@ -119,6 +119,20 @@ impl TokenDestroyFrozenFundsTransitionBuilder { self } + /// Adds signing options to the token destroy transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token destroy transition /// /// # Arguments @@ -132,12 +146,11 @@ impl TokenDestroyFrozenFundsTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -166,7 +179,7 @@ impl TokenDestroyFrozenFundsTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs index 75abb02dd66..11ce639cf70 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs @@ -18,14 +18,15 @@ use std::sync::Arc; /// A builder to configure and broadcast emergency action transitions pub struct TokenEmergencyActionTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - actor_id: Identifier, - action: TokenEmergencyAction, - public_note: Option, - settings: Option, - user_fee_increase: Option, - using_group_info: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub actor_id: Identifier, + pub action: TokenEmergencyAction, + pub public_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub using_group_info: Option, + pub signing_options: Option, } impl TokenEmergencyActionTransitionBuilder { @@ -45,8 +46,6 @@ impl TokenEmergencyActionTransitionBuilder { token_position: TokenContractPosition, actor_id: Identifier, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -56,6 +55,7 @@ impl TokenEmergencyActionTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, + signing_options: None, } } @@ -75,8 +75,6 @@ impl TokenEmergencyActionTransitionBuilder { token_position: TokenContractPosition, actor_id: Identifier, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -86,6 +84,7 @@ impl TokenEmergencyActionTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, + signing_options: None, } } @@ -148,6 +147,20 @@ impl TokenEmergencyActionTransitionBuilder { self } + /// Adds signing options to the token emergency action transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token emergency action transition /// /// # Arguments @@ -161,12 +174,11 @@ impl TokenEmergencyActionTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -195,7 +207,7 @@ impl TokenEmergencyActionTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/freeze.rs b/packages/rs-sdk/src/platform/tokens/builders/freeze.rs index 00324b25c25..d3774571835 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/freeze.rs @@ -17,14 +17,15 @@ use std::sync::Arc; /// A builder to configure and broadcast token freeze transitions pub struct TokenFreezeTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - actor_id: Identifier, - freeze_identity_id: Identifier, - public_note: Option, - settings: Option, - user_fee_increase: Option, - using_group_info: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub actor_id: Identifier, + pub freeze_identity_id: Identifier, + pub public_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub using_group_info: Option, + pub signing_options: Option, } impl TokenFreezeTransitionBuilder { @@ -46,8 +47,6 @@ impl TokenFreezeTransitionBuilder { actor_id: Identifier, freeze_identity_id: Identifier, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -57,6 +56,7 @@ impl TokenFreezeTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, + signing_options: None, } } @@ -119,6 +119,20 @@ impl TokenFreezeTransitionBuilder { self } + /// Adds signing options to the token freeze transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token freeze transition /// /// # Arguments @@ -132,12 +146,11 @@ impl TokenFreezeTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -166,7 +179,7 @@ impl TokenFreezeTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/mint.rs b/packages/rs-sdk/src/platform/tokens/builders/mint.rs index 87f34e25547..c3b49c13c10 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/mint.rs @@ -18,15 +18,16 @@ use std::sync::Arc; /// A builder to configure and broadcast token mint transitions pub struct TokenMintTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - issuer_id: Identifier, - amount: TokenAmount, - recipient_id: Option, - public_note: Option, - settings: Option, - user_fee_increase: Option, - using_group_info: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub issuer_id: Identifier, + pub amount: TokenAmount, + pub recipient_id: Option, + pub public_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub using_group_info: Option, + pub signing_options: Option, } impl TokenMintTransitionBuilder { @@ -48,8 +49,6 @@ impl TokenMintTransitionBuilder { issuer_id: Identifier, amount: TokenAmount, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -60,6 +59,7 @@ impl TokenMintTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, + signing_options: None, } } @@ -139,6 +139,20 @@ impl TokenMintTransitionBuilder { self } + /// Adds signing options to the token mint transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token mint transition /// /// # Arguments @@ -152,12 +166,11 @@ impl TokenMintTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -187,7 +200,7 @@ impl TokenMintTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/purchase.rs b/packages/rs-sdk/src/platform/tokens/builders/purchase.rs index fbbfe5db5d0..71c53f22c11 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/purchase.rs @@ -18,13 +18,14 @@ use std::sync::Arc; /// A builder to configure and broadcast token purchase transitions pub struct TokenDirectPurchaseTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - actor_id: Identifier, - amount: TokenAmount, - total_agreed_price: Credits, - settings: Option, - user_fee_increase: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub actor_id: Identifier, + pub amount: TokenAmount, + pub total_agreed_price: Credits, + pub settings: Option, + pub user_fee_increase: Option, + pub signing_options: Option, } impl TokenDirectPurchaseTransitionBuilder { @@ -47,8 +48,6 @@ impl TokenDirectPurchaseTransitionBuilder { amount: TokenAmount, total_agreed_price: Credits, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -57,6 +56,7 @@ impl TokenDirectPurchaseTransitionBuilder { total_agreed_price, settings: None, user_fee_increase: None, + signing_options: None, } } @@ -88,6 +88,20 @@ impl TokenDirectPurchaseTransitionBuilder { self } + /// Adds signing options to the token purchase transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token purchase transition /// /// # Arguments @@ -101,12 +115,11 @@ impl TokenDirectPurchaseTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -134,7 +147,7 @@ impl TokenDirectPurchaseTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/set_price.rs b/packages/rs-sdk/src/platform/tokens/builders/set_price.rs index b0a1533ad64..68401b3c6a6 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/set_price.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/set_price.rs @@ -18,14 +18,15 @@ use std::sync::Arc; /// A builder to configure and broadcast token change direct purchase price transitions pub struct TokenChangeDirectPurchasePriceTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - actor_id: Identifier, - token_pricing_schedule: Option, - public_note: Option, - settings: Option, - user_fee_increase: Option, - using_group_info: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub actor_id: Identifier, + pub token_pricing_schedule: Option, + pub public_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub using_group_info: Option, + pub signing_options: Option, } impl TokenChangeDirectPurchasePriceTransitionBuilder { @@ -47,8 +48,6 @@ impl TokenChangeDirectPurchasePriceTransitionBuilder { issuer_id: Identifier, token_pricing_schedule: Option, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -58,6 +57,7 @@ impl TokenChangeDirectPurchasePriceTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, + signing_options: None, } } @@ -120,6 +120,20 @@ impl TokenChangeDirectPurchasePriceTransitionBuilder { self } + /// Adds signing options to the token change direct purchase price transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token change direct purchase price transition /// /// # Arguments @@ -133,12 +147,11 @@ impl TokenChangeDirectPurchasePriceTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -167,7 +180,7 @@ impl TokenChangeDirectPurchasePriceTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/transfer.rs b/packages/rs-sdk/src/platform/tokens/builders/transfer.rs index 6fc489ad386..53191a6f6ce 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/transfer.rs @@ -17,16 +17,17 @@ use std::sync::Arc; /// A builder to configure and broadcast token transfer transitions pub struct TokenTransferTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - issuer_id: Identifier, - amount: TokenAmount, - recipient_id: Identifier, - public_note: Option, - shared_encrypted_note: Option, - private_encrypted_note: Option, - settings: Option, - user_fee_increase: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub issuer_id: Identifier, + pub amount: TokenAmount, + pub recipient_id: Identifier, + pub public_note: Option, + pub shared_encrypted_note: Option, + pub private_encrypted_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub signing_options: Option, } impl TokenTransferTransitionBuilder { @@ -50,8 +51,6 @@ impl TokenTransferTransitionBuilder { recipient_id: Identifier, amount: TokenAmount, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -63,6 +62,7 @@ impl TokenTransferTransitionBuilder { user_fee_increase: None, private_encrypted_note: None, shared_encrypted_note: None, + signing_options: None, } } @@ -143,6 +143,20 @@ impl TokenTransferTransitionBuilder { self } + /// Adds signing options to the token transfer transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token transfer transition /// /// # Arguments @@ -156,12 +170,11 @@ impl TokenTransferTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -184,15 +197,15 @@ impl TokenTransferTransitionBuilder { self.token_position, self.amount, self.recipient_id, - self.public_note.clone(), - self.shared_encrypted_note.clone(), - self.private_encrypted_note.clone(), + self.public_note, + self.shared_encrypted_note, + self.private_encrypted_note, identity_public_key, identity_contract_nonce, self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs index 96e01e9ca4d..f8c48eabd05 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs @@ -17,14 +17,15 @@ use std::sync::Arc; /// A builder to configure and broadcast token unfreeze transitions pub struct TokenUnfreezeTransitionBuilder { - data_contract: Arc, - token_position: TokenContractPosition, - actor_id: Identifier, - unfreeze_identity_id: Identifier, - public_note: Option, - settings: Option, - user_fee_increase: Option, - using_group_info: Option, + pub data_contract: Arc, + pub token_position: TokenContractPosition, + pub actor_id: Identifier, + pub unfreeze_identity_id: Identifier, + pub public_note: Option, + pub settings: Option, + pub user_fee_increase: Option, + pub using_group_info: Option, + pub signing_options: Option, } impl TokenUnfreezeTransitionBuilder { @@ -46,8 +47,6 @@ impl TokenUnfreezeTransitionBuilder { actor_id: Identifier, unfreeze_identity_id: Identifier, ) -> Self { - // TODO: Validate token position - Self { data_contract, token_position, @@ -57,6 +56,7 @@ impl TokenUnfreezeTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, + signing_options: None, } } @@ -119,6 +119,20 @@ impl TokenUnfreezeTransitionBuilder { self } + /// Adds signing options to the token unfreeze transition + /// + /// # Arguments + /// + /// * `signing_options` - The signing options to add + /// + /// # Returns + /// + /// * `Self` - The updated builder + pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { + self.signing_options = Some(signing_options); + self + } + /// Signs the token unfreeze transition /// /// # Arguments @@ -132,12 +146,11 @@ impl TokenUnfreezeTransitionBuilder { /// /// * `Result` - The signed state transition or an error pub async fn sign( - &self, + self, sdk: &Sdk, identity_public_key: &IdentityPublicKey, signer: &impl Signer, platform_version: &PlatformVersion, - options: Option, ) -> Result { let token_id = Identifier::from(calculate_token_id( self.data_contract.id().as_bytes(), @@ -166,7 +179,7 @@ impl TokenUnfreezeTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - options, + self.signing_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs index 4a7e9549568..7c4c24f7cc3 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/burn.rs @@ -64,12 +64,14 @@ impl Sdk { ) -> Result { let platform_version = self.version(); + let put_settings = burn_tokens_transition_builder.settings; + let state_transition = burn_tokens_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition - .broadcast_and_wait::(self, None) + .broadcast_and_wait::(self, put_settings) .await?; match proof_result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs index 0987f9b3b4e..4b209e2c848 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/claim.rs @@ -55,12 +55,14 @@ impl Sdk { ) -> Result { let platform_version = self.version(); + let put_settings = claim_tokens_transition_builder.settings; + let state_transition = claim_tokens_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition - .broadcast_and_wait::(self, None) + .broadcast_and_wait::(self, put_settings) .await?; match proof_result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs index a818083f4d3..04a9ffb95ae 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/config_update.rs @@ -56,12 +56,14 @@ impl Sdk { ) -> Result { let platform_version = self.version(); + let put_settings = config_update_transition_builder.settings; + let state_transition = config_update_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition - .broadcast_and_wait::(self, None) + .broadcast_and_wait::(self, put_settings) .await?; match proof_result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs index 1a59cd5c187..029c5939731 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/destroy_frozen_funds.rs @@ -54,12 +54,14 @@ impl Sdk { ) -> Result { let platform_version = self.version(); + let put_settings = destroy_frozen_funds_transition_builder.settings; + let state_transition = destroy_frozen_funds_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition - .broadcast_and_wait::(self, None) + .broadcast_and_wait::(self, put_settings) .await?; match proof_result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs index ee794079af9..27d21b33bf3 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/direct_purchase.rs @@ -63,12 +63,14 @@ impl Sdk { ) -> Result { let platform_version = self.version(); + let put_settings = purchase_tokens_transition_builder.settings; + let state_transition = purchase_tokens_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition - .broadcast_and_wait::(self, None) + .broadcast_and_wait::(self, put_settings) .await?; match proof_result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs index 34eb9ce231d..8d072ed56d2 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/emergency_action.rs @@ -14,9 +14,11 @@ use dpp::state_transition::proof_result::StateTransitionProofResult; /// Result type returned from emergency action operations. /// -/// Emergency actions always require group authorization and may include +/// Emergency actions may require group authorization and may include /// a document recording the action details. pub enum EmergencyActionResult { + /// Standard emergency action result containing the action document. + Document(Document), /// Emergency action result with group power and optional document for history. GroupActionWithDocument(GroupSumPower, Option), } @@ -54,15 +56,20 @@ impl Sdk { ) -> Result { let platform_version = self.version(); + let put_settings = emergency_action_transition_builder.settings; + let state_transition = emergency_action_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition - .broadcast_and_wait::(self, None) + .broadcast_and_wait::(self, put_settings) .await?; match proof_result { + StateTransitionProofResult::VerifiedTokenActionWithDocument(document) => { + Ok(EmergencyActionResult::Document(document)) + } StateTransitionProofResult::VerifiedTokenGroupActionWithDocument( group_power, document, @@ -72,7 +79,7 @@ impl Sdk { )), _ => Err(Error::DriveProofError( drive::error::proof::ProofError::UnexpectedResultProof( - "Expected VerifiedTokenGroupActionWithDocument for emergency action transition" + "Expected VerifiedTokenActionWithDocument or VerifiedTokenGroupActionWithDocument for emergency action transition" .to_string(), ), vec![], diff --git a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs index 37f90e3f210..e483f8ad1af 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/freeze.rs @@ -64,7 +64,7 @@ impl Sdk { let platform_version = self.version(); let state_transition = freeze_tokens_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs index 3eaaba9746d..e81088a2ebb 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/mint.rs @@ -64,7 +64,7 @@ impl Sdk { let platform_version = self.version(); let state_transition = mint_tokens_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs index eb9da4b7ec1..cd95188395e 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/set_price_for_direct_purchase.rs @@ -69,7 +69,7 @@ impl Sdk { let platform_version = self.version(); let state_transition = set_price_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition diff --git a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs index 1c4736e0245..4279174e0b2 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/transfer.rs @@ -61,12 +61,14 @@ impl Sdk { ) -> Result { let platform_version = self.version(); + let put_settings = transfer_tokens_transition_builder.settings; + let state_transition = transfer_tokens_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition - .broadcast_and_wait::(self, None) + .broadcast_and_wait::(self, put_settings) .await?; match proof_result { diff --git a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs index 44cf6cd4490..8462739a32e 100644 --- a/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/transitions/unfreeze.rs @@ -63,7 +63,7 @@ impl Sdk { let platform_version = self.version(); let state_transition = unfreeze_tokens_transition_builder - .sign(self, signing_key, signer, platform_version, None) + .sign(self, signing_key, signer, platform_version) .await?; let proof_result = state_transition From 18aaef659c940d86d8e32bc57d0df6a50f8d3d42 Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Wed, 4 Jun 2025 10:22:48 +0200 Subject: [PATCH 8/8] renamed --- .../src/platform/tokens/builders/burn.rs | 17 ++++++++++------- .../src/platform/tokens/builders/claim.rs | 17 ++++++++++------- .../platform/tokens/builders/config_update.rs | 17 ++++++++++------- .../src/platform/tokens/builders/destroy.rs | 17 ++++++++++------- .../tokens/builders/emergency_action.rs | 19 +++++++++++-------- .../src/platform/tokens/builders/freeze.rs | 17 ++++++++++------- .../src/platform/tokens/builders/mint.rs | 17 ++++++++++------- .../src/platform/tokens/builders/purchase.rs | 17 ++++++++++------- .../src/platform/tokens/builders/set_price.rs | 17 ++++++++++------- .../src/platform/tokens/builders/transfer.rs | 17 ++++++++++------- .../src/platform/tokens/builders/unfreeze.rs | 17 ++++++++++------- 11 files changed, 111 insertions(+), 78 deletions(-) diff --git a/packages/rs-sdk/src/platform/tokens/builders/burn.rs b/packages/rs-sdk/src/platform/tokens/builders/burn.rs index e6bbdbb25e6..9ebd907f06b 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/burn.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/burn.rs @@ -26,7 +26,7 @@ pub struct TokenBurnTransitionBuilder { pub settings: Option, pub user_fee_increase: Option, pub using_group_info: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenBurnTransitionBuilder { @@ -53,7 +53,7 @@ impl TokenBurnTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -113,17 +113,20 @@ impl TokenBurnTransitionBuilder { self } - /// Adds signing options to the token burn transition + /// Adds state transition creation options to the token burn transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The signing options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -173,7 +176,7 @@ impl TokenBurnTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/claim.rs b/packages/rs-sdk/src/platform/tokens/builders/claim.rs index 52a2089d71b..a4763db6f50 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/claim.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/claim.rs @@ -24,7 +24,7 @@ pub struct TokenClaimTransitionBuilder { pub public_note: Option, pub settings: Option, pub user_fee_increase: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenClaimTransitionBuilder { @@ -54,7 +54,7 @@ impl TokenClaimTransitionBuilder { public_note: None, settings: None, user_fee_increase: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -100,17 +100,20 @@ impl TokenClaimTransitionBuilder { self } - /// Adds signing options to the token claim transition + /// Adds state transition creation options to the token claim transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -159,7 +162,7 @@ impl TokenClaimTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/config_update.rs b/packages/rs-sdk/src/platform/tokens/builders/config_update.rs index 4cbc16f6835..264e5763583 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/config_update.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/config_update.rs @@ -26,7 +26,7 @@ pub struct TokenConfigUpdateTransitionBuilder { pub using_group_info: Option, pub settings: Option, pub user_fee_increase: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenConfigUpdateTransitionBuilder { @@ -58,7 +58,7 @@ impl TokenConfigUpdateTransitionBuilder { using_group_info: None, settings: None, user_fee_increase: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -121,17 +121,20 @@ impl TokenConfigUpdateTransitionBuilder { self } - /// Adds signing options to the token config_update transition + /// Adds state transition creation options to the token config_update transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -181,7 +184,7 @@ impl TokenConfigUpdateTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/destroy.rs b/packages/rs-sdk/src/platform/tokens/builders/destroy.rs index 97996b0309d..cdf225ace0f 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/destroy.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/destroy.rs @@ -25,7 +25,7 @@ pub struct TokenDestroyFrozenFundsTransitionBuilder { pub settings: Option, pub user_fee_increase: Option, pub using_group_info: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenDestroyFrozenFundsTransitionBuilder { @@ -56,7 +56,7 @@ impl TokenDestroyFrozenFundsTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -119,17 +119,20 @@ impl TokenDestroyFrozenFundsTransitionBuilder { self } - /// Adds signing options to the token destroy transition + /// Adds state transition creation options to the token destroy transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -179,7 +182,7 @@ impl TokenDestroyFrozenFundsTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs b/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs index 11ce639cf70..b1a9dfde5eb 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/emergency_action.rs @@ -26,7 +26,7 @@ pub struct TokenEmergencyActionTransitionBuilder { pub settings: Option, pub user_fee_increase: Option, pub using_group_info: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenEmergencyActionTransitionBuilder { @@ -55,7 +55,7 @@ impl TokenEmergencyActionTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -84,7 +84,7 @@ impl TokenEmergencyActionTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -147,17 +147,20 @@ impl TokenEmergencyActionTransitionBuilder { self } - /// Adds signing options to the token emergency action transition + /// Adds state transition creation options to the token emergency action transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -207,7 +210,7 @@ impl TokenEmergencyActionTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/freeze.rs b/packages/rs-sdk/src/platform/tokens/builders/freeze.rs index d3774571835..6f874ea2f60 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/freeze.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/freeze.rs @@ -25,7 +25,7 @@ pub struct TokenFreezeTransitionBuilder { pub settings: Option, pub user_fee_increase: Option, pub using_group_info: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenFreezeTransitionBuilder { @@ -56,7 +56,7 @@ impl TokenFreezeTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -119,17 +119,20 @@ impl TokenFreezeTransitionBuilder { self } - /// Adds signing options to the token freeze transition + /// Adds state transition creation options to the token freeze transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -179,7 +182,7 @@ impl TokenFreezeTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/mint.rs b/packages/rs-sdk/src/platform/tokens/builders/mint.rs index c3b49c13c10..27195e76676 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/mint.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/mint.rs @@ -27,7 +27,7 @@ pub struct TokenMintTransitionBuilder { pub settings: Option, pub user_fee_increase: Option, pub using_group_info: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenMintTransitionBuilder { @@ -59,7 +59,7 @@ impl TokenMintTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -139,17 +139,20 @@ impl TokenMintTransitionBuilder { self } - /// Adds signing options to the token mint transition + /// Adds state transition creation options to the token mint transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -200,7 +203,7 @@ impl TokenMintTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/purchase.rs b/packages/rs-sdk/src/platform/tokens/builders/purchase.rs index 71c53f22c11..b23f74920d9 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/purchase.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/purchase.rs @@ -25,7 +25,7 @@ pub struct TokenDirectPurchaseTransitionBuilder { pub total_agreed_price: Credits, pub settings: Option, pub user_fee_increase: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenDirectPurchaseTransitionBuilder { @@ -56,7 +56,7 @@ impl TokenDirectPurchaseTransitionBuilder { total_agreed_price, settings: None, user_fee_increase: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -88,17 +88,20 @@ impl TokenDirectPurchaseTransitionBuilder { self } - /// Adds signing options to the token purchase transition + /// Adds state transition creation options to the token purchase transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -147,7 +150,7 @@ impl TokenDirectPurchaseTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/set_price.rs b/packages/rs-sdk/src/platform/tokens/builders/set_price.rs index 68401b3c6a6..8898b251425 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/set_price.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/set_price.rs @@ -26,7 +26,7 @@ pub struct TokenChangeDirectPurchasePriceTransitionBuilder { pub settings: Option, pub user_fee_increase: Option, pub using_group_info: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenChangeDirectPurchasePriceTransitionBuilder { @@ -57,7 +57,7 @@ impl TokenChangeDirectPurchasePriceTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -120,17 +120,20 @@ impl TokenChangeDirectPurchasePriceTransitionBuilder { self } - /// Adds signing options to the token change direct purchase price transition + /// Adds state transition creation options to the token change direct purchase price transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -180,7 +183,7 @@ impl TokenChangeDirectPurchasePriceTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/transfer.rs b/packages/rs-sdk/src/platform/tokens/builders/transfer.rs index 53191a6f6ce..ff591ef22cb 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/transfer.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/transfer.rs @@ -27,7 +27,7 @@ pub struct TokenTransferTransitionBuilder { pub private_encrypted_note: Option, pub settings: Option, pub user_fee_increase: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenTransferTransitionBuilder { @@ -62,7 +62,7 @@ impl TokenTransferTransitionBuilder { user_fee_increase: None, private_encrypted_note: None, shared_encrypted_note: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -143,17 +143,20 @@ impl TokenTransferTransitionBuilder { self } - /// Adds signing options to the token transfer transition + /// Adds state transition creation options to the token transfer transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -205,7 +208,7 @@ impl TokenTransferTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition) diff --git a/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs b/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs index f8c48eabd05..06ffa651987 100644 --- a/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs +++ b/packages/rs-sdk/src/platform/tokens/builders/unfreeze.rs @@ -25,7 +25,7 @@ pub struct TokenUnfreezeTransitionBuilder { pub settings: Option, pub user_fee_increase: Option, pub using_group_info: Option, - pub signing_options: Option, + pub state_transition_creation_options: Option, } impl TokenUnfreezeTransitionBuilder { @@ -56,7 +56,7 @@ impl TokenUnfreezeTransitionBuilder { settings: None, user_fee_increase: None, using_group_info: None, - signing_options: None, + state_transition_creation_options: None, } } @@ -119,17 +119,20 @@ impl TokenUnfreezeTransitionBuilder { self } - /// Adds signing options to the token unfreeze transition + /// Adds state transition creation options to the token unfreeze transition /// /// # Arguments /// - /// * `signing_options` - The signing options to add + /// * `state_transition_creation_options` - The state transition creation options to add /// /// # Returns /// /// * `Self` - The updated builder - pub fn with_signing_options(mut self, signing_options: StateTransitionCreationOptions) -> Self { - self.signing_options = Some(signing_options); + pub fn with_state_transition_creation_options( + mut self, + state_transition_creation_options: StateTransitionCreationOptions, + ) -> Self { + self.state_transition_creation_options = Some(state_transition_creation_options); self } @@ -179,7 +182,7 @@ impl TokenUnfreezeTransitionBuilder { self.user_fee_increase.unwrap_or_default(), signer, platform_version, - self.signing_options, + self.state_transition_creation_options, )?; Ok(state_transition)