use super::{BackendTaskSuccessResult, FeeResult}; use crate::backend_task::error::TaskError; use crate::backend_task::{NETWORK_REQUEST_TIMEOUT, await_network_request_with_timeout}; use crate::ui::tokens::tokens_screen::{IdentityTokenIdentifier, IdentityTokenInfo, TokenInfo}; use crate::wallet_backend::{TokenActionCommon, TokenActor}; use crate::{app::TaskResult, context::AppContext, model::qualified_identity::QualifiedIdentity}; use dash_sdk::dpp::balances::credits::TokenAmount; use dash_sdk::dpp::data_contract::GroupContractPosition; use dash_sdk::dpp::data_contract::associated_token::token_configuration_item::TokenConfigurationChangeItem; use dash_sdk::dpp::fee::Credits; use dash_sdk::dpp::group::GroupStateTransitionInfoStatus; use dash_sdk::dpp::tokens::token_pricing_schedule::TokenPricingSchedule; use dash_sdk::platform::Fetch; use dash_sdk::{ Sdk, dpp::{ ProtocolError, data_contract::{ TokenConfiguration, TokenContractPosition, associated_token::{ token_configuration::accessors::v1::TokenConfigurationV1Setters, token_configuration::v0::TokenConfigurationV0, token_configuration_convention::TokenConfigurationConvention, token_configuration_localization::{ TokenConfigurationLocalization, v0::TokenConfigurationLocalizationV0, }, token_distribution_key::TokenDistributionType, token_distribution_rules::TokenDistributionRules, token_keeps_history_rules::TokenKeepsHistoryRules, token_marketplace_rules::{ TokenMarketplaceRules, v0::{TokenMarketplaceRulesV0, TokenTradeMode}, }, }, change_control_rules::{ ChangeControlRules, authorized_action_takers::AuthorizedActionTakers, }, config::DataContractConfig, group::Group, v1::DataContractV1, }, identity::accessors::IdentityGettersV0, }, platform::{ DataContract, Identifier, IdentityPublicKey, proto::get_documents_request::get_documents_request_v0::Start, }, }; use std::future::Future; use std::{collections::BTreeMap, sync::Arc}; mod burn_tokens; mod claim_tokens; mod destroy_frozen_funds; mod freeze_tokens; mod mint_tokens; mod pause_tokens; mod purchase_tokens; mod query_my_token_balances; mod query_token_non_claimed_perpetual_distribution_rewards; mod query_token_pricing; mod query_tokens; mod resume_tokens; mod set_token_price; mod transfer_tokens; mod unfreeze_tokens; mod update_token_config; /// All token-configuration inputs for /// [`AppContext::build_data_contract_v1_with_one_token`], grouped to keep the /// builder and its task variant from carrying two dozen positional fields. #[derive(Debug, Clone, PartialEq)] pub struct TokenContractParams { pub token_names: Vec<(String, String, String)>, pub contract_keywords: Vec, pub token_description: Option, pub should_capitalize: bool, pub decimals: u8, pub base_supply: TokenAmount, pub max_supply: Option, pub start_paused: bool, pub allow_transfers_to_frozen_identities: bool, pub keeps_history: TokenKeepsHistoryRules, pub main_control_group: Option, pub manual_minting_rules: ChangeControlRules, pub manual_burning_rules: ChangeControlRules, pub freeze_rules: ChangeControlRules, pub unfreeze_rules: ChangeControlRules, pub destroy_frozen_funds_rules: ChangeControlRules, pub emergency_action_rules: ChangeControlRules, pub max_supply_change_rules: ChangeControlRules, pub conventions_change_rules: ChangeControlRules, pub main_control_group_change_authorized: AuthorizedActionTakers, pub distribution_rules: TokenDistributionRules, pub groups: BTreeMap, pub document_schemas: Option>, pub marketplace_rules: ChangeControlRules, /// Whether holders may move the token to another identity. `false` needs /// a version 1 token configuration (protocol version 14). pub transferable: bool, } #[derive(Debug, Clone, PartialEq)] #[allow(clippy::large_enum_variant)] pub enum TokenTask { RegisterTokenContract { identity: QualifiedIdentity, signing_key: Box, params: Box, }, QueryMyTokenBalances, QueryIdentityTokenBalance(IdentityTokenIdentifier), /// Stop tracking one `(identity, token)` balance: un-watch it upstream so /// the background sync stops fetching it, drop it from the My Tokens /// ordering so the row disappears, and record the dismissal so later /// refreshes do not re-watch the pair. StopTrackingTokenBalance(IdentityTokenIdentifier), /// Forget the note that an identity may already have taken its /// once-per-identity claim of a token (the user dismissed it). ClearOncePerIdentityClaimHint(IdentityTokenIdentifier), QueryDescriptionsByKeyword(String, Option), FetchTokenByContractId(Identifier), FetchTokenByTokenId(Identifier), SaveTokenLocally(TokenInfo), QueryTokenPricing(Identifier), MintTokens { sending_identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, public_note: Option, amount: TokenAmount, recipient_id: Option, group_info: Option, }, TransferTokens { sending_identity: QualifiedIdentity, recipient_id: Identifier, amount: TokenAmount, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, public_note: Option, }, BurnTokens { owner_identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, public_note: Option, amount: TokenAmount, group_info: Option, }, DestroyFrozenFunds { actor_identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, public_note: Option, frozen_identity: Identifier, group_info: Option, }, FreezeTokens { actor_identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, public_note: Option, freeze_identity: Identifier, group_info: Option, }, UnfreezeTokens { actor_identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, public_note: Option, unfreeze_identity: Identifier, group_info: Option, }, PauseTokens { actor_identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, public_note: Option, group_info: Option, }, ResumeTokens { actor_identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, public_note: Option, group_info: Option, }, ClaimTokens { data_contract: Arc, token_position: TokenContractPosition, actor_identity: QualifiedIdentity, distribution_type: TokenDistributionType, signing_key: IdentityPublicKey, public_note: Option, }, EstimatePerpetualTokenRewardsWithExplanation { identity_id: Identifier, token_id: Identifier, }, UpdateTokenConfig { identity_token_info: Box, change_item: TokenConfigurationChangeItem, signing_key: IdentityPublicKey, public_note: Option, group_info: Option, }, PurchaseTokens { identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, amount: TokenAmount, total_agreed_price: Credits, }, SetDirectPurchasePrice { identity: QualifiedIdentity, data_contract: Arc, token_position: TokenContractPosition, signing_key: IdentityPublicKey, token_pricing_schedule: Option, public_note: Option, group_info: Option, }, } impl AppContext { /// The actor a token action of `identity` is sent through: the wallet /// that holds it, or the SDK when no wallet in this app holds it. /// /// # Errors /// The wallet-not-loaded errors when the identity's wallet is not loaded. async fn token_actor<'a>( &self, identity: &'a QualifiedIdentity, ) -> Result, TaskError> { match self.token_action_wallet(&identity.identity.id())? { Some(seed_hash) => { self.wallet_backend()? .token_actor(&seed_hash, identity) .await } None => Ok(TokenActor::without_wallet(self.sdk.load_full(), identity)), } } /// The arguments every token action shares, with the current signing /// options. fn token_action_common<'a>( &self, data_contract: Arc, token_position: TokenContractPosition, signing_key: &'a IdentityPublicKey, ) -> TokenActionCommon<'a> { TokenActionCommon { data_contract, token_position, signing_key, options: self.state_transition_options(), } } /// Awaits a token state-transition SDK call, applies its post-broadcast /// side effects (balance updates, audit logging), and returns the success /// result carrying an estimated-only fee. /// /// The platform does not report a settled fee for token ops, so the fee is /// always the pre-flight estimate (see [`FeeResult::estimated_only`]). async fn execute_token_op( &self, call: impl Future>, post_broadcast: impl FnOnce(R), make_success: fn(FeeResult) -> BackendTaskSuccessResult, ) -> Result { let result = call.await?; post_broadcast(result); let estimated_fee = self.fee_estimator().estimate_token_transition(); Ok(make_success(FeeResult::estimated_only(estimated_fee))) } /// Version 1 distribution rules (a once-per-identity distribution) only /// decode on networks that accept them; refuse them elsewhere before /// anything is signed. fn ensure_distribution_rules_supported( &self, rules: &TokenDistributionRules, ) -> Result<(), TaskError> { match rules { TokenDistributionRules::V0(_) => Ok(()), TokenDistributionRules::V1(_) if crate::context::feature_gate::FeatureGate::TokenOncePerIdentityDistribution .is_available(self) => { Ok(()) } TokenDistributionRules::V1(_) => Err(TaskError::TokenOncePerIdentityNotSupported), } } /// A token that cannot be transferred needs a version 1 token /// configuration, which only decodes on networks that accept it; refuse it /// elsewhere before anything is signed. fn ensure_transferability_supported(&self, transferable: bool) -> Result<(), TaskError> { if transferable || crate::context::feature_gate::FeatureGate::NonTransferableTokens.is_available(self) { Ok(()) } else { Err(TaskError::NonTransferableTokenNotSupported) } } pub async fn run_token_task( self: &Arc, task: TokenTask, sdk: &Sdk, sender: crate::utils::egui_mpsc::SenderAsync, ) -> Result { match task { TokenTask::RegisterTokenContract { identity, signing_key, params, } => { self.ensure_distribution_rules_supported(¶ms.distribution_rules)?; self.ensure_transferability_supported(params.transferable)?; params .contract_keywords .iter() .try_for_each(|keyword| crate::model::token::validate_contract_keyword(keyword)) .map_err(|source| TaskError::InvalidContractKeywordLength { source })?; let alias = params.token_names[0].0.clone(); let data_contract = self .build_data_contract_v1_with_one_token(identity.identity.id(), *params) .map_err(|e| TaskError::from(dash_sdk::Error::Protocol(e)))?; self.register_data_contract( data_contract, alias, identity, *signing_key, sdk, sender, ) .await .map(|_| BackendTaskSuccessResult::RegisteredTokenContract) } TokenTask::QueryMyTokenBalances => self.query_my_token_balances(sdk, sender).await, TokenTask::MintTokens { sending_identity, data_contract, token_position, signing_key, public_note, amount, recipient_id, group_info, } => { self.mint_tokens( &sending_identity, data_contract, token_position, signing_key, public_note, amount, recipient_id, group_info, sender, ) .await } TokenTask::QueryDescriptionsByKeyword(keyword, cursor) => { self.query_descriptions_by_keyword(&keyword, &cursor, sdk) .await } TokenTask::TransferTokens { sending_identity, recipient_id, amount, data_contract, token_position, signing_key, public_note, } => { self.transfer_tokens( &sending_identity, recipient_id, amount, data_contract, token_position, signing_key, public_note, sender, ) .await } TokenTask::BurnTokens { owner_identity, data_contract, token_position, signing_key, public_note, amount, group_info, } => { self.burn_tokens( &owner_identity, data_contract, token_position, signing_key, public_note, amount, group_info, sender, ) .await } TokenTask::DestroyFrozenFunds { actor_identity, data_contract, token_position, signing_key, public_note, frozen_identity, group_info, } => { self.destroy_frozen_funds( &actor_identity, data_contract, token_position, signing_key, public_note, frozen_identity, group_info, sender, ) .await } TokenTask::FreezeTokens { actor_identity, data_contract, token_position, signing_key, public_note, freeze_identity, group_info, } => { self.freeze_tokens( &actor_identity, data_contract, token_position, signing_key, public_note, freeze_identity, group_info, sender, ) .await } TokenTask::UnfreezeTokens { actor_identity, data_contract, token_position, signing_key, public_note, unfreeze_identity, group_info, } => { self.unfreeze_tokens( &actor_identity, data_contract, token_position, signing_key, public_note, unfreeze_identity, group_info, sender, ) .await } TokenTask::PauseTokens { actor_identity, data_contract, token_position, signing_key, public_note, group_info, } => { self.pause_tokens( &actor_identity, data_contract, token_position, signing_key, public_note, group_info, sender, ) .await } TokenTask::ResumeTokens { actor_identity, data_contract, token_position, signing_key, public_note, group_info, } => { self.resume_tokens( &actor_identity, data_contract, token_position, signing_key, public_note, group_info, sender, ) .await } TokenTask::ClaimTokens { data_contract, token_position, actor_identity, distribution_type, signing_key, public_note, } => { self.claim_tokens( data_contract, token_position, &actor_identity, distribution_type, signing_key, public_note, ) .await } TokenTask::EstimatePerpetualTokenRewardsWithExplanation { identity_id, token_id, } => { self.query_token_non_claimed_perpetual_distribution_rewards_with_explanation( identity_id, token_id, sdk, ) .await } TokenTask::QueryIdentityTokenBalance(identity_token_pair) => { self.query_token_balance(sdk, identity_token_pair, sender) .await } TokenTask::StopTrackingTokenBalance(identity_token_pair) => { self.stop_tracking_token_balance(identity_token_pair, sender) .await } TokenTask::FetchTokenByContractId(contract_id) => { match await_network_request_with_timeout( NETWORK_REQUEST_TIMEOUT, DataContract::fetch_by_identifier(sdk, contract_id), |source| TaskError::TokenLookupTimeout { source }, ) .await? { Ok(Some(data_contract)) => { Ok(BackendTaskSuccessResult::FetchedContract(data_contract)) } Ok(None) => Ok(BackendTaskSuccessResult::ContractNotFound), Err(e) => Err(TaskError::from(e)), } } TokenTask::FetchTokenByTokenId(token_id) => { use dash_sdk::dpp::tokens::contract_info::TokenContractInfo; use dash_sdk::dpp::tokens::contract_info::v0::TokenContractInfoV0Accessors; match await_network_request_with_timeout( NETWORK_REQUEST_TIMEOUT, TokenContractInfo::fetch(sdk, token_id), |source| TaskError::TokenLookupTimeout { source }, ) .await? { Ok(Some(token_contract_info)) => { // Extract the contract ID and token position from token_contract_info let (contract_id, token_position) = match &token_contract_info { TokenContractInfo::V0(info) => { (info.contract_id(), info.token_contract_position()) } }; // Fetch the full contract match await_network_request_with_timeout( NETWORK_REQUEST_TIMEOUT, DataContract::fetch_by_identifier(sdk, contract_id), |source| TaskError::TokenLookupTimeout { source }, ) .await? { Ok(Some(data_contract)) => { // Return the contract with the specific token position Ok(BackendTaskSuccessResult::FetchedContractWithTokenPosition( data_contract, token_position, )) } Ok(None) => Ok(BackendTaskSuccessResult::ContractNotFound), Err(e) => Err(TaskError::from(e)), } } Ok(None) => Ok(BackendTaskSuccessResult::TokenNotFound), Err(e) => Err(TaskError::from(e)), } } TokenTask::ClearOncePerIdentityClaimHint(pair) => { self.clear_once_per_identity_claim(&pair.token_id, &pair.identity_id)?; Ok(BackendTaskSuccessResult::OncePerIdentityClaimHintCleared( pair, )) } TokenTask::SaveTokenLocally(token_info) => { let token_id = token_info.token_id; self.insert_token( &token_id, &token_info.token_name, token_info.token_configuration, &token_info.data_contract_id, token_info.token_position, )?; // Importing a token is intent to track it, so it overrides an // earlier "stop tracking" of the same token. self.clear_untracked_token(&token_id)?; Ok(BackendTaskSuccessResult::SavedToken) } TokenTask::UpdateTokenConfig { identity_token_info, change_item, signing_key, public_note, group_info, } => { self.update_token_config( *identity_token_info, change_item, &signing_key, public_note, group_info, sdk, ) .await } TokenTask::PurchaseTokens { identity, data_contract, token_position, signing_key, amount, total_agreed_price, } => { self.purchase_tokens( &identity, data_contract, token_position, signing_key, amount, total_agreed_price, sender, ) .await } TokenTask::SetDirectPurchasePrice { identity, data_contract, token_position, signing_key, token_pricing_schedule, public_note, group_info, } => { self.set_direct_purchase_price( &identity, data_contract, token_position, signing_key, public_note, token_pricing_schedule, group_info, sender, ) .await } TokenTask::QueryTokenPricing(token_id) => { self.query_token_pricing(token_id, sdk, sender).await } } } /// Constructs a DataContract::V1 with: /// - contract_id (random) /// - version = 1 /// - the specified owner_id /// - an empty set of documents, groups, schema_defs /// - a single token in tokens[0] with fields derived from your parameters. #[allow(clippy::result_large_err)] pub fn build_data_contract_v1_with_one_token( &self, owner_id: Identifier, params: TokenContractParams, ) -> Result { let TokenContractParams { token_names, contract_keywords, token_description, should_capitalize, decimals, base_supply, max_supply, start_paused: start_as_paused, allow_transfers_to_frozen_identities: allow_transfer_to_frozen_balance, keeps_history, main_control_group, manual_minting_rules, manual_burning_rules, freeze_rules, unfreeze_rules, destroy_frozen_funds_rules, emergency_action_rules, max_supply_change_rules, conventions_change_rules, main_control_group_change_authorized, distribution_rules, groups, document_schemas, marketplace_rules, transferable, } = params; // 1) Create the V1 struct first to get the contract ID let contract_id = Identifier::random(); let mut contract_v1 = DataContractV1 { id: contract_id, version: 1, owner_id, document_types: BTreeMap::new(), // Initialize empty, will populate below config: DataContractConfig::default_for_version(self.platform_version())?, schema_defs: None, groups, tokens: BTreeMap::new(), keywords: contract_keywords, created_at: None, updated_at: None, created_at_block_height: None, updated_at_block_height: None, created_at_epoch: None, updated_at_epoch: None, description: token_description.clone(), }; // 2) Parse document schemas if provided and add them to the contract if let Some(schemas) = document_schemas { for (name, schema_json) in schemas { // Convert serde_json::Value to platform_value::Value let platform_value = schema_json.into(); // Convert JSON schema to DocumentType using the proper parameters let mut validation_operations = Vec::new(); match dash_sdk::dpp::data_contract::document_type::DocumentType::try_from_schema( contract_id, 0, 0, &name, platform_value, None, // schema_defs &contract_v1.tokens, &contract_v1.config, true, // validate_required &mut validation_operations, self.platform_version(), ) { Ok(document_type) => { contract_v1.document_types.insert(name, document_type); } Err(e) => { return Err(ProtocolError::Generic(format!( "Failed to convert document schema '{}' to DocumentType: {}", name, e ))); } } } } // 3) Build a single TokenConfiguration in V0 format let mut token_config_v0 = TokenConfigurationV0::default_most_restrictive(); let TokenConfigurationConvention::V0(ref mut conv_v0) = token_config_v0.conventions; conv_v0.decimals = decimals; for (token_name, token_plural, language) in token_names { conv_v0.localizations.insert( language, TokenConfigurationLocalization::V0(TokenConfigurationLocalizationV0 { should_capitalize, singular_form: token_name, plural_form: token_plural, }), ); } token_config_v0.base_supply = base_supply; token_config_v0.max_supply = max_supply; token_config_v0.start_as_paused = start_as_paused; token_config_v0.allow_transfer_to_frozen_balance = allow_transfer_to_frozen_balance; token_config_v0.keeps_history = keeps_history; token_config_v0.main_control_group = main_control_group; token_config_v0.manual_minting_rules = manual_minting_rules; token_config_v0.manual_burning_rules = manual_burning_rules; token_config_v0.freeze_rules = freeze_rules; token_config_v0.unfreeze_rules = unfreeze_rules; token_config_v0.destroy_frozen_funds_rules = destroy_frozen_funds_rules; token_config_v0.emergency_action_rules = emergency_action_rules; token_config_v0.max_supply_change_rules = max_supply_change_rules; token_config_v0.conventions_change_rules = conventions_change_rules; token_config_v0.main_control_group_can_be_modified = main_control_group_change_authorized; token_config_v0.distribution_rules = distribution_rules; token_config_v0.description = token_description; // All tokens are created NotTradeable; a future SDK will add more modes. token_config_v0.marketplace_rules = TokenMarketplaceRules::V0(TokenMarketplaceRulesV0 { trade_mode: TokenTradeMode::NotTradeable, trade_mode_change_rules: marketplace_rules, }); let mut token_config = TokenConfiguration::V0(token_config_v0); // Upgrades to a version 1 configuration only for a token that cannot // be transferred, so a transferable token keeps the format every // network accepts. token_config.set_transferable(transferable); // 7) Insert this token config at position 0 contract_v1 .tokens .insert(TokenContractPosition::from(0u16), token_config); // 8) Wrap the whole struct in DataContract::V1 Ok(DataContract::V1(contract_v1)) } } #[cfg(test)] mod tests { use super::*; /// Once-per-identity rules are refused until the network accepts them; /// version 0 rules always pass. #[test] fn once_per_identity_rules_need_a_network_that_accepts_them() { use dash_sdk::dpp::data_contract::associated_token::token_configuration::v0::TokenConfigurationV0; let temp_dir = tempfile::tempdir().expect("tempdir"); let ctx = crate::context::test_support::test_app_context(temp_dir.path()); let TokenDistributionRules::V0(v0) = TokenConfigurationV0::default_most_restrictive().distribution_rules else { panic!("the default rules are version 0"); }; let v1 = crate::model::token::distribution_rules_with_once_per_identity(v0.clone(), Some(5)); let v0 = TokenDistributionRules::V0(v0); crate::context::test_support::prove_protocol_version(&ctx, 13); assert!(ctx.ensure_distribution_rules_supported(&v0).is_ok()); assert!(matches!( ctx.ensure_distribution_rules_supported(&v1), Err(TaskError::TokenOncePerIdentityNotSupported) )); crate::context::test_support::prove_protocol_version(&ctx, 14); assert!(ctx.ensure_distribution_rules_supported(&v1).is_ok()); } /// A token that cannot be transferred is refused until the network /// accepts one; a transferable token always passes. #[test] fn non_transferable_tokens_need_a_network_that_accepts_them() { let temp_dir = tempfile::tempdir().expect("tempdir"); let ctx = crate::context::test_support::test_app_context(temp_dir.path()); crate::context::test_support::prove_protocol_version(&ctx, 13); assert!(ctx.ensure_transferability_supported(true).is_ok()); assert!(matches!( ctx.ensure_transferability_supported(false), Err(TaskError::NonTransferableTokenNotSupported) )); crate::context::test_support::prove_protocol_version(&ctx, 14); assert!(ctx.ensure_transferability_supported(false).is_ok()); } #[tokio::test] async fn token_lookup_timeout_is_typed_and_actionable() { let error = crate::backend_task::await_network_request_with_timeout( std::time::Duration::from_millis(1), std::future::pending::<()>(), |source| TaskError::TokenLookupTimeout { source }, ) .await .expect_err("a pending token lookup must time out"); assert!(matches!(error, TaskError::TokenLookupTimeout { .. })); assert!(error.to_string().contains("Check your connection")); let error = crate::backend_task::await_network_request_with_timeout( std::time::Duration::from_millis(1), std::future::pending::<()>(), |source| TaskError::TokenBalanceRefreshTimeout { source }, ) .await .expect_err("a pending token balance refresh must time out"); assert!(matches!( error, TaskError::TokenBalanceRefreshTimeout { .. } )); assert!(error.to_string().contains("refresh the Tokens screen")); } #[tokio::test] async fn timed_out_managed_request_is_reaped_after_completion() { let (completed_tx, completed_rx) = tokio::sync::oneshot::channel(); let (release_tx, release_rx) = tokio::sync::oneshot::channel(); let task_manager = std::sync::Arc::new(crate::utils::tasks::TaskManager::new()); let error = crate::backend_task::await_managed_network_request_with_timeout( task_manager, "test_request_reaper", std::time::Duration::from_millis(1), async move { release_rx .await .expect("the test must release the timed-out request"); let _ = completed_tx.send(()); }, |source| TaskError::TokenBalanceRefreshTimeout { source }, ) .await .expect_err("the UI wait must time out before the request completes"); assert!(matches!( error, TaskError::TokenBalanceRefreshTimeout { .. } )); release_tx .send(()) .expect("the timed-out request must still be running"); tokio::time::timeout(std::time::Duration::from_secs(1), completed_rx) .await .expect("the managed request must keep running") .expect("the managed request must report completion"); } } #[cfg(test)] mod token_action_routing_tests { use super::*; use crate::backend_task::error::TokenOperationKind; use crate::context::test_support::{ mock_sdk_for, test_app_context, user_identity_with_signing_key, }; use crate::model::wallet::WalletSeedHash; use crate::utils::egui_mpsc::SenderAsync; use dash_sdk::dpp::dashcore::Network; use dash_sdk::dpp::data_contract::associated_token::token_configuration::v0::TokenConfigurationV0; use dash_sdk::dpp::identity::SecurityLevel; use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeySettersV0; use dash_sdk::dpp::version::PlatformVersion; /// A contract holding one most-restrictive token at position 0. fn token_contract(owner_id: Identifier) -> Arc { let mut contract = DataContractV1 { id: Identifier::random(), version: 1, owner_id, document_types: BTreeMap::new(), config: DataContractConfig::default_for_version(PlatformVersion::latest()) .expect("contract config"), schema_defs: None, groups: BTreeMap::new(), tokens: BTreeMap::new(), keywords: Vec::new(), created_at: None, updated_at: None, created_at_block_height: None, updated_at_block_height: None, created_at_epoch: None, updated_at_epoch: None, description: None, }; contract.tokens.insert( 0, TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), ); Arc::new(DataContract::V1(contract)) } /// An identity holding one CRITICAL authentication key, as token /// transitions require. fn actor_identity() -> (QualifiedIdentity, IdentityPublicKey) { let mut identity = user_identity_with_signing_key(Identifier::random(), Network::Testnet, true); let mut key = identity.identity.public_keys()[&1].clone(); key.set_security_level(SecurityLevel::CRITICAL); identity.identity.add_public_key(key.clone()); (identity, key) } /// Every token action `TokenTask` offers except the settings update (which /// reads its contract from storage first), with the operation it is. fn token_actions( identity: &QualifiedIdentity, key: &IdentityPublicKey, ) -> Vec<(TokenOperationKind, TokenTask)> { let contract = token_contract(identity.identity.id()); let other = Identifier::random(); let common = |identity: &QualifiedIdentity| { (identity.clone(), Arc::clone(&contract), 0u16, key.clone()) }; let (actor, data_contract, token_position, signing_key) = common(identity); vec![ ( TokenOperationKind::Mint, TokenTask::MintTokens { sending_identity: actor.clone(), data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), public_note: None, amount: 5, recipient_id: None, group_info: None, }, ), ( TokenOperationKind::Transfer, TokenTask::TransferTokens { sending_identity: actor.clone(), recipient_id: other, amount: 5, data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), public_note: None, }, ), ( TokenOperationKind::Burn, TokenTask::BurnTokens { owner_identity: actor.clone(), data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), public_note: None, amount: 5, group_info: None, }, ), ( TokenOperationKind::DestroyFrozenFunds, TokenTask::DestroyFrozenFunds { actor_identity: actor.clone(), data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), public_note: None, frozen_identity: other, group_info: None, }, ), ( TokenOperationKind::Freeze, TokenTask::FreezeTokens { actor_identity: actor.clone(), data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), public_note: None, freeze_identity: other, group_info: None, }, ), ( TokenOperationKind::Unfreeze, TokenTask::UnfreezeTokens { actor_identity: actor.clone(), data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), public_note: None, unfreeze_identity: other, group_info: None, }, ), ( TokenOperationKind::Pause, TokenTask::PauseTokens { actor_identity: actor.clone(), data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), public_note: None, group_info: None, }, ), ( TokenOperationKind::Resume, TokenTask::ResumeTokens { actor_identity: actor.clone(), data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), public_note: None, group_info: None, }, ), ( TokenOperationKind::Claim, TokenTask::ClaimTokens { data_contract: Arc::clone(&data_contract), token_position, actor_identity: actor.clone(), distribution_type: TokenDistributionType::PreProgrammed, signing_key: signing_key.clone(), public_note: None, }, ), ( TokenOperationKind::Purchase, TokenTask::PurchaseTokens { identity: actor.clone(), data_contract: Arc::clone(&data_contract), token_position, signing_key: signing_key.clone(), amount: 5, total_agreed_price: 500, }, ), ( TokenOperationKind::SetPrice, TokenTask::SetDirectPurchasePrice { identity: actor, data_contract, token_position, signing_key, token_pricing_schedule: Some(TokenPricingSchedule::SinglePrice(100)), public_note: None, group_info: None, }, ), ] } /// A context whose SDK is a mock with no expectations, so any request that /// reaches it fails, and whose wallet backend is wired. async fn offline_context( dir: &std::path::Path, ) -> ( Arc, SenderAsync, tokio::sync::mpsc::Receiver, ) { let ctx = test_app_context(dir); ctx.sdk.store(Arc::new(mock_sdk_for(&ctx))); let (tx, rx) = tokio::sync::mpsc::channel(64); let sender = SenderAsync::new(tx, ctx.egui_ctx().clone()); ctx.ensure_wallet_backend(sender.clone()) .await .expect("wire the wallet backend offline"); (ctx, sender, rx) } /// Register an HD wallet with the upstream manager and return its hash. async fn registered_wallet(ctx: &AppContext) -> WalletSeedHash { let seed = crate::test_support::keys::seed(); let wallet = crate::model::wallet::Wallet::new_from_seed(seed, Network::Testnet, None, None) .expect("build wallet"); let seed_hash = wallet.seed_hash(); ctx.wallet_backend() .expect("backend wired") .register_wallet_from_seed(&seed_hash, &seed, None) .await .expect("register the wallet upstream"); seed_hash } /// `identity` with `key` as an ECDSA key whose private half it holds. fn holding_its_key( mut identity: QualifiedIdentity, mut key: IdentityPublicKey, ) -> (QualifiedIdentity, IdentityPublicKey) { use crate::model::qualified_identity::PrivateKeyTarget; use crate::model::qualified_identity::encrypted_key_storage::{KeyStorage, PrivateKeyData}; use dash_sdk::dpp::identity::KeyType; use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; let secret = crate::test_support::keys::secret_key(); let public = secret.public_key(); key.set_key_type(KeyType::ECDSA_SECP256K1); key.set_data(public.serialize().to_vec().into()); identity.identity.add_public_key(key.clone()); identity.private_keys = KeyStorage::from(BTreeMap::from([( (PrivateKeyTarget::PrivateKeyOnMainIdentity, key.id()), ( key.clone().into(), PrivateKeyData::Clear(*secret.as_secret_bytes()), ), )])); (identity, key) } /// A mint at a token position the contract does not have fails before /// anything is signed, with the error the wallet route reports, instead /// of sending the chosen recipient unchecked. #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn an_sdk_mint_at_a_missing_token_position_fails_like_the_wallet_route() { use dash_sdk::dpp::data_contract::accessors::v1::DataContractV1Getters; let dir = tempfile::tempdir().expect("tempdir"); let (ctx, sender, _rx) = offline_context(dir.path()).await; let (identity, key) = actor_identity(); let (identity, key) = holding_its_key(identity, key); ctx.insert_local_qualified_identity(&identity, &None) .expect("store the wallet-less identity"); let data_contract = token_contract(identity.identity.id()); let missing_position = 1; let upstream_error = data_contract .expected_token_configuration(missing_position) .expect_err("the contract has no token at that position"); let sdk = (*ctx.sdk.load_full()).clone(); let err = ctx .run_token_task( TokenTask::MintTokens { sending_identity: identity.clone(), data_contract, token_position: missing_position, signing_key: key, public_note: None, amount: 5, recipient_id: Some(Identifier::random()), group_info: None, }, &sdk, sender, ) .await .expect_err("no token at that position"); let expected = TaskError::from_token_operation( TokenOperationKind::Mint, dash_sdk::Error::Protocol(upstream_error), ); assert_eq!(format!("{err:?}"), format!("{expected:?}")); } /// An identity no wallet in this app holds (a masternode or key-only /// identity) still acts on tokens: each action is built through the SDK /// and signed with the identity's own key, without borrowing a loaded /// wallet. Holding the key gets every action past signing; without it, /// the identity's signer refuses and says the key is missing. #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn token_actions_of_an_identity_no_wallet_holds_are_signed_by_the_identity() { use dash_sdk::dpp::data_contract::accessors::v0::DataContractV0Getters; use dash_sdk::query_types::IdentityContractNonceFetcher; let dir = tempfile::tempdir().expect("tempdir"); let (ctx, sender, _rx) = offline_context(dir.path()).await; registered_wallet(&ctx).await; let (identity, key) = actor_identity(); let (identity, key) = holding_its_key(identity, key); ctx.insert_local_qualified_identity(&identity, &None) .expect("store the wallet-less identity"); assert!( ctx.token_action_availability(&identity.identity.id()) .expect("availability") .is_available() ); assert!( !ctx.token_actor(&identity) .await .expect("an actor") .is_wallet_held() ); let mut keyless = identity.clone(); keyless.private_keys = Default::default(); for (signer, signs) in [(&identity, true), (&keyless, false)] { let actions = token_actions(signer, &key); let Some((_, TokenTask::MintTokens { data_contract, .. })) = actions.first() else { panic!("the first action is a mint"); }; let mut sdk = (*ctx.sdk.load_full()).clone(); sdk.mock() .expect_fetch( (identity.identity.id(), data_contract.id()), Some(IdentityContractNonceFetcher(0)), ) .await .expect("mock the identity-contract nonce"); ctx.sdk.store(Arc::new(sdk.clone())); for (kind, task) in actions { let err = ctx .run_token_task(task, &sdk, sender.clone()) .await .expect_err("the mock SDK accepts no broadcast"); if !signs { // The user is told the key is missing, not to check the connection. assert!( matches!(err, TaskError::IdentitySigningKeyMissing { .. }), "{kind:?} without the key: {err:?}" ); continue; } let TaskError::TokenOperationFailed { operation, source_error, } = &err else { panic!("{kind:?}: {err:?}"); }; assert_eq!(*operation, kind); assert!( !matches!(**source_error, dash_sdk::Error::Protocol(_)), "{kind:?} got past signing: {err:?}" ); } } } /// Each token action of a wallet-held identity runs through upstream's /// token API on the wallet backend: the mock SDK's failure comes back /// labelled with that action's operation. #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn token_actions_of_a_wallet_held_identity_go_through_platform_wallet() { let dir = tempfile::tempdir().expect("tempdir"); let (ctx, sender, _rx) = offline_context(dir.path()).await; let seed_hash = registered_wallet(&ctx).await; let (identity, key) = actor_identity(); ctx.insert_local_qualified_identity(&identity, &Some((seed_hash, 0))) .expect("store the wallet-held identity"); assert!( ctx.token_action_availability(&identity.identity.id()) .expect("availability") .is_available() ); assert!( ctx.token_actor(&identity) .await .expect("an actor") .is_wallet_held() ); let sdk = ctx.sdk.load_full(); for (kind, task) in token_actions(&identity, &key) { let err = ctx .run_token_task(task, &sdk, sender.clone()) .await .expect_err("the mock SDK answers nothing"); assert!( matches!( err, TaskError::TokenOperationFailed { operation, .. } | TaskError::TokenOperationRejected { operation, .. } if operation == kind ), "{kind:?}: {err:?}" ); } } /// A completed token action reports the same fee estimate its /// confirmation screens show (`estimate_token_transition`). #[tokio::test] async fn token_action_reports_the_fee_its_screens_show() { let dir = tempfile::tempdir().expect("tempdir"); let ctx = test_app_context(dir.path()); let result = ctx .execute_token_op( async { Ok::<_, TaskError>(()) }, |()| {}, BackendTaskSuccessResult::MintedTokens, ) .await .expect("a successful action"); let BackendTaskSuccessResult::MintedTokens(fee) = result else { panic!("got {result:?}"); }; assert_eq!( fee, FeeResult::estimated_only(ctx.fee_estimator().estimate_token_transition()) ); } /// An identity whose wallet was removed from the app acts as a /// wallet-less one again: it is not told to wait for a wallet that no /// longer exists, and its actions go through the SDK. #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn token_actions_of_an_identity_whose_wallet_was_removed_go_through_the_sdk() { use crate::model::wallet::birth_height::WalletOrigin; let dir = tempfile::tempdir().expect("tempdir"); let (ctx, sender, _rx) = offline_context(dir.path()).await; ctx.prepare_storage(sender).await.expect("prepare storage"); let seed = crate::test_support::keys::seed(); let wallet = crate::model::wallet::Wallet::new_from_seed(seed, Network::Testnet, None, None) .expect("build wallet"); let (seed_hash, _) = ctx .register_wallet(wallet, &seed, WalletOrigin::Imported) .expect("register the wallet"); let (identity, _) = actor_identity(); ctx.insert_local_qualified_identity(&identity, &Some((seed_hash, 0))) .expect("link the identity to the wallet"); assert_eq!( ctx.token_action_wallet(&identity.identity.id()) .expect("the identity's wallet"), Some(seed_hash), "a wallet the app knows, loaded or not, carries the identity's actions" ); ctx.remove_wallet(&seed_hash).expect("remove the wallet"); assert_eq!( ctx.token_action_availability(&identity.identity.id()) .expect("availability"), crate::model::token::TokenActionAvailability::Available ); assert!( !ctx.token_actor(&identity) .await .expect("an actor") .is_wallet_held() ); } /// An identity whose wallet is known but not loaded waits for it. #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn token_actions_wait_for_the_identitys_wallet_to_load() { let dir = tempfile::tempdir().expect("tempdir"); let (ctx, sender, _rx) = offline_context(dir.path()).await; let (identity, key) = actor_identity(); let unloaded: WalletSeedHash = [0x4E; 32]; ctx.insert_local_qualified_identity(&identity, &Some((unloaded, 0))) .expect("store the identity of an unloaded wallet"); assert_eq!( ctx.token_action_availability(&identity.identity.id()) .expect("availability"), crate::model::token::TokenActionAvailability::WalletNotOpen ); let sdk = ctx.sdk.load_full(); let (_, task) = token_actions(&identity, &key).remove(0); let err = ctx .run_token_task(task, &sdk, sender) .await .expect_err("the wallet is not loaded"); assert!( matches!( err, TaskError::WalletNotLoaded { .. } | TaskError::WalletLockedNotLoaded { .. } ), "{err:?}" ); } }