fix(wallets): use selector ceiling for asset-lock Max

CHANGELOG.md

@@ -46,6 +46,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Fixed
 
+- **"Max" now matches what your Core wallet can actually send**: pressing
+  "Max" when shielding DASH, funding a Platform address, or funding an
+  identity (creating or topping up, from your wallet balance or a received
+  deposit) could suggest an amount larger than the wallet could actually
+  send, so the transaction was rejected no matter how you adjusted it. Max
+  and the amount check now ask the wallet directly what it can send instead
+  of estimating from an on-screen balance, so the two stay in agreement.
+  While that check is running, the amount field shows "Checking the
+  available amount..."; if the check fails, a "Retry" button appears in its
+  place.
+
 - **Wallet rename consistency**: renaming a wallet no longer overwrites other
   saved wallet details when metadata cannot be read. Overlapping renames and
   wallet removals also keep displayed aliases and deleted-wallet metadata

src/backend_task/error.rs

@@ -234,6 +234,17 @@ pub enum TaskError {
         >,
     },
 
+    /// The read-only asset-lock builder probe could not determine a safe Max.
+    #[error(
+        "The wallet's available amount could not be checked. Wait a moment and try again."
+    )]
+    AssetLockBalanceQueryFailed {
+        #[source]
+        source: Box<
+            dash_sdk::dpp::key_wallet::wallet::managed_wallet_info::transaction_builder::BuilderError,
+        >,
+    },
+
     /// The payment would need more individual unspent outputs than fit in a
     /// single standard transaction.
     #[error(

src/backend_task/mod.rs

@@ -331,6 +331,11 @@ pub enum BackendTaskContext {
     ScheduledVoteSweep { network: Network },
     /// Receive-address derivation for one wallet's deposit flow.
     GenerateReceiveAddress { seed_hash: WalletSeedHash },
+    /// Live asset-lock builder ceiling query for one wallet.
+    AssetLockMaxAmount {
+        seed_hash: WalletSeedHash,
+        snapshot_generation: u64,
+    },
     /// One HD-wallet or imported-key alias update.
     WalletRename(WalletTask),
     /// A known backend task that needs no finer UI correlation.
@@ -387,6 +392,16 @@ impl BackendTaskContext {
         }
     }
 
+    pub(crate) fn asset_lock_max_amount_request(&self) -> Option<(WalletSeedHash, u64)> {
+        match self.operation() {
+            Self::AssetLockMaxAmount {
+                seed_hash,
+                snapshot_generation,
+            } => Some((*seed_hash, *snapshot_generation)),
+            _ => None,
+        }
+    }
+
     pub(crate) fn wallet_rename_task(&self) -> Option<&WalletTask> {
         match self.operation() {
             Self::WalletRename(task) => Some(task),
@@ -434,6 +449,13 @@ impl From<&BackendTask> for BackendTaskContext {
                     seed_hash: *seed_hash,
                 }
             }
+            BackendTask::WalletTask(WalletTask::GetAssetLockMaxAmount {
+                seed_hash,
+                snapshot_generation,
+            }) => Self::AssetLockMaxAmount {
+                seed_hash: *seed_hash,
+                snapshot_generation: *snapshot_generation,
+            },
             BackendTask::WalletTask(
                 task @ (WalletTask::RenameHdWallet { .. }
                 | WalletTask::RenameSingleKeyWallet { .. }),
@@ -601,6 +623,12 @@ pub enum BackendTaskSuccessResult {
         seed_hash: WalletSeedHash,
         locks: Vec<platform_wallet::wallet::asset_lock::tracked::TrackedAssetLock>,
     },
+    /// Largest asset-lock credit output the live upstream builder accepts.
+    AssetLockMaxAmount {
+        seed_hash: WalletSeedHash,
+        snapshot_generation: u64,
+        amount_duffs: u64,
+    },
     /// Platform address balances fetched from Platform
     PlatformAddressBalances {
         seed_hash: WalletSeedHash,
@@ -1243,6 +1271,19 @@ impl AppContext {
                 .list_tracked_asset_locks(&seed_hash)
                 .await
                 .map(|locks| BackendTaskSuccessResult::TrackedAssetLocks { seed_hash, locks }),
+            WalletTask::GetAssetLockMaxAmount {
+                seed_hash,
+                snapshot_generation,
+            } => backend
+                .asset_lock_max_amount(&seed_hash)
+                .await
+                .map(
+                    |amount_duffs| BackendTaskSuccessResult::AssetLockMaxAmount {
+                        seed_hash,
+                        snapshot_generation,
+                        amount_duffs,
+                    },
+                ),
             WalletTask::FetchPlatformAddressBalances { seed_hash } => {
                 self.fetch_platform_address_balances(seed_hash).await
             }

src/backend_task/wallet/mod.rs

@@ -224,6 +224,12 @@ pub enum WalletTask {
     ListTrackedAssetLocks {
         seed_hash: WalletSeedHash,
     },
+    /// Dry-run the live upstream asset-lock builder to obtain the largest
+    /// credit output its current UTXO set can fund.
+    GetAssetLockMaxAmount {
+        seed_hash: WalletSeedHash,
+        snapshot_generation: u64,
+    },
     /// Fund Platform addresses from a tracked asset lock identified by its
     /// credit-output outpoint. The proof and credit-output key are recovered
     /// from the upstream `AssetLockManager` and the wallet's funding

src/context/mod.rs

@@ -1461,6 +1461,13 @@ impl AppContext {
             .unwrap_or_default()
     }
 
+    /// Monotonic generation of the event-pushed snapshot for one wallet.
+    pub fn snapshot_generation(&self, seed_hash: &WalletSeedHash) -> u64 {
+        self.wallet_backend()
+            .map(|wb| wb.wallet_snapshot_generation(seed_hash))
+            .unwrap_or_default()
+    }
+
     /// Number of UTXOs in the wallet's display snapshot. Used to estimate the
     /// Core (L1) transaction fee for a "Max" send, which spends every UTXO.
     ///

src/model/asset_lock.rs

@@ -0,0 +1,51 @@
+//! Stateless asset-lock amount calculations shared by UI flows.
+
+/// Why an asset-lock amount is outside the builder-derived ceiling.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AssetLockAmountError {
+    /// Adding the operation-specific reserve exceeded the amount range.
+    Overflow,
+    /// The requested amount plus its reserve exceeds the builder ceiling.
+    ExceedsMaximum { maximum_amount_duffs: u64 },
+}
+
+/// Largest user-entered amount after reserving operation-specific fees.
+///
+/// Both arguments must use the same unit (duffs or Platform credits).
+pub fn asset_lock_user_max_amount(builder_max: u64, reserve: u64) -> u64 {
+    builder_max.saturating_sub(reserve)
+}
+
+/// Validate a user-entered amount against the live builder-derived ceiling.
+pub fn validate_asset_lock_amount(
+    amount_duffs: u64,
+    reserve_duffs: u64,
+    builder_max_duffs: u64,
+) -> Result<(), AssetLockAmountError> {
+    let required_duffs = amount_duffs
+        .checked_add(reserve_duffs)
+        .ok_or(AssetLockAmountError::Overflow)?;
+    if required_duffs > builder_max_duffs {
+        return Err(AssetLockAmountError::ExceedsMaximum {
+            maximum_amount_duffs: asset_lock_user_max_amount(builder_max_duffs, reserve_duffs),
+        });
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{AssetLockAmountError, asset_lock_user_max_amount, validate_asset_lock_amount};
+
+    #[test]
+    fn builder_ceiling_validation_reserves_operation_fee() {
+        assert_eq!(asset_lock_user_max_amount(10_000, 1_000), 9_000);
+        assert_eq!(validate_asset_lock_amount(9_000, 1_000, 10_000), Ok(()));
+        assert_eq!(
+            validate_asset_lock_amount(9_001, 1_000, 10_000),
+            Err(AssetLockAmountError::ExceedsMaximum {
+                maximum_amount_duffs: 9_000,
+            })
+        );
+    }
+}

src/model/mod.rs

@@ -1,5 +1,6 @@
 pub mod address;
 pub mod amount;
+pub mod asset_lock;
 pub mod contested_name;
 pub mod dashpay;
 pub mod dashpay_derivation;

src/ui/identities/add_new_identity_screen/by_receive_deposit.rs

@@ -145,6 +145,19 @@ impl AddNewIdentityScreen {
         let mut action = AppAction::None;
         self.reconcile_funding_deposit();
         let step = *self.step.read_recover();
+        let seed_hash = self
+            .selected_wallet
+            .as_ref()
+            .and_then(|wallet| wallet.read().ok().map(|wallet| wallet.seed_hash()));
+        if let Some(seed_hash) = seed_hash {
+            let snapshot_generation = self.app_context.snapshot_generation(&seed_hash);
+            if let Some(task) = self
+                .asset_lock_balance
+                .ensure_requested(seed_hash, snapshot_generation)
+            {
+                action |= AppAction::BackendTask(task);
+            }
+        }
 
         if step == WalletFundedScreenStep::WaitingOnFunds {
             ui.heading(format!(
@@ -171,6 +184,20 @@ impl AddNewIdentityScreen {
         // committed to the pending transaction, so the input's max recomputes to
         // 0 and would show a stale "exceeds maximum" error over a succeeding op.
         if step == WalletFundedScreenStep::FundsReceived {
+            let Some(seed_hash) = seed_hash else {
+                return action;
+            };
+            if self.asset_lock_balance.is_failed(&seed_hash) {
+                ui.label("The available amount could not be checked.");
+                if ui.button("Retry available amount check").clicked() {
+                    self.asset_lock_balance.invalidate_one(&seed_hash);
+                }
+                return action;
+            }
+            if self.asset_lock_balance.get(&seed_hash).is_none() {
+                ui.label("Checking the available amount…");
+                return action;
+            }
             self.render_funding_amount_input(ui);
 
             let has_valid_amount = self

src/ui/identities/add_new_identity_screen/by_using_unused_balance.rs

@@ -19,10 +19,11 @@ impl AddNewIdentityScreen {
                 }
             };
 
-            let spendable_balance: u64 = self
-                .app_context
-                .snapshot_balance(&wallet.seed_hash())
-                .spendable();
+            let seed_hash = wallet.seed_hash();
+            let spendable_balance = self
+                .asset_lock_balance
+                .get(&seed_hash)
+                .unwrap_or_else(|| self.app_context.snapshot_balance(&seed_hash).spendable());
 
             let dash_balance = spendable_balance as f64 * 1e-8; // Convert to DASH units
 
@@ -45,10 +46,7 @@ impl AddNewIdentityScreen {
     fn render_insufficient_wallet_balance_banner(&self, ui: &mut egui::Ui) -> Option<AppAction> {
         let selected_wallet = self.selected_wallet.as_ref()?;
         let spendable_duffs = match selected_wallet.read() {
-            Ok(w) => self
-                .app_context
-                .snapshot_balance(&w.seed_hash())
-                .spendable(),
+            Ok(w) => self.asset_lock_balance.get(&w.seed_hash())?,
             Err(_) => {
                 ui.label("Wallet is busy. Try again in a moment.");
                 return Some(AppAction::None);
@@ -102,8 +100,35 @@ impl AddNewIdentityScreen {
         self.show_wallet_balance(ui);
         ui.add_space(5.0);
 
+        let seed_hash = self
+            .selected_wallet
+            .as_ref()
+            .and_then(|wallet| wallet.read().ok().map(|wallet| wallet.seed_hash()));
+        let Some(seed_hash) = seed_hash else {
+            return action;
+        };
+        let snapshot_generation = self.app_context.snapshot_generation(&seed_hash);
+        if let Some(task) = self
+            .asset_lock_balance
+            .ensure_requested(seed_hash, snapshot_generation)
+        {
+            action |= AppAction::BackendTask(task);
+        }
+        if self.asset_lock_balance.is_failed(&seed_hash) {
+            ui.label("The available amount could not be checked.");
+            if ui.button("Retry available amount check").clicked() {
+                self.asset_lock_balance.invalidate_one(&seed_hash);
+            }
+            return action;
+        }
+        if self.asset_lock_balance.get(&seed_hash).is_none() {
+            ui.label("Checking the available amount…");
+            return action;
+        }
+
         if let Some(insufficient_action) = self.render_insufficient_wallet_balance_banner(ui) {
-            return insufficient_action;
+            action |= insufficient_action;
+            return action;
         }
 
         self.render_funding_amount_input(ui);