dashpay · lklimek · May 4, 2026 · Apr 29, 2026 · Apr 29, 2026 · Apr 29, 2026
@@ -582,6 +582,36 @@ pub struct PlatformAddressChangeSet {
     /// Last block height with recent address changes (compaction marker).
     /// `None` means "no change".
     pub last_known_recent_block: Option<u64>,
+    /// Lower-bound static fee estimate for the transfer that produced
+    /// this changeset, in credits. `0` for changesets not produced by
+    /// `transfer()` (e.g. sync-only changesets). See
+    /// [`Self::estimated_min_fee`].
+    pub fee: Credits,
+}
+
+impl PlatformAddressChangeSet {
+    /// Lower-bound static fee estimate for the transfer that produced
+    /// this changeset, in credits.
+    ///
+    /// Returns `0` for changesets that didn't originate from a
+    /// `transfer()` call — e.g. sync-only changesets, or changesets
+    /// constructed via `Default::default()`. The value is the raw
+    /// `AddressFundsTransferTransition::estimate_min_fee(input_count,
+    /// output_count, version)` result captured at submit time — it is
+    /// **NOT** the actual on-chain fee and is **NOT** adjusted by the
+    /// `fee_strategy`.
+    ///
+    /// `estimate_min_fee` only models the static
+    /// `state_transition_min_fees` floor; chain-time fees include
+    /// storage + processing costs that scale with the operation set
+    /// (~6.5M static vs ~14.94M observed real for 1in/1out at the time
+    /// of writing). Tests asserting on the actual chain-time debit
+    /// must read the post-broadcast balance delta directly, not this
+    /// value. See platform issue #3040 for the open ticket on
+    /// upgrading `estimate_min_fee` to a chain-time-accurate estimate.
+    pub fn estimated_min_fee(&self) -> Credits {
+        self.fee
+    }
 }
 
 impl Merge for PlatformAddressChangeSet {
@@ -606,13 +636,20 @@ impl Merge for PlatformAddressChangeSet {
                     .map_or(r, |existing| existing.max(r)),
             );
         }
+        // Fee: append-sum via `saturating_add`. Sync-only merges
+        // (`fee == 0`) are a no-op so a transfer's recorded fee
+        // survives untouched; merging two transfer changesets sums
+        // the per-operation fees so the merged total reflects the
+        // "total fee paid across operations in this batch" intent.
+        self.fee = self.fee.saturating_add(other.fee);
     }
 
     fn is_empty(&self) -> bool {
         self.addresses.is_empty()
             && self.sync_height.is_none()
             && self.sync_timestamp.is_none()
             && self.last_known_recent_block.is_none()
+            && self.fee == 0
     }
 }
 

@@ -104,6 +104,20 @@ impl IdentityManager {
                 .sum::<usize>()
     }
 
+    /// Snapshot of every managed identity's `Identifier` across both
+    /// buckets. Order is unspecified — callers that need a stable
+    /// order should sort the returned `Vec`.
+    pub fn identity_ids(&self) -> Vec<Identifier> {
+        let mut out: Vec<Identifier> = Vec::with_capacity(self.identity_count());
+        out.extend(self.out_of_wallet_identities.keys().copied());
+        for inner in self.wallet_identities.values() {
+            for managed in inner.values() {
+                out.push(managed.identity.id());
+            }
+        }
+        out
+    }
+
     /// `true` iff both buckets are empty.
     pub fn is_empty(&self) -> bool {
         self.out_of_wallet_identities.is_empty() && self.wallet_identities.is_empty()

@@ -421,6 +421,18 @@ impl PlatformPaymentAddressProvider {
         self.last_known_recent_block = result.last_known_recent_block;
     }
 
+    /// Current `last_known_recent_block` watermark.
+    ///
+    /// Read-only mirror of the field used by the trait
+    /// implementation; exposed `pub` so wallet-level helpers
+    /// (notably [`super::wallet::PlatformAddressWallet::sync_watermark`])
+    /// can return the value to callers without going through the
+    /// `AddressProvider` trait. Monotonic non-decreasing across
+    /// `sync_finished` calls.
+    pub fn last_known_recent_block(&self) -> u64 {
+        self.last_known_recent_block
+    }
+
     /// Restore incremental-sync watermark from persisted state.
     pub(crate) fn set_stored_sync_state(
         &mut self,

@@ -45,32 +45,44 @@ impl PlatformAddressWallet {
 
         let version = platform_version.unwrap_or(LATEST_PLATFORM_VERSION);
 
-        let address_infos = match input_selection {
+        // Capture (input_count, output_count) so we can compute the
+        // fee paid after broadcast for `PlatformAddressChangeSet::fee`.
+        // The output map is consumed by the SDK call below; the
+        // input map is materialized (`Auto`) or is the caller's
+        // (`Explicit*`).
+        let output_count = outputs.len();
+        let (address_infos, input_count) = match input_selection {
             InputSelection::Explicit(inputs) => {
                 if inputs.is_empty() {
                     return Err(PlatformWalletError::AddressOperation(
                         "Transfer requires at least one input address".to_string(),
                     ));
                 }
-                self.sdk
+                let n = inputs.len();
+                let infos = self
+                    .sdk
                     .transfer_address_funds(inputs, outputs, fee_strategy, address_signer, None)
-                    .await?
+                    .await?;
+                (infos, n)
             }
             InputSelection::ExplicitWithNonces(inputs) => {
                 if inputs.is_empty() {
                     return Err(PlatformWalletError::AddressOperation(
                         "Transfer requires at least one input address".to_string(),
                     ));
                 }
-                self.sdk
+                let n = inputs.len();
+                let infos = self
+                    .sdk
                     .transfer_address_funds_with_nonce(
                         inputs,
                         outputs,
                         fee_strategy,
                         address_signer,
                         None,
                     )
-                    .await?
+                    .await?;
+                (infos, n)
             }
             InputSelection::Auto => {
                 // Auto-select supports `[DeductFromInput(0)]` and
@@ -89,12 +101,27 @@ impl PlatformAddressWallet {
                 let inputs = self
                     .auto_select_inputs(account_index, &outputs, &fee_strategy, version)
                     .await?;
-                self.sdk
+                let n = inputs.len();
+                let infos = self
+                    .sdk
                     .transfer_address_funds(inputs, outputs, fee_strategy, address_signer, None)
-                    .await?
+                    .await?;
+                (infos, n)
             }
         };
 
+        // Lower-bound static estimate from `estimate_min_fee` —
+        // captures the `state_transition_min_fees` floor only, with
+        // no adjustment for the chosen `fee_strategy`. This crate
+        // ships transfers under both `[ReduceOutput(0)]` (the
+        // wallet-factory default) and `[DeductFromInput(0)]`; either
+        // way the chain-time fee scales with storage + processing
+        // costs and is typically larger than this value (see
+        // `PlatformAddressChangeSet::estimated_min_fee` for the
+        // honest doc and platform issue #3040).
+        let fee_paid =
+            AddressFundsTransferTransition::estimate_min_fee(input_count, output_count, version);
+
         // Get the cached key source from the unified provider for gap
         // limit maintenance.
         let key_source = {
@@ -106,7 +133,10 @@ impl PlatformAddressWallet {
 
         // Update balances in the ManagedPlatformAccount.
         let mut wm = self.wallet_manager.write().await;
-        let mut cs = PlatformAddressChangeSet::default();
+        let mut cs = PlatformAddressChangeSet {
+            fee: fee_paid,
+            ..Default::default()
+        };
         if let Some(info) = wm.get_wallet_info_mut(&self.wallet_id) {
             if let Some(account) = info
                 .core_wallet

@@ -244,6 +244,28 @@ impl PlatformAddressWallet {
             .unwrap_or_default()
     }
 
+    /// Read the current incremental-sync watermark from the unified
+    /// platform-address provider.
+    ///
+    /// Returns `None` when the provider hasn't been initialised yet
+    /// (no [`Self::initialize`] call) or when the provider has no stored
+    /// watermark (whether restored via [`Self::apply_sync_state`] or
+    /// produced by a previous sync). The value is monotonic non-decreasing
+    /// across [`Self::sync_balances`](super::sync) calls against the
+    /// same chain — a later sync can only advance the watermark, never
+    /// roll it back. A zero-valued watermark is reported as `None` to
+    /// match the "no stored watermark" convention used elsewhere in
+    /// the wallet (see [`Self::apply_sync_state`]).
+    pub async fn sync_watermark(&self) -> Option<u64> {
+        let guard = self.provider.read().await;
+        let raw = guard.as_ref().map(|p| p.last_known_recent_block())?;
+        if raw == 0 {
+            None
+        } else {
+            Some(raw)
+        }
+    }
+
     /// Get total platform credits across all addresses.
     ///
     /// Returns the sum of all cached balances.