refactor: use state transitions to estimate fees for identity create and top up

src/backend_task/identity/mod.rs

@@ -558,10 +558,24 @@ impl AppContext {
         wallet_seed_hash: WalletSeedHash,
     ) -> Result<BackendTaskSuccessResult, String> {
         use crate::model::fee_estimation::PlatformFeeEstimator;
+        use dash_sdk::dpp::prelude::AddressNonce;
         use dash_sdk::platform::transition::top_up_identity_from_addresses::TopUpIdentityFromAddresses;
 
         // Estimate fee for top-up from platform addresses
-        let estimated_fee = PlatformFeeEstimator::new().estimate_identity_topup();
+        let inputs_with_nonce: BTreeMap<
+            dash_sdk::dpp::address_funds::PlatformAddress,
+            (AddressNonce, Credits),
+        > = inputs
+            .iter()
+            .map(|(addr, credits)| (*addr, (0, *credits)))
+            .collect();
+        let estimated_fee = PlatformFeeEstimator::new()
+            .estimate_identity_topup_from_addresses_fee_from_transition(
+                sdk.version(),
+                &inputs_with_nonce,
+                None,
+                qualified_identity.identity.id(),
+            );
 
         tracing::info!(
             "top_up_identity_from_platform_addresses: identity={}, inputs={:?}",

src/backend_task/identity/register_identity.rs

@@ -733,12 +733,13 @@ impl AppContext {
 
         // Calculate fee estimate for identity creation from platform addresses
         let key_count = public_keys.len();
-        let input_count = inputs.len();
-        let estimated_fee = PlatformFeeEstimator::new().estimate_identity_create_from_addresses(
-            input_count,
-            false,
-            key_count,
-        );
+        let estimated_fee = PlatformFeeEstimator::new()
+            .estimate_identity_create_from_addresses_fee_from_transition(
+                sdk.version(),
+                &inputs,
+                None,
+                key_count,
+            );
 
         // Clone the wallet for use as the address signer (needed across async boundary)
         let wallet_clone = { wallet.read().map_err(|e| e.to_string())?.clone() };

src/model/fee_estimation.rs

@@ -12,7 +12,21 @@
 //! performed by Platform. For accurate fees, use Platform's EstimateStateTransitionFee
 //! endpoint (when available).
 
+use dash_sdk::dpp::address_funds::{AddressFundsFeeStrategyStep, PlatformAddress};
+use dash_sdk::dpp::balances::credits::Credits;
+use dash_sdk::dpp::identity::core_script::CoreScript;
+use dash_sdk::dpp::prelude::{AddressNonce, Identifier};
+use dash_sdk::dpp::state_transition::StateTransitionEstimatedFeeValidation;
+use dash_sdk::dpp::state_transition::address_credit_withdrawal_transition::AddressCreditWithdrawalTransition;
+use dash_sdk::dpp::state_transition::address_credit_withdrawal_transition::v0::AddressCreditWithdrawalTransitionV0;
+use dash_sdk::dpp::state_transition::identity_create_from_addresses_transition::IdentityCreateFromAddressesTransition;
+use dash_sdk::dpp::state_transition::identity_create_from_addresses_transition::v0::IdentityCreateFromAddressesTransitionV0;
+use dash_sdk::dpp::state_transition::identity_topup_from_addresses_transition::IdentityTopUpFromAddressesTransition;
+use dash_sdk::dpp::state_transition::identity_topup_from_addresses_transition::v0::IdentityTopUpFromAddressesTransitionV0;
+use dash_sdk::dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
 use dash_sdk::dpp::version::PlatformVersion;
+use dash_sdk::dpp::withdrawal::Pooling;
+use std::collections::BTreeMap;
 
 /// Storage fee constants from FEE_STORAGE_VERSION1 in rs-platform-version.
 /// These determine the cost of storing and processing data on Platform.
@@ -629,6 +643,86 @@ impl PlatformFeeEstimator {
     pub fn storage_fees(&self) -> &StorageFeeConstants {
         &self.storage_fees
     }
+
+    /// Estimate fee for address credit withdrawal using a constructed state transition.
+    pub fn estimate_withdrawal_fee_from_transition(
+        &self,
+        platform_version: &PlatformVersion,
+        inputs: &BTreeMap<PlatformAddress, u64>,
+        output_script: &CoreScript,
+    ) -> u64 {
+        let inputs_with_nonce: BTreeMap<PlatformAddress, (AddressNonce, Credits)> = inputs
+            .iter()
+            .map(|(addr, amount)| (*addr, (0, *amount)))
+            .collect();
+
+        let transition =
+            AddressCreditWithdrawalTransition::V0(AddressCreditWithdrawalTransitionV0 {
+                inputs: inputs_with_nonce,
+                output: None,
+                fee_strategy: vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
+                core_fee_per_byte: 1,
+                pooling: Pooling::Never,
+                output_script: output_script.clone(),
+                user_fee_increase: 0,
+                input_witnesses: Vec::new(),
+            });
+
+        transition
+            .calculate_min_required_fee(platform_version)
+            .unwrap_or(0)
+    }
+
+    /// Estimate fee for identity creation from Platform addresses using a constructed state transition.
+    pub fn estimate_identity_create_from_addresses_fee_from_transition(
+        &self,
+        platform_version: &PlatformVersion,
+        inputs: &BTreeMap<PlatformAddress, (AddressNonce, Credits)>,
+        output: Option<(PlatformAddress, Credits)>,
+        key_count: usize,
+    ) -> u64 {
+        let public_keys = match IdentityPublicKeyInCreation::default_versioned(platform_version) {
+            Ok(key) => std::iter::repeat(key).take(key_count).collect(),
+            Err(_) => Vec::new(),
+        };
+
+        let transition =
+            IdentityCreateFromAddressesTransition::V0(IdentityCreateFromAddressesTransitionV0 {
+                public_keys,
+                inputs: inputs.clone(),
+                output,
+                fee_strategy: vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
+                user_fee_increase: 0,
+                input_witnesses: Vec::new(),
+            });
+
+        transition
+            .calculate_min_required_fee(platform_version)
+            .unwrap_or(0)
+    }
+
+    /// Estimate fee for identity top-up from Platform addresses using a constructed state transition.
+    pub fn estimate_identity_topup_from_addresses_fee_from_transition(
+        &self,
+        platform_version: &PlatformVersion,
+        inputs: &BTreeMap<PlatformAddress, (AddressNonce, Credits)>,
+        output: Option<(PlatformAddress, Credits)>,
+        identity_id: Identifier,
+    ) -> u64 {
+        let transition =
+            IdentityTopUpFromAddressesTransition::V0(IdentityTopUpFromAddressesTransitionV0 {
+                inputs: inputs.clone(),
+                output,
+                identity_id,
+                fee_strategy: vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
+                user_fee_increase: 0,
+                input_witnesses: Vec::new(),
+            });
+
+        transition
+            .calculate_min_required_fee(platform_version)
+            .unwrap_or(0)
+    }
 }
 
 /// Credits per DASH constant

src/ui/identities/add_new_identity_screen/by_platform_address.rs

@@ -1,6 +1,8 @@
 use crate::app::AppAction;
 use crate::model::amount::Amount;
 use crate::model::fee_estimation::format_credits_as_dash;
+use dash_sdk::dpp::balances::credits::Credits;
+use dash_sdk::dpp::prelude::AddressNonce;
 use crate::ui::components::amount_input::AmountInput;
 use crate::ui::components::component_trait::{Component, ComponentResponse};
 use crate::ui::identities::add_new_identity_screen::{
@@ -152,15 +154,22 @@ impl AddNewIdentityScreen {
 
         // Calculate estimated fee for identity creation (needed for max amount calculation)
         let key_count = self.identity_keys.keys_input.len() + 1; // +1 for master key
-        let input_count = if self.selected_platform_address_for_funding.is_some() {
-            1
-        } else {
-            0
-        };
+        let inputs: std::collections::BTreeMap<PlatformAddress, (AddressNonce, Credits)> = self
+            .selected_platform_address_for_funding
+            .as_ref()
+            .map(|(platform_addr, amount)| {
+                std::collections::BTreeMap::from([(*platform_addr, (0, *amount))])
+            })
+            .unwrap_or_default();
         let estimated_fee = self
             .app_context
             .fee_estimator()
-            .estimate_identity_create_from_addresses(input_count, false, key_count);
+            .estimate_identity_create_from_addresses_fee_from_transition(
+                self.app_context.platform_version(),
+                &inputs,
+                None,
+                key_count,
+            );
 
         // Calculate max amount with fee reserved
         let max_amount_with_fee_reserved =

src/ui/identities/top_up_identity_screen/by_platform_address.rs

@@ -11,6 +11,8 @@ use crate::ui::theme::DashColors;
 use dash_sdk::dpp::address_funds::PlatformAddress;
 use dash_sdk::dpp::balances::credits::Credits;
 use dash_sdk::dpp::dashcore::Address;
+use dash_sdk::dpp::identity::accessors::IdentityGettersV0;
+use dash_sdk::dpp::prelude::AddressNonce;
 use egui::{Frame, Margin, RichText, Ui};
 use std::collections::BTreeMap;
 
@@ -97,8 +99,20 @@ impl TopUpIdentityScreen {
             .map(|(_, _, balance)| *balance);
 
         // Calculate estimated fee for top-up from platform address (needed for max amount calculation)
-        let fee_estimator = self.app_context.fee_estimator();
-        let estimated_fee = fee_estimator.estimate_identity_topup_from_addresses(1);
+        let inputs: BTreeMap<PlatformAddress, (AddressNonce, Credits)> = self
+            .selected_platform_address
+            .as_ref()
+            .map(|(_, platform_addr, balance)| BTreeMap::from([(*platform_addr, (0, *balance))]))
+            .unwrap_or_default();
+        let estimated_fee = self
+            .app_context
+            .fee_estimator()
+            .estimate_identity_topup_from_addresses_fee_from_transition(
+                self.app_context.platform_version(),
+                &inputs,
+                None,
+                self.identity.identity.id(),
+            );
 
         // Calculate max amount with fee reserved
         let max_amount_with_fee_reserved =