fix: add quickpay daily spend limit

Bitkit/Components/CustomSlider.swift

@@ -3,6 +3,8 @@ import SwiftUI
 struct CustomSlider: View {
     @Binding var value: Double
     let steps: [Double]
+    var formatLabel: (Double) -> String = { "$\(Int($0))" }
+    var testIdentifier: String? = nil
 
     @State private var sliderIndex: Double = 0
     @State private var sliderWidth: CGFloat = 0
@@ -75,6 +77,7 @@ struct CustomSlider: View {
                             }
                     }
                 )
+                .accessibilityIdentifierIfPresent(testIdentifier)
                 .gesture(
                     DragGesture(minimumDistance: 0)
                         .onChanged { gesture in
@@ -117,7 +120,7 @@ struct CustomSlider: View {
             // Step labels
             GeometryReader { geometry in
                 ForEach(Array(steps.enumerated()), id: \.offset) { index, step in
-                    Text("$\(Int(step))")
+                    Text(formatLabel(step))
                         .font(.custom(Fonts.medium, size: 13))
                         .foregroundColor(.textPrimary)
                         .position(

Bitkit/Models/SettingsBackupConfig.swift

@@ -53,6 +53,7 @@ enum SettingsBackupConfig {
         "backupVerified": .bool,
         "enableNotifications": .bool,
         "quickpayAmount": .double(optional: false),
+        "quickpayDailyLimitMultiplier": .double(optional: false),
     ]
 
     static var settingsKeys: [String] {
@@ -65,6 +66,7 @@ enum SettingsBackupConfig {
         "warnWhenSendingOver100": "enableSendAmountWarning",
         "bitcoinDisplayUnit": "displayUnit",
         "enableQuickpay": "isQuickPayEnabled",
+        "quickpayDailyLimitMultiplier": "quickPayDailyLimitMultiplier",
         "enableNotifications": "notificationsGranted",
         // Note: PIN settings are intentionally NOT backed up for security
         // PIN itself cannot be backed up, so PIN settings shouldn't be either

Bitkit/Resources/Localization/en.lproj/Localizable.strings

@@ -801,7 +801,12 @@
 "settings__quickpay__settings__toggle" = "Enable QuickPay";
 "settings__quickpay__settings__text" = "If enabled, scanned invoices below ${amount} will be paid automatically without requiring your confirmation or PIN*.";
 "settings__quickpay__settings__label" = "Quickpay threshold";
+"settings__quickpay__settings__daily_label" = "Daily QuickPay limit";
+"settings__quickpay__settings__daily_text" = "Auto-pay up to ${limit} per day without PIN ({multiplier}× your threshold). After that, payments open Confirm.";
+"settings__quickpay__settings__multiplier_format" = "{multiplier}×";
 "settings__quickpay__settings__note" = "* Bitkit QuickPay exclusively supports payments from your Spending Balance.";
+"wallet__send_quickpay__currency_conversion" = "Currency conversion failed";
+"wallet__send_quickpay__daily_limit" = "Daily QuickPay limit reached";
 "settings__security__title" = "Security And Privacy";
 "settings__security__swipe_balance_to_hide" = "Swipe balance to hide";
 "settings__security__hide_balance_on_open" = "Hide balance on open";

Bitkit/Utilities/PaymentNavigationHelper.swift

@@ -12,39 +12,65 @@ struct PaymentNavigationHelper {
     static func shouldUseQuickpay(
         app: AppViewModel,
         settings: SettingsViewModel,
-        currency: CurrencyViewModel
+        currency: CurrencyViewModel,
+        spendStore: QuickPaySpendStore = .shared
     ) -> Bool {
-        // Check if quickpay is enabled
         guard settings.enableQuickpay else {
             return false
         }
 
-        // We need a lightning invoice or LNURL pay data to use quickpay
-        guard app.scannedLightningInvoice != nil || app.lnurlPayData != nil else {
+        guard let amountSats = QuickPayLimits.paymentAmountSats(app: app), amountSats > 0 else {
             return false
         }
 
-        // Convert quickpay amount from USD to sats
-        let quickpayAmountSats = currency.convert(fiatAmount: settings.quickpayAmount, from: "USD") ?? 0
-        guard quickpayAmountSats > 0 else {
+        return isWithinThreshold(amountSats: amountSats, settings: settings, currency: currency)
+            && isWithinDailyCap(amountSats: amountSats, settings: settings, currency: currency, spendStore: spendStore)
+    }
+
+    private static func isWithinThreshold(
+        amountSats: UInt64,
+        settings: SettingsViewModel,
+        currency: CurrencyViewModel
+    ) -> Bool {
+        let quickpayAmountSats = currency.convert(fiatAmount: settings.quickpayAmount, from: QuickPayLimits.usdCurrencyCode) ?? 0
+        return quickpayAmountSats > 0 && amountSats <= quickpayAmountSats
+    }
+
+    private static func isWithinDailyCap(
+        amountSats: UInt64,
+        settings: SettingsViewModel,
+        currency: CurrencyViewModel,
+        spendStore: QuickPaySpendStore
+    ) -> Bool {
+        let multiplier = QuickPayLimits.sanitizedMultiplier(settings.quickpayDailyLimitMultiplier)
+        guard let dailyCapSats = QuickPayLimits.dailyCapSats(
+            thresholdUsd: settings.quickpayAmount,
+            multiplier: multiplier,
+            currency: currency
+        ) else {
             return false
         }
 
-        // Check LNURL pay
-        if let lnurlPayData = app.lnurlPayData {
-            return lnurlPayData.isFixedAmount && lnurlPayData.minSendableSat <= quickpayAmountSats
+        let dayKey = QuickPaySpendStore.dayKey()
+        let spentSatsToday = spendStore.spentSats(forDayKey: dayKey)
+        let (total, overflow) = spentSatsToday.addingReportingOverflow(amountSats)
+        if !overflow, total <= dailyCapSats {
+            return true
         }
 
-        // Check regular lightning invoice
-        return app.scannedLightningInvoice!.amountSatoshis <= quickpayAmountSats
+        Logger.info(
+            "Skipping QuickPay: daily spend '\(spentSatsToday)' + '\(amountSats)' exceeds cap '\(dailyCapSats)'"
+        )
+        return false
     }
 
     /// Centralized method to open the appropriate sheet based on the current state
     static func openPaymentSheet(
         app: AppViewModel,
         currency: CurrencyViewModel,
         settings: SettingsViewModel,
-        sheetViewModel: SheetViewModel
+        sheetViewModel: SheetViewModel,
+        spendStore: QuickPaySpendStore = .shared
     ) {
         // Handle LNURL withdraw
         if let lnurlWithdrawData = app.lnurlWithdrawData {
@@ -57,7 +83,7 @@ struct PaymentNavigationHelper {
             return
         }
 
-        let shouldUseQuickpay = shouldUseQuickpay(app: app, settings: settings, currency: currency)
+        let shouldUseQuickpay = shouldUseQuickpay(app: app, settings: settings, currency: currency, spendStore: spendStore)
 
         // Handle Lightning address / LNURL pay
         if let lnurlPayData = app.lnurlPayData {
@@ -100,7 +126,8 @@ struct PaymentNavigationHelper {
     static func appropriateSendRoute(
         app: AppViewModel,
         currency: CurrencyViewModel,
-        settings: SettingsViewModel
+        settings: SettingsViewModel,
+        spendStore: QuickPaySpendStore = .shared
     ) -> SendRoute? {
         if let lnurlWithdrawData = app.lnurlWithdrawData {
             if lnurlWithdrawData.isFixedAmount {
@@ -110,7 +137,7 @@ struct PaymentNavigationHelper {
             }
         }
 
-        let shouldUseQuickpay = shouldUseQuickpay(app: app, settings: settings, currency: currency)
+        let shouldUseQuickpay = shouldUseQuickpay(app: app, settings: settings, currency: currency, spendStore: spendStore)
 
         // Handle Lightning address / LNURL pay
         if let lnurlPayData = app.lnurlPayData {
@@ -147,12 +174,25 @@ struct PaymentNavigationHelper {
         return nil
     }
 
+    static func confirmRouteAfterQuickPayCap(app: AppViewModel) -> SendRoute {
+        if let lnurlPayData = app.lnurlPayData {
+            return lnurlPayData.isFixedAmount ? .lnurlPayConfirm : .lnurlPayAmount
+        }
+
+        if let invoice = app.scannedLightningInvoice, invoice.amountSatoshis == 0 {
+            return .amount
+        }
+
+        return .confirm
+    }
+
     static func contactPaymentRoute(
         app: AppViewModel,
         currency: CurrencyViewModel,
-        settings: SettingsViewModel
+        settings: SettingsViewModel,
+        spendStore: QuickPaySpendStore = .shared
     ) -> SendRoute? {
-        guard let route = appropriateSendRoute(app: app, currency: currency, settings: settings) else {
+        guard let route = appropriateSendRoute(app: app, currency: currency, settings: settings, spendStore: spendStore) else {
             return nil
         }
 

Bitkit/Utilities/QuickPayLimits.swift

@@ -0,0 +1,46 @@
+import Foundation
+
+enum QuickPayLimits {
+    static let usdCurrencyCode = "USD"
+    static let thresholdSteps: [Double] = [1, 5, 10, 20, 50]
+    static let dailyMultiplierSteps: [Double] = [1, 3, 5, 10, 50]
+    static let defaultThresholdUsd: Double = 5
+    static let defaultDailyMultiplier: Double = 5
+
+    static func amountWithFeeSats(amountSats: UInt64, feePaidSats: UInt64) -> UInt64 {
+        let (total, overflow) = amountSats.addingReportingOverflow(feePaidSats)
+        return overflow ? UInt64.max : total
+    }
+
+    static func sanitizedMultiplier(_ value: Double) -> Double {
+        dailyMultiplierSteps.contains(value) ? value : defaultDailyMultiplier
+    }
+
+    static func dailyCapUsdDisplay(thresholdUsd: Double, multiplier: Double) -> Int {
+        Int(thresholdUsd) * Int(multiplier)
+    }
+
+    @MainActor
+    static func paymentAmountSats(app: AppViewModel) -> UInt64? {
+        if let lnurlPayData = app.lnurlPayData {
+            guard lnurlPayData.isFixedAmount else { return nil }
+            return lnurlPayData.minSendableSat
+        }
+
+        return app.scannedLightningInvoice?.amountSatoshis
+    }
+
+    @MainActor
+    static func dailyCapSats(
+        thresholdUsd: Double,
+        multiplier: Double,
+        currency: CurrencyViewModel
+    ) -> UInt64? {
+        guard let thresholdSats = currency.convert(fiatAmount: thresholdUsd, from: usdCurrencyCode), thresholdSats > 0 else {
+            return nil
+        }
+
+        let (dailyCapSats, overflow) = thresholdSats.multipliedReportingOverflow(by: UInt64(max(multiplier, 1).rounded()))
+        return overflow ? UInt64.max : dailyCapSats
+    }
+}

Bitkit/Utilities/QuickPaySpendStore.swift

@@ -0,0 +1,147 @@
+import Foundation
+
+final class QuickPaySpendStore: @unchecked Sendable {
+    static let shared = QuickPaySpendStore()
+
+    static let dayKeyDefaultsKey = "quickPaySpendDayKey"
+    static let spentSatsDefaultsKey = "quickPaySpentSatsToday"
+    static let pendingReservationsDefaultsKey = "quickPayPendingReservations"
+
+    private let defaults: UserDefaults
+    private let lock = NSLock()
+
+    struct PendingReservation: Codable, Equatable {
+        let amountSats: UInt64
+        let dayKey: String
+    }
+
+    init(defaults: UserDefaults = .standard) {
+        self.defaults = defaults
+    }
+
+    static func dayKey(date: Date = Date(), timeZone: TimeZone = .current) -> String {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = timeZone
+        let components = calendar.dateComponents([.year, .month, .day], from: date)
+        return String(format: "%04d-%02d-%02d", components.year ?? 0, components.month ?? 0, components.day ?? 0)
+    }
+
+    func spentSats(forDayKey dayKey: String) -> UInt64 {
+        lock.lock()
+        defer { lock.unlock() }
+        return lockedSpend(forDayKey: dayKey).spentSats
+    }
+
+    @discardableResult
+    func tryReserve(amountSats: UInt64, dayKey: String, dailyCapSats: UInt64) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+
+        let spend = lockedSpend(forDayKey: dayKey)
+        let (total, overflow) = spend.spentSats.addingReportingOverflow(amountSats)
+        if overflow || total > dailyCapSats {
+            return false
+        }
+
+        lockedWrite(dayKey: spend.dayKey, spentSats: total)
+        return true
+    }
+
+    func release(amountSats: UInt64, dayKey: String) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        let spend = lockedSpend(forDayKey: dayKey)
+        let storedDayKey = defaults.string(forKey: Self.dayKeyDefaultsKey) ?? ""
+        guard spend.dayKey == storedDayKey else { return }
+        lockedWrite(dayKey: spend.dayKey, spentSats: spend.spentSats > amountSats ? spend.spentSats - amountSats : 0)
+    }
+
+    func record(amountSats: UInt64, dayKey: String) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        let spend = lockedSpend(forDayKey: dayKey)
+        let (total, overflow) = spend.spentSats.addingReportingOverflow(amountSats)
+        lockedWrite(dayKey: spend.dayKey, spentSats: overflow ? UInt64.max : total)
+    }
+
+    func trackPending(paymentHash: String, amountSats: UInt64, dayKey: String) {
+        guard !paymentHash.isEmpty else { return }
+
+        lock.lock()
+        defer { lock.unlock() }
+
+        var pending = lockedPendingReservations()
+        pending[paymentHash] = PendingReservation(amountSats: amountSats, dayKey: dayKey)
+        lockedWritePending(pending)
+    }
+
+    func forgetPending(paymentHash: String) {
+        guard !paymentHash.isEmpty else { return }
+
+        lock.lock()
+        defer { lock.unlock() }
+
+        var pending = lockedPendingReservations()
+        pending.removeValue(forKey: paymentHash)
+        lockedWritePending(pending)
+    }
+
+    func releasePending(paymentHash: String) {
+        guard !paymentHash.isEmpty else { return }
+
+        lock.lock()
+        defer { lock.unlock() }
+
+        var pending = lockedPendingReservations()
+        guard let reservation = pending.removeValue(forKey: paymentHash) else { return }
+        lockedWritePending(pending)
+
+        let spend = lockedSpend(forDayKey: reservation.dayKey)
+        lockedWrite(
+            dayKey: spend.dayKey,
+            spentSats: spend.spentSats > reservation.amountSats ? spend.spentSats - reservation.amountSats : 0
+        )
+    }
+
+    private func lockedSpend(forDayKey dayKey: String) -> (dayKey: String, spentSats: UInt64) {
+        let storedDayKey = defaults.string(forKey: Self.dayKeyDefaultsKey) ?? ""
+        let storedSpend = lockedStoredSpentSats()
+
+        if storedDayKey.isEmpty || dayKey > storedDayKey {
+            return (dayKey, 0)
+        }
+        if dayKey == storedDayKey {
+            return (dayKey, storedSpend)
+        }
+        return (storedDayKey, storedSpend)
+    }
+
+    private func lockedStoredSpentSats() -> UInt64 {
+        UInt64(max(defaults.integer(forKey: Self.spentSatsDefaultsKey), 0))
+    }
+
+    private func lockedWrite(dayKey: String, spentSats: UInt64) {
+        defaults.set(dayKey, forKey: Self.dayKeyDefaultsKey)
+        defaults.set(Int(clamping: spentSats), forKey: Self.spentSatsDefaultsKey)
+    }
+
+    private func lockedPendingReservations() -> [String: PendingReservation] {
+        guard let data = defaults.data(forKey: Self.pendingReservationsDefaultsKey),
+              let decoded = try? JSONDecoder().decode([String: PendingReservation].self, from: data)
+        else {
+            return [:]
+        }
+        return decoded
+    }
+
+    private func lockedWritePending(_ pending: [String: PendingReservation]) {
+        if pending.isEmpty {
+            defaults.removeObject(forKey: Self.pendingReservationsDefaultsKey)
+            return
+        }
+
+        defaults.set(try? JSONEncoder().encode(pending), forKey: Self.pendingReservationsDefaultsKey)
+    }
+}