fix: authorize initial USDT subscriptions once

Bitkit/Services/PaykitPaymentRequestService.swift

@@ -2601,19 +2601,22 @@ final class PaykitPaymentRequestManager {
                 .flatMap { _, requests in
                     requests.filter {
                         $0.lifecycleState != .proofSubmitted &&
+                            !$0.isExpired(at: refreshDate) &&
                             !locallyCompletedRequestIds.contains($0.id) &&
                             (!locallyInFlightRequestIds.contains($0.id) || retainedHardwareRetries[$0.id] != nil) &&
                             !dismissedSubscriptionPaymentIds.contains($0.id)
                     }
                 }
                 .sorted { ($0.billingPeriod?.startsAt ?? .distantFuture) < ($1.billingPeriod?.startsAt ?? .distantFuture) }
-            let recurringHistory = recurringRequestsBySubscription.flatMap { _, requests in
+            let recurringHistory = recurringRequestsBySubscription.flatMap { subscription, requests in
                 requests.compactMap { request in
                     if request.lifecycleState == .proofSubmitted {
                         return request
                     }
-                    guard let proofKind = locallyCompletedProofKinds[request.id] else { return nil }
-                    return request.updatingLifecycleState(.proofSubmitted, paymentProofKind: proofKind)
+                    if let proofKind = locallyCompletedProofKinds[request.id] {
+                        return request.updatingLifecycleState(.proofSubmitted, paymentProofKind: proofKind)
+                    }
+                    return subscription.lifecycleState == .activeRecurring && request.isExpired(at: refreshDate) ? request : nil
                 }
             }
             let protectedRequests = pendingRequests.filter {
@@ -2700,13 +2703,19 @@ final class PaykitPaymentRequestManager {
         let recurringRequests = subscriptionAcceptedAt[subscription.id].map {
             subscription.requests(through: date, acceptedAt: $0)
         } ?? []
+        let paymentDate = now()
         pendingRequests.removeAll { $0.belongs(to: subscription) }
         if subscription.lifecycleState == .activeRecurring {
-            pendingRequests.append(contentsOf: recurringRequests.filter { $0.lifecycleState != .proofSubmitted })
+            pendingRequests.append(contentsOf: recurringRequests.filter {
+                $0.lifecycleState != .proofSubmitted && !$0.isExpired(at: paymentDate)
+            })
             pendingRequests.sort { ($0.createdAt ?? .distantFuture) < ($1.createdAt ?? .distantFuture) }
         }
         historyRequests.removeAll { $0.belongs(to: subscription) }
-        historyRequests.append(contentsOf: recurringRequests.filter { $0.lifecycleState == .proofSubmitted })
+        historyRequests.append(contentsOf: recurringRequests.filter {
+            $0.lifecycleState == .proofSubmitted ||
+                (subscription.lifecycleState == .activeRecurring && $0.isExpired(at: paymentDate))
+        })
         historyRequests.sort { ($0.createdAt ?? .distantPast) > ($1.createdAt ?? .distantPast) }
         await subscriptionNotificationScheduler.synchronize(
             subscriptions,
@@ -2815,6 +2824,11 @@ final class PaykitPaymentRequestManager {
         let subscriptionDate = subscriptionNow()
         recordRequestedPresentationExpiration(at: date, excluding: handledRequestedExpirationId)
         recordSilentExpirations(at: date, excluding: [handledRequestedExpirationId, openedRequestId].compactMap { $0 })
+        let historyIds = Set(historyRequests.map(\.id))
+        historyRequests.append(contentsOf: pendingRequests.filter {
+            $0.billingPeriod != nil && $0.isExpired(at: date) && !historyIds.contains($0.id)
+        })
+        historyRequests.sort { ($0.createdAt ?? .distantPast) > ($1.createdAt ?? .distantPast) }
         pendingRequests.removeAll { $0.isExpired(at: date) }
         subscriptions = subscriptions.map { $0.withExpiredLifecycle(at: subscriptionDate) }
         presentedSubscriptionProposalIds.formIntersection(
@@ -2898,14 +2912,18 @@ final class PaykitPaymentRequestManager {
         let requestDelays = pendingRequests.filter { $0.lifecycleState == .proposed }.compactMap(\.expiresAt).map {
             $0.timeIntervalSince(date)
         }
+        // Payment deadlines are inclusive; reconcile just after the boundary.
+        let paymentDeadlineDelays = pendingRequests.compactMap(\.paymentDeadline).map {
+            $0.date.addingTimeInterval(0.001).timeIntervalSince(date)
+        }
         let subscriptionDelays = subscriptions.filter {
             $0.isProposal || $0.lifecycleState == .activeRecurring
         }.flatMap {
             [$0.proposalExpiresAt, $0.recurrence.endsAt].compactMap { $0 }
         }.filter { $0 > subscriptionDate }.map {
             $0.timeIntervalSince(subscriptionDate)
         }
-        guard let nextDelay = (requestDelays + subscriptionDelays).min() else { return }
+        guard let nextDelay = (requestDelays + paymentDeadlineDelays + subscriptionDelays).min() else { return }
         let delay = max(0, nextDelay)
         expirationTask = Task { [weak self] in
             do {

Bitkit/ViewModels/AppViewModel.swift

@@ -37,6 +37,23 @@ struct ContactPaymentContext: Equatable {
             incomingPaymentRequest.map { $0.amount.asset != .btc || $0.pricing.conversion != nil } == true
     }
 
+    func initialUsdtSubscriptionPayment(at date: Date = Date()) -> PaykitRequestPricing.Payment? {
+        guard isInitialSubscriptionPayment, let request = incomingPaymentRequest, request.billingPeriod != nil,
+              Set(request.acceptedPaymentEndpointIdentifiers) == [PublicPaykitService.MethodId.usdtArbitrum.rawValue],
+              !endpoints.isEmpty, endpoints.allSatisfy({ $0.methodId == .usdtArbitrum }),
+              !request.isExpired(at: date)
+        else { return nil }
+        switch (request.amount.asset, request.pricing.conversion) {
+        case (.usdt, nil): break
+        case let (.usd, .fixed(rates)):
+            let rate = rates.first { $0.asset == "usdt-arbitrum" } ?? rates.first { $0.asset == "usdt" }
+            guard let rate, Decimal(string: rate.value, locale: Locale(identifier: "en_US_POSIX")) == 1 else { return nil }
+        default: return nil
+        }
+        guard let payment = try? request.payment(using: .usdtArbitrum, at: date), payment.isValid(at: date) else { return nil }
+        return payment
+    }
+
     func prefersUsdt(
         onchainBalanceSats: UInt64,
         canSendLightning: Bool = false,

Bitkit/Views/PaymentRequests/PaymentRequestsView.swift

@@ -20,7 +20,7 @@ enum PaymentRequestDisplay {
         isActionable: Bool,
         now: Date = Date()
     ) -> String {
-        if request.isExpired(at: now), request.lifecycleState == .proposed {
+        if request.isExpired(at: now), request.lifecycleState == .proposed || request.lifecycleState == .activeRecurring {
             return "wallet__payment_request_status_expired"
         }
 
@@ -46,7 +46,11 @@ enum PaymentRequestDisplay {
             return "wallet__payment_request_status_proof_submitted"
         case .recoveryRequired:
             return "wallet__payment_request_status_action_required"
-        case .invalidConflict, .activeRecurring, .unknown:
+        case .activeRecurring:
+            return request.billingPeriod != nil && request.direction == .incoming && isActionable
+                ? "wallet__payment_request_waiting"
+                : "wallet__payment_request_status_unavailable"
+        case .invalidConflict, .unknown:
             return "wallet__payment_request_status_unavailable"
         }
     }

Bitkit/Views/Subscriptions/SubscriptionsView.swift

@@ -244,6 +244,12 @@ struct SubscriptionsView: View {
     }
 }
 
+func subscriptionPayments(subscription: PaykitSubscription, history: [PaykitPaymentRequest]) -> [PaykitPaymentRequest] {
+    subscription.isCreatedByUser
+        ? subscription.receivedPaymentRequests()
+        : history.filter { $0.belongs(to: subscription) && $0.lifecycleState == .proofSubmitted }
+}
+
 func subscriptionMonthlyCostSats(amounts: [PaykitAmount], rate: PaykitExchangeRate?, now: Date = Date()) -> Int? {
     var total = 0
     for amount in amounts {
@@ -523,9 +529,7 @@ struct SubscriptionDetailView: View {
 
     @ViewBuilder
     private func payments(_ subscription: PaykitSubscription) -> some View {
-        let payments = subscription.isCreatedByUser
-            ? subscription.receivedPaymentRequests()
-            : paymentRequests.historyRequests.filter { $0.belongs(to: subscription) }
+        let payments = subscriptionPayments(subscription: subscription, history: paymentRequests.historyRequests)
         if !payments.isEmpty {
             VStack(alignment: .leading, spacing: 12) {
                 CaptionMText(t("subscriptions__payments").localizedUppercase, textColor: .white64)
@@ -785,8 +789,16 @@ struct SubscriptionSheet: View {
             return
         }
 
-        let sendRoute: SendRoute = context.requiresAssetSelection ? .amount : app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
-        route = .payment(sendRoute)
+        if app.paykitUsesUsdt, let terms = context.initialUsdtSubscriptionPayment(),
+           let recipient = context.endpoints.first?.value
+        {
+            app.paykitPaymentTerms = terms
+            app.paykitReviewedAmount = terms.amount
+            route = .payment(.usdt(recipient: recipient, amount: terms.amount.value))
+        } else {
+            let sendRoute: SendRoute = context.requiresAssetSelection ? .amount : app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
+            route = .payment(sendRoute)
+        }
     }
 
     @MainActor
@@ -922,7 +934,9 @@ struct SubscriptionSuccessView: View {
 
     var body: some View {
         ZStack {
-            if let animation = confettiAnimation {
+            if paymentProofKind == .usdt {
+                PaymentCelebration(isOnchain: true, isReceived: false, confettiColor: .usdtAccent, isUsdt: true)
+            } else if let animation = confettiAnimation {
                 LottieView(animation: animation)
                     .playing(loopMode: .loop)
                     .scaleEffect(1.9)

Bitkit/Views/Wallets/Send/SendSheet.swift

@@ -958,7 +958,13 @@ struct SendSheet: View {
                     }
                     guard app.ownsContactPaymentContext(context) else { throw PaykitPaymentRequestError.requestUnavailable }
                 }
-            }, onBack: { flow.navigationPath.removeLast() }, onClose: { sheets.hideSheet() })
+            }, onBack: {
+                if flow.navigationPath.isEmpty {
+                    sheets.hideSheet()
+                } else {
+                    flow.navigationPath.removeLast()
+                }
+            }, onClose: { sheets.hideSheet() })
         case let .usdtAddress(recipient, amount):
             UsdtSendView(onDetails: { id in
                 flow.usdtDetails = id
@@ -1448,7 +1454,13 @@ struct SendSheet: View {
                 return
             }
         }
-        flow.pendingEmbeddedRetryRoute = context.requiresAssetSelection ? .amount : app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
+        if app.paykitUsesUsdt, let terms = context.initialUsdtSubscriptionPayment(), let recipient = context.endpoints.first?.value {
+            app.paykitPaymentTerms = terms
+            app.paykitReviewedAmount = terms.amount
+            flow.pendingEmbeddedRetryRoute = .usdt(recipient: recipient, amount: terms.amount.value)
+        } else {
+            flow.pendingEmbeddedRetryRoute = context.requiresAssetSelection ? .amount : app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
+        }
         flow.hasValidatedAfterSync = false
         guard !shouldShowSyncOverlay else { return }
         validatePaymentAfterSync()