dashpay · lklimek · May 4, 2026 · Apr 29, 2026 · Apr 29, 2026 · Apr 29, 2026
@@ -582,6 +582,27 @@ pub struct PlatformAddressChangeSet {
     /// Last block height with recent address changes (compaction marker).
     /// `None` means "no change".
     pub last_known_recent_block: Option<u64>,
+    /// Fee paid by the transfer that produced this changeset, in
+    /// credits. `0` for changesets not produced by `transfer()`
+    /// (e.g. sync-only changesets). See [`Self::fee_paid`].
+    pub fee: Credits,
+}
+
+impl PlatformAddressChangeSet {
+    /// Fee paid by 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 computed by
+    /// `transfer()` from the transition's input/output counts via
+    /// `AddressFundsTransferTransition::estimate_min_fee`, then
+    /// adjusted by the configured `fee_strategy` so the returned
+    /// number reflects the portion of the fee charged to the
+    /// fee-bearing input's remaining balance.
+    pub fn fee_paid(&self) -> Credits {
+        self.fee
+    }
 }
 
 impl Merge for PlatformAddressChangeSet {
@@ -606,13 +627,19 @@ impl Merge for PlatformAddressChangeSet {
                     .map_or(r, |existing| existing.max(r)),
             );
         }
+        // Fee: last-non-zero-wins. Sync-only merges (which carry
+        // `fee == 0`) preserve a transfer's recorded fee; merging
+        // two transfer changesets sums the fees, matching 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,23 @@ 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)
             }
         };
 
+        // Estimated fee = the same min-fee formula the protocol uses
+        // for validation. With `DeductFromInput(_)` (the canonical
+        // strategy used everywhere in this crate) the entire fee is
+        // charged to the targeted input's remaining balance, so this
+        // value matches the on-chain debit.
+        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 +129,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,27 @@ 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 no sync has produced a
+    /// watermark in this session. 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.