fix: align withdraw minimum, gate, and summary math (#223)

* fix: align withdraw minimum, gate, and summary on shared rounding

The amount-screen minimum and the summary's "Less fee"/"Net amount" used
to compute through different rounding paths, producing user-visible math
mismatches at certain rates (e.g. minimum displayed as ¥80 with summary
fee shown as ¥78). Display, gate, and summary now derive from one
half-up-rounded fee × rate, so the three numbers always match.

The Next button below the fee is enabled and surfaces a "Withdrawal
Amount Too Small" dialog instead of being silently disabled. Subtitle
copy reads "Minimum withdrawal X" in red. Verified-state and submission
paths are unchanged.

* fix: parse entered amount with Decimal(string:) for locale safety

NumberFormatter.decimal(from:) is locale-aware and parses "0.69" as 0
on non-"." separator locales (and through the .none-style fallback in
the parse chain), so isBelowMinimumWithdraw fired even when the user
entered exactly the displayed minimum. The keypad always emits "."
regardless of device locale, matching what Decimal(string:) expects —
and what EnterAmountView.isExceedingLimit already uses.

* docs: pitfall — keypad-emitted amounts need Decimal(string:)

Captures the locale-parsing trap that wasted hours on the withdraw
minimum gate. NumberFormatter.decimal(from:) silently parses "0.69" as
0 on non-"." locales; Decimal(string:) is the established pattern for
keypad input and matches EnterAmountView.isExceedingLimit.

Author: raulriera

CLAUDE.md

@@ -519,6 +519,7 @@ Types: `feat`, `fix`, `refactor`, `test`, `docs`, `chore`
 | `matchedGeometryEffect` applied after `.frame` | **`.matchedGeometryEffect` must come BEFORE `.frame` in the modifier chain.** Wrong order causes hero animations to fail silently: you see two separate views fading in/out at their own static positions instead of one morphing element. Paul Hudson's hackingwithswift example uses the wrong order and does not work on current iOS. Correct: `Rectangle().fill(.red).matchedGeometryEffect(id:in:).frame(width:height:)`. Incorrect: `Rectangle().fill(.red).frame(width:height:).matchedGeometryEffect(id:in:)`. Also note: `.transition(.identity)` on a parent containing matched views **kills the animation entirely** — matched geometry needs the parent view to remain in the tree briefly for interpolation, and `.identity` removes it instantly. |
 | Binding the same `dialogItem` to `.dialog(item:)` on two views in the live hierarchy | `dialog(item:)` is `.sheet(item:)` under the hood (`Dialog+View.swift`). When two views in the live tree bind the same observable — e.g. `ScanScreen` *and* a sheet `ScanScreen` is currently presenting — both attempt to present the dialog, and UIKit logs `Currently, only presenting a single sheet is supported`. For dialogs that need to fire across sheet boundaries (a viewmodel referenced by both `ScanScreen` and a router-presented sheet, or an error that fires *while* a sheet is being torn down), route through `session.dialogItem`. `DialogWindow` hosts that binding in a separate `UIWindow` at `UIWindow.Level.alert` and renders above every sheet without joining the main window's presentation queue. Per-screen state that's only ever bound by one view in the tree (e.g. a `@State DialogItem?` on a leaf) is fine to keep local. |
 | Calling `router.present(.x)` next to a viewmodel mutator that may *block* the flow | A viewmodel that surfaces a blocking error via `session.dialogItem` (e.g. `GiveViewModel.showNoBalanceError`) does not stop the router — `DialogWindow` renders the dialog above the sheet, but the sheet is still presented underneath and reappears once the dialog is dismissed. Gate the router on the precondition: expose `attemptPresent() -> Bool` on the viewmodel and write `if vm.attemptPresent() { router.present(.x) }`. Putting the check inside an `isPresented` `didSet` is not enough — the router call still runs unconditionally on the next line. |
+| Parsing keypad-emitted amounts with `NumberFormatter.decimal(from:)` | `KeyPadView` always emits "." as the decimal separator regardless of device locale. `NumberFormatter.decimal(from:)` is locale-aware and falls through `genericDecimal` and `generic` (style `.none`) — on non-"." locales those parse "0.69" as 0, silently breaking fee gates and limit comparisons (the user types the displayed minimum and the gate fires anyway). **Use `Decimal(string:)` for any string the keypad produced** — it always treats "." as the decimal separator and matches the established pattern in `EnterAmountView.isExceedingLimit`. `NumberFormatter.decimal(from:)` is appropriate only when parsing currency-formatted strings (already through the formatter, locale-correct). |
 
 ---
 

Flipcash/Core/Screens/Settings/Withdraw/WithdrawScreen.swift

@@ -88,15 +88,9 @@ struct WithdrawScreen: View {
             }
         }
         .onAppear {
-            // Wire the view model's navigation callbacks. Push substeps onto
-            // the parent (Settings) NavigationStack via the router; pops
-            // remove that many items from the top.
             viewModel.pushSubstep = { step in
                 router.pushAny(step)
             }
-            viewModel.popSubsteps = { count in
-                router.popLast(count, on: .settings)
-            }
             viewModel.onComplete = {
                 // Successful withdrawal: unwind the entire flow back to
                 // Settings root. Using `dismiss()` here would tear down the

Flipcash/Core/Screens/Settings/Withdraw/WithdrawSummaryScreen.swift

@@ -15,7 +15,7 @@ struct WithdrawSummaryScreen: View {
         Background(color: .backgroundMain) {
             VStack(spacing: 20) {
                 if let entered = viewModel.enteredFiat,
-                   let net = viewModel.withdrawableAmount,
+                   let net = viewModel.displayNet,
                    let display = viewModel.youReceiveDisplayValue {
                     BorderedContainer {
                         VStack(spacing: 20) {
@@ -30,7 +30,7 @@ struct WithdrawSummaryScreen: View {
                                 )
                                 SummaryLineItem(
                                     title: "Net amount",
-                                    value: net.nativeAmount.formatted()
+                                    value: net.formatted()
                                 )
                                 if let amountText = viewModel.amountInTokenText,
                                    let kind = viewModel.kind {

Flipcash/Core/Screens/Settings/Withdraw/WithdrawViewModel.swift

@@ -11,20 +11,10 @@ import FlipcashUI
 
 @MainActor @Observable
 class WithdrawViewModel {
-    /// Tracks which sub-step screens have been pushed. Mirrors the
-    /// `WithdrawNavigationPath` items the model has appended to the parent
-    /// navigation stack via the `pushSubstep` callback. Used by
-    /// `popToEnterAmount` to compute how many items to pop.
-    @ObservationIgnored private var substepStack: [WithdrawNavigationPath] = []
-
     /// Pushes a sub-step onto the parent NavigationStack. Wired by
     /// `WithdrawScreen` to call `router.pushAny(_:on: .settings)`.
     @ObservationIgnored var pushSubstep: (WithdrawNavigationPath) -> Void = { _ in }
 
-    /// Pops the given number of items from the parent NavigationStack.
-    /// Wired by `WithdrawScreen` to call `router.popLast(_:on: .settings)`.
-    @ObservationIgnored var popSubsteps: (Int) -> Void = { _ in }
-
     var withdrawButtonState: ButtonState = .normal
     var kind: WithdrawKind?
 
@@ -47,26 +37,47 @@ class WithdrawViewModel {
         computeAmount(using: ratesController.rateForEntryCurrency(), pinnedSupplyQuarks: nil)
     }
 
+    /// Fee in entry currency for the summary's "Less fee" line. Rounded
+    /// half-up to currency precision so the implied fee on the amount screen
+    /// (`minimumWithdrawAmount = displayFee + smallestUnit`) matches the
+    /// summary verbatim — no rounding drift between the two screens.
     var displayFee: FiatAmount? {
-        guard let enteredFiat, let withdrawableAmount else {
-            return nil
-        }
-        let entered = enteredFiat.nativeAmount
-        let withdrawable = withdrawableAmount.nativeAmount
-        guard entered.currency == withdrawable.currency, entered >= withdrawable else {
-            return nil
-        }
-        return entered - withdrawable
+        guard let enteredFiat, let fee = resolvedFee else { return nil }
+        let feeInEntry = fee.usd.converting(to: enteredFiat.currencyRate)
+        let rounded = feeInEntry.value.rounded(to: feeInEntry.currency.maximumFractionDigits)
+        return FiatAmount(value: rounded, currency: feeInEntry.currency)
     }
 
-    /// Returns the amount by which the fee exceeds the entered amount, or nil if the fee is covered.
-    /// Used by `completeWithdrawalAction` to block withdrawals where the fee exceeds the amount,
-    /// and by the summary screen to display the negative delta.
-    var negativeWithdrawableAmount: FiatAmount? {
+    /// Net in entry currency, derived as `entered − displayFee` so the three
+    /// summary lines (Withdrawal amount, Less fee, Net amount) form a closed
+    /// identity. Falls back to `entered` when there's no fee.
+    var displayNet: FiatAmount? {
         guard let enteredFiat else { return nil }
-        guard let fee = resolvedFee else { return nil }
-        guard fee.onChain >= enteredFiat.onChainAmount else { return nil }
-        return (fee.usd - enteredFiat.usdfValue).converting(to: enteredFiat.currencyRate)
+        let entered = enteredFiat.nativeAmount
+        guard let fee = displayFee else { return entered }
+        return entered - fee
+    }
+
+    /// Smallest amount that yields at least one displayable unit of net after
+    /// the fee. `displayFee + smallest_displayable_unit` in the entry currency.
+    /// Display and the `isBelowMinimumWithdraw` gate use the same number by
+    /// construction.
+    var minimumWithdrawAmount: FiatAmount? {
+        guard let displayFee else { return nil }
+        let precision = displayFee.currency.maximumFractionDigits
+        let smallestUnit = Decimal(sign: .plus, exponent: -precision, significand: 1)
+        return FiatAmount(value: displayFee.value + smallestUnit, currency: displayFee.currency)
+    }
+
+    /// Compares the raw entered Decimal against `minimumWithdrawAmount`.
+    /// Uses `Decimal(string:)` (always "." separator, matching the keypad's
+    /// output and `EnterAmountView.isExceedingLimit`) instead of the
+    /// locale-aware `NumberFormatter.decimal(from:)`, which on non-"."
+    /// locales parses "0.69" as 0 and falsely fires the gate.
+    var isBelowMinimumWithdraw: Bool {
+        guard let minimum = minimumWithdrawAmount else { return false }
+        guard let entered = Decimal(string: enteredAmount) else { return false }
+        return entered < minimum.value
     }
 
     var withdrawableAmount: ExchangedFiat? {
@@ -99,10 +110,10 @@ class WithdrawViewModel {
 
     /// Gate for the Enter-Amount screen's Next button. Disables when the
     /// entered amount exceeds the displayed balance cap (so `EnterAmountView`
-    /// turns the subtitle red) or fails to cover the withdrawal fee.
+    /// turns the subtitle red). Below-fee entries keep the button enabled so
+    /// `amountEnteredAction` can surface the dialog explaining the floor.
     var canProceedToAddress: Bool {
         guard enteredFiat != nil else { return false }
-        guard negativeWithdrawableAmount == nil else { return false }
         return EnterAmountCalculator.isWithinDisplayLimit(
             enteredAmount: enteredAmount,
             max: maxWithdrawLimit.nativeAmount
@@ -153,15 +164,15 @@ class WithdrawViewModel {
     }
 
     /// Single string rendered inside the "You Receive" box on the summary.
-    /// USDF: native fiat amount (e.g. "$49.50"). Bonded: scaled token quantity
-    /// (matches `amountInTokenText` — same number, different framing on screen).
+    /// USDF: net fiat (matches the summary's `Net amount` line). Bonded:
+    /// scaled token quantity (matches `amountInTokenText` — same number,
+    /// different framing on screen).
     var youReceiveDisplayValue: String? {
-        guard let withdrawableAmount else { return nil }
         switch kind {
         case .sameMint:
-            return withdrawableAmount.onChainAmount.decimalValue.formatted()
+            return withdrawableAmount?.onChainAmount.decimalValue.formatted()
         case .usdfToUsdc:
-            return withdrawableAmount.nativeAmount.formatted()
+            return displayNet?.formatted()
         case .none:
             return nil
         }
@@ -181,15 +192,13 @@ class WithdrawViewModel {
         }
     }
 
-    /// Subtitle for the amount-entry screen. "Enter more than $X.XX" when the
-    /// entered amount is at or below the fee (a hard gate that disables Next).
+    /// Subtitle for the amount-entry screen. "Minimum withdrawal $X.XX" when
+    /// the entered amount is at or below the fee, hinting at the floor without
+    /// disabling Next — the gating dialog fires from `amountEnteredAction`.
     /// Otherwise the "Enter up to $Y.YY" balance-with-limit copy.
     var amountSubtitle: EnterAmountView.Subtitle {
-        if let enteredFiat,
-           negativeWithdrawableAmount != nil,
-           let fee = resolvedFee {
-            let feeInEntryCurrency = fee.usd.converting(to: enteredFiat.currencyRate)
-            return .custom("Enter more than \(feeInEntryCurrency.formatted())")
+        if isBelowMinimumWithdraw, let minimum = minimumWithdrawAmount {
+            return .error("Minimum withdrawal \(minimum.formatted())")
         }
         return .balanceWithLimit(maxWithdrawLimit)
     }
@@ -350,6 +359,11 @@ class WithdrawViewModel {
     }
 
     func amountEnteredAction() {
+        if isBelowMinimumWithdraw {
+            showWithdrawalTooSmallError()
+            return
+        }
+
         guard let exchangedFiat = enteredFiat else {
             return
         }
@@ -371,21 +385,6 @@ class WithdrawViewModel {
     }
 
     func completeWithdrawalAction() {
-        guard negativeWithdrawableAmount == nil else {
-            dialogItem = .init(
-                style: .destructive,
-                title: "Withdrawal Amount Too Small",
-                subtitle: "Your withdrawal amount is too small to cover the fee. Please try a different amount",
-                dismissable: true
-            ) {
-                .okay(kind: .standard) { [weak self] in
-                    self?.resetEnteredAmount()
-                    self?.popToEnterAmount()
-                }
-            }
-            return
-        }
-
         dialogItem = .init(
             style: .destructive,
             title: "Are You Sure?",
@@ -490,44 +489,22 @@ class WithdrawViewModel {
         enteredAddress = address.base58
     }
 
-    // MARK: - Reset -
-
-    private func resetEnteredAmount() {
-        enteredAmount = ""
-    }
-
     // MARK: - Navigation -
 
-    private func popToEnterAmount() {
-        // Pop everything above `.enterAmount`, leaving it as the top substep.
-        // If we're already there or the stack is empty, this is a no-op.
-        guard let firstAmountIndex = substepStack.firstIndex(of: .enterAmount) else {
-            return
-        }
-        let popsNeeded = substepStack.count - (firstAmountIndex + 1)
-        guard popsNeeded > 0 else { return }
-        popSubsteps(popsNeeded)
-        substepStack.removeLast(popsNeeded)
-    }
-
     private func pushIntroScreen() {
         pushSubstep(.intro)
-        substepStack.append(.intro)
     }
 
     func pushEnterAmountScreen() {
         pushSubstep(.enterAmount)
-        substepStack.append(.enterAmount)
     }
 
     private func pushEnterAddressScreen() {
         pushSubstep(.enterAddress)
-        substepStack.append(.enterAddress)
     }
 
     private func pushConfirmationScreen() {
         pushSubstep(.confirmation)
-        substepStack.append(.confirmation)
     }
 
     // MARK: - Dialogs -
@@ -555,6 +532,17 @@ class WithdrawViewModel {
             .okay(kind: .destructive)
         }
     }
+
+    private func showWithdrawalTooSmallError() {
+        dialogItem = .init(
+            style: .destructive,
+            title: "Withdrawal Amount Too Small",
+            subtitle: "Your withdrawal amount is too small to cover the fee. Please try a different amount",
+            dismissable: true
+        ) {
+            .okay(kind: .standard)
+        }
+    }
 }
 
 enum WithdrawNavigationPath {

Flipcash/UI/EnterAmountView.swift

@@ -103,10 +103,10 @@ public struct EnterAmountView: View {
                             .foregroundColor(subtitleColor)
                             .font(.appTextMedium)
 
-                    case .custom(let text):
+                    case .error(let text):
                         Text(text)
                             .fixedSize()
-                            .foregroundColor(subtitleColor)
+                            .foregroundColor(.textError)
                             .font(.appTextMedium)
                     }
                 }
@@ -198,7 +198,9 @@ extension EnterAmountView {
     enum Subtitle {
         case singleTransactionLimit
         case balanceWithLimit(ExchangedFiat)
-        case custom(String)
+        /// Always rendered in `textError`. Use for soft-validation copy where
+        /// Next stays enabled and the caller surfaces a dialog on tap.
+        case error(String)
     }
 }