From ead8a6adcd86a27abc4d98993797d1ed6a8e8822 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 6 Oct 2026 22:14:16 -0500
Subject: [PATCH 01/62] feat: add usdt wallet and paykit payments

---
 Bitkit.xcodeproj/project.pbxproj              |   2 +-
 .../xcshareddata/swiftpm/Package.resolved     |   4 +-
 Bitkit/AppScene.swift                         |   7 +-
 Bitkit/Components/DrawerView.swift            |   5 +
 Bitkit/Components/MoneyStack.swift            |  79 +--
 Bitkit/Components/NumberPadTextField.swift    |  44 +-
 Bitkit/Components/PaykitAmountText.swift      |  19 +
 Bitkit/Components/PaymentAddressInput.swift   |  33 ++
 Bitkit/Components/PaymentCelebration.swift    |  35 ++
 .../PaymentReviewIllustration.swift           |  17 +
 Bitkit/Components/WalletBalanceView.swift     |  44 +-
 Bitkit/Constants/Env.swift                    |  30 ++
 Bitkit/Info.plist                             |  12 +
 Bitkit/MainNavView.swift                      |  19 +
 Bitkit/Managers/UsdtWalletManager.swift       | 402 ++++++++++++++++
 Bitkit/Models/BackupPayloads.swift            |   1 +
 Bitkit/Models/PaykitAmount.swift              | 122 +++++
 Bitkit/Models/PaykitPaymentStateBackup.swift  |  10 +
 Bitkit/Models/PaykitRequestPricing.swift      | 117 +++++
 Bitkit/Models/PaykitUsdt.swift                |  31 ++
 Bitkit/Models/PaykitUsdtStateBackup.swift     |  96 ++++
 Bitkit/Models/PubkyAuthRequest.swift          |  43 +-
 .../Localization/en.lproj/Localizable.strings | 114 +++++
 Bitkit/Services/BackupService.swift           |  59 ++-
 Bitkit/Services/ContactPaymentsService.swift  |   1 +
 Bitkit/Services/PaykitIssuerInterop.swift     |   2 +-
 .../Services/PaykitPaymentProofService.swift  |  17 +-
 .../PaykitPaymentRequestService.swift         | 197 +++++---
 Bitkit/Services/PaykitSubscription.swift      |  43 +-
 .../Services/PaykitSubscriptionProposal.swift |  56 +--
 .../Services/PaykitUsdtPaymentService.swift   | 423 +++++++++++++++++
 .../PrivatePaykitService+Endpoints.swift      |   4 +
 .../PrivatePaykitService+Payments.swift       |   3 +-
 Bitkit/Services/PubkyService.swift            |  16 +-
 Bitkit/Services/PublicPaykitService.swift     |  27 +-
 Bitkit/Utilities/AppReset.swift               |   6 +
 Bitkit/Utilities/Keychain.swift               |   2 +
 .../Utilities/PaymentNavigationHelper.swift   |  11 +-
 Bitkit/ViewModels/AppViewModel.swift          |  46 +-
 Bitkit/ViewModels/CurrencyViewModel.swift     |   5 +
 Bitkit/ViewModels/NavigationViewModel.swift   |   1 +
 Bitkit/ViewModels/WalletViewModel.swift       |   2 +
 Bitkit/Views/Contacts/AddContactView.swift    |   8 +-
 Bitkit/Views/Home/HomeWalletView.swift        |  25 +-
 .../CreatePaymentRequestView.swift            | 136 ++++--
 .../PaymentRequests/PaymentRequestsView.swift |  69 +--
 .../PubkyAuthApprovalSheet.swift              | 105 +++-
 Bitkit/Views/Sheets/Sheet.swift               |   3 +-
 .../CreateSubscriptionView.swift              |  48 +-
 .../Subscriptions/SubscriptionsView.swift     |  74 ++-
 .../Views/Wallets/Activity/ActivityRow.swift  |  33 +-
 .../Activity/ActivityRowLightning.swift       |  11 +-
 .../Wallets/Activity/ActivityRowOnchain.swift |  12 +-
 .../Views/Wallets/Receive/ReceiveEdit.swift   |   2 +-
 .../Views/Wallets/Receive/ReceiveSheet.swift  |  16 +-
 .../Views/Wallets/Send/LnurlPayConfirm.swift  |   7 +-
 .../Views/Wallets/Send/SendAmountView.swift   | 161 +++++--
 .../Wallets/Send/SendConfirmationView.swift   |  26 +-
 .../Wallets/Send/SendContactSelectView.swift  |  11 +-
 .../Wallets/Send/SendEnterManuallyView.swift  |  30 +-
 Bitkit/Views/Wallets/Send/SendSheet.swift     |  43 +-
 Bitkit/Views/Wallets/Send/SendSuccess.swift   |  22 +-
 Bitkit/Views/Wallets/Sheets/ReceivedTx.swift  |  45 +-
 Bitkit/Views/Wallets/UsdtActivityDetail.swift | 189 ++++++++
 .../Wallets/UsdtDepositHistoryView.swift      | 258 ++++++++++
 Bitkit/Views/Wallets/UsdtReceiveView.swift    | 167 +++++++
 Bitkit/Views/Wallets/UsdtSendView.swift       | 449 ++++++++++++++++++
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   | 136 ++++++
 BitkitTests/PaykitAmountTests.swift           |  47 ++
 .../PaykitPaymentProofServiceTests.swift      |  26 +-
 .../PaykitPaymentRequestServiceTests.swift    | 339 ++++++++++---
 .../PaykitPaymentStateBackupTests.swift       | 164 ++++++-
 BitkitTests/PaykitRequestPricingTests.swift   | 107 +++++
 .../PaykitSubscriptionProposalTests.swift     |  16 +-
 BitkitTests/PubkyAuthApprovalSheetTests.swift |  52 ++
 BitkitTests/ReceiveSheetSessionTests.swift    |   9 +-
 BitkitTests/ShopPaymentRequestTests.swift     |  40 ++
 BitkitTests/UsdtWalletManagerTests.swift      |  88 ++++
 BitkitUITests/UsdtWalletUITests.swift         | 163 +++++++
 Docs/USDT-QA.md                               |  70 +++
 Docs/USDT.md                                  |  45 ++
 Docs/earn-receiving-details.md                |  39 ++
 changelog.d/next/usdt.added.md                |   1 +
 journeys/paykit-quoted-usdt.xml               |  11 +
 .../pubky-auth/share-receiving-details.xml    |  13 +
 journeys/subscriptions/create-and-propose.xml |   2 +-
 journeys/usdt-wallet-navigation.xml           |  10 +
 scripts/build-usdt-local.sh                   |  31 ++
 88 files changed, 4965 insertions(+), 601 deletions(-)
 create mode 100644 Bitkit/Components/PaykitAmountText.swift
 create mode 100644 Bitkit/Components/PaymentAddressInput.swift
 create mode 100644 Bitkit/Components/PaymentCelebration.swift
 create mode 100644 Bitkit/Components/PaymentReviewIllustration.swift
 create mode 100644 Bitkit/Managers/UsdtWalletManager.swift
 create mode 100644 Bitkit/Models/PaykitAmount.swift
 create mode 100644 Bitkit/Models/PaykitRequestPricing.swift
 create mode 100644 Bitkit/Models/PaykitUsdt.swift
 create mode 100644 Bitkit/Models/PaykitUsdtStateBackup.swift
 create mode 100644 Bitkit/Services/PaykitUsdtPaymentService.swift
 create mode 100644 Bitkit/Views/Wallets/UsdtActivityDetail.swift
 create mode 100644 Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
 create mode 100644 Bitkit/Views/Wallets/UsdtReceiveView.swift
 create mode 100644 Bitkit/Views/Wallets/UsdtSendView.swift
 create mode 100644 Bitkit/Views/Wallets/UsdtWalletScreen.swift
 create mode 100644 BitkitTests/PaykitAmountTests.swift
 create mode 100644 BitkitTests/PaykitRequestPricingTests.swift
 create mode 100644 BitkitTests/UsdtWalletManagerTests.swift
 create mode 100644 BitkitUITests/UsdtWalletUITests.swift
 create mode 100644 Docs/USDT-QA.md
 create mode 100644 Docs/USDT.md
 create mode 100644 Docs/earn-receiving-details.md
 create mode 100644 changelog.d/next/usdt.added.md
 create mode 100644 journeys/paykit-quoted-usdt.xml
 create mode 100644 journeys/pubky-auth/share-receiving-details.xml
 create mode 100644 journeys/usdt-wallet-navigation.xml
 create mode 100755 scripts/build-usdt-local.sh

diff --git a/Bitkit.xcodeproj/project.pbxproj b/Bitkit.xcodeproj/project.pbxproj
index 1b8c4fc5c..8d81cf8c0 100644
--- a/Bitkit.xcodeproj/project.pbxproj
+++ b/Bitkit.xcodeproj/project.pbxproj
@@ -1226,7 +1226,7 @@
 			repositoryURL = "https://github.com/synonymdev/bitkit-core";
 			requirement = {
 				kind = exactVersion;
-				version = 0.5.18;
+				version = "0.8.0-rc1";
 			};
 		};
 		96E493A22C942FD1000E8BC2 /* XCRemoteSwiftPackageReference "swift-secp256k1" */ = {
diff --git a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
index 5d1fcfd97..cd0686b45 100644
--- a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
+++ b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -6,8 +6,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/synonymdev/bitkit-core",
       "state" : {
-        "revision" : "b53fa54a16f04940943072bb6e08dc2650302f93",
-        "version" : "0.5.18"
+        "revision" : "d0cbbf957ea7b00b4bc8e09cfe44aa0c7766a2ef",
+        "version" : "0.8.0-rc1"
       }
     },
     {
diff --git a/Bitkit/AppScene.swift b/Bitkit/AppScene.swift
index 0c0f87994..6572da50e 100644
--- a/Bitkit/AppScene.swift
+++ b/Bitkit/AppScene.swift
@@ -577,6 +577,7 @@ struct AppScene: View {
             .environment(trezorViewModel)
             .environment(jadeManager)
             .environment(hwWalletManager)
+            .environment(wallet.usdtWallet)
             .environment(calculatorInputManager)
             .environment(paykitPaymentRequestManager)
     }
@@ -1328,6 +1329,7 @@ struct AppScene: View {
         paykitPaymentRequestManager.updateSavedPublicKeys(contactsManager.contacts.map(\.publicKey))
         if mode == .full {
             await PaykitPaymentProofService.shared.reconcile()
+            await PaykitUsdtPaymentService.shared.reconcile(wallet: wallet.usdtWallet)
         }
         guard !Task.isCancelled, !onlyWhileActive || isPaykitSceneActive else { return false }
         guard let identity = pubkyProfile.publicKey else { return false }
@@ -1516,7 +1518,7 @@ struct AppScene: View {
                         }
                         return
                     }
-                    guard case let .opened(paymentTarget, privatePaymentContext) = result else {
+                    guard case let .opened(paymentTarget, privatePaymentContext, endpoints) = result else {
                         deferIncomingPaykitPaymentRequestPresentation(
                             request,
                             reason: result.incomingPaymentRequestFailureReason ?? .resolutionFailed
@@ -1527,7 +1529,8 @@ struct AppScene: View {
                     let contactPaymentContext = ContactPaymentContext(
                         publicKey: request.counterparty,
                         privatePaymentContext: privatePaymentContext,
-                        incomingPaymentRequest: request
+                        incomingPaymentRequest: request,
+                        endpoints: endpoints
                     )
                     guard app.claimContactPaymentContext(contactPaymentContext) else { return }
                     preparation.paymentContext = contactPaymentContext
diff --git a/Bitkit/Components/DrawerView.swift b/Bitkit/Components/DrawerView.swift
index 2a4881988..621000f56 100644
--- a/Bitkit/Components/DrawerView.swift
+++ b/Bitkit/Components/DrawerView.swift
@@ -240,6 +240,11 @@ struct DrawerView: View {
                 withAnimation(.easeOut(duration: 0.25).delay(0.1)) {
                     showMenu = true
                 }
+            } else {
+                withAnimation(.easeOut(duration: 0.25)) {
+                    showBackdrop = false
+                    showMenu = false
+                }
             }
         }
     }
diff --git a/Bitkit/Components/MoneyStack.swift b/Bitkit/Components/MoneyStack.swift
index a86447afd..3c1610bf5 100644
--- a/Bitkit/Components/MoneyStack.swift
+++ b/Bitkit/Components/MoneyStack.swift
@@ -19,36 +19,6 @@ struct MoneyStack: View {
 
     private let springAnimation = Animation.spring(response: 0.3, dampingFraction: 0.8)
 
-    var hideGesture: some Gesture {
-        DragGesture(minimumDistance: 50, coordinateSpace: .local)
-            .onEnded { value in
-                let horizontalAmount = value.translation.width
-                let verticalAmount = value.translation.height
-
-                // Only trigger if horizontal swipe is more significant than vertical
-                if abs(horizontalAmount) > abs(verticalAmount) {
-                    let wasHidden = settings.hideBalance
-                    withAnimation(springAnimation) {
-                        settings.hideBalance.toggle()
-                    }
-                    Haptics.play(.medium)
-
-                    // Show toast on first hide (when balance becomes hidden)
-                    if !wasHidden && settings.hideBalance && !settings.ignoresHideBalanceToast {
-                        app.toast(
-                            type: .info,
-                            title: t("wallet__balance_hidden_title"),
-                            description: t("wallet__balance_hidden_message"),
-                            visibilityTime: 5.0,
-                            accessibilityIdentifier: "BalanceHiddenToast"
-                        )
-
-                        settings.ignoresHideBalanceToast = true
-                    }
-                }
-            }
-    }
-
     var body: some View {
         VStack(alignment: .leading, spacing: 16) {
             if currency.primaryDisplay == .bitcoin {
@@ -177,7 +147,7 @@ struct MoneyStack: View {
             }
         }
         .animation(springAnimation, value: currency.primaryDisplay)
-        .highPriorityGesture(enableSwipeGesture ? hideGesture : nil)
+        .balanceVisibilityToggle(enabled: enableSwipeGesture)
         .animation(enableSwipeGesture ? springAnimation : nil, value: settings.hideBalance)
     }
 }
@@ -263,3 +233,50 @@ private extension MoneyStack {
     }
     .preferredColorScheme(.dark)
 }
+
+private struct BalanceVisibilityModifier: ViewModifier {
+    @EnvironmentObject private var app: AppViewModel
+    @EnvironmentObject private var settings: SettingsViewModel
+    let enabled: Bool
+    private let springAnimation = Animation.spring(response: 0.3, dampingFraction: 0.8)
+
+    var hideGesture: some Gesture {
+        DragGesture(minimumDistance: 50, coordinateSpace: .local)
+            .onEnded { value in
+                let horizontalAmount = value.translation.width
+                let verticalAmount = value.translation.height
+
+                // Only trigger if horizontal swipe is more significant than vertical
+                if abs(horizontalAmount) > abs(verticalAmount) {
+                    let wasHidden = settings.hideBalance
+                    withAnimation(springAnimation) {
+                        settings.hideBalance.toggle()
+                    }
+                    Haptics.play(.medium)
+
+                    // Show toast on first hide (when balance becomes hidden)
+                    if !wasHidden && settings.hideBalance && !settings.ignoresHideBalanceToast {
+                        app.toast(
+                            type: .info,
+                            title: t("wallet__balance_hidden_title"),
+                            description: t("wallet__balance_hidden_message"),
+                            visibilityTime: 5.0,
+                            accessibilityIdentifier: "BalanceHiddenToast"
+                        )
+
+                        settings.ignoresHideBalanceToast = true
+                    }
+                }
+            }
+    }
+
+    func body(content: Content) -> some View {
+        content.highPriorityGesture(enabled ? hideGesture : nil)
+    }
+}
+
+extension View {
+    func balanceVisibilityToggle(enabled: Bool = true) -> some View {
+        modifier(BalanceVisibilityModifier(enabled: enabled))
+    }
+}
diff --git a/Bitkit/Components/NumberPadTextField.swift b/Bitkit/Components/NumberPadTextField.swift
index bf99b31c9..6a2fd55db 100644
--- a/Bitkit/Components/NumberPadTextField.swift
+++ b/Bitkit/Components/NumberPadTextField.swift
@@ -97,25 +97,35 @@ struct NumberPadTextField: View {
         let isSuffix = currency.primaryDisplay == .fiat && isSuffixSymbolCurrency(currency.selectedCurrency)
         let symbolText = currency.primaryDisplay == .bitcoin ? "₿" : currency.symbol
 
-        HStack(spacing: 6) {
-            if !isSuffix {
-                Text(symbolText)
-                    .font(.custom(Fonts.extraBold, size: 44))
-                    .foregroundColor(.textSecondary)
-            }
+        NumberPadAmountText(
+            value: viewModel.displayText,
+            placeholder: viewModel.getPlaceholder(currency: currency),
+            symbol: symbolText,
+            isSymbolSuffix: isSuffix,
+            isFocused: isFocused
+        )
+    }
+}
 
-            // Value and placeholder
-            (Text(viewModel.displayText)
-                .foregroundColor(.textPrimary)
-                + Text(viewModel.getPlaceholder(currency: currency))
-                .foregroundColor(isFocused ? .textSecondary : .textPrimary))
-                .font(.custom(Fonts.black, size: 44))
+struct NumberPadAmountText: View {
+    let value: String
+    var placeholder: String = ""
+    let symbol: String
+    var isSymbolSuffix = false
+    var isFocused = true
 
-            if isSuffix {
-                Text(symbolText)
-                    .font(.custom(Fonts.extraBold, size: 44))
-                    .foregroundColor(.textSecondary)
-            }
+    var body: some View {
+        HStack(spacing: 6) {
+            if !isSymbolSuffix { symbolView }
+            (Text(value).foregroundColor(.textPrimary)
+                + Text(placeholder).foregroundColor(isFocused ? .textSecondary : .textPrimary))
+                .font(.custom(Fonts.black, size: 44))
+                .lineLimit(1).minimumScaleFactor(0.5)
+            if isSymbolSuffix { symbolView }
         }
     }
+
+    private var symbolView: some View {
+        Text(symbol).font(.custom(Fonts.extraBold, size: 44)).foregroundColor(.textSecondary)
+    }
 }
diff --git a/Bitkit/Components/PaykitAmountText.swift b/Bitkit/Components/PaykitAmountText.swift
new file mode 100644
index 000000000..6dde23439
--- /dev/null
+++ b/Bitkit/Components/PaykitAmountText.swift
@@ -0,0 +1,19 @@
+import SwiftUI
+
+struct PaykitAmountText: View {
+    let amount: PaykitAmount
+    var size: MoneySize = .bodyMSB
+    var prefix = ""
+    var color: Color = .textPrimary
+
+    var body: some View {
+        if amount.asset == .btc {
+            MoneyText(sats: Int(clamping: amount.atomic), size: size, symbol: true,
+                      prefix: prefix, color: color, symbolColor: .textSecondary, fillsWidth: false)
+        } else if size == .display {
+            NumberPadAmountText(value: prefix + amount.value, symbol: amount.asset == .usd ? "$" : "₮")
+        } else {
+            BodyMSBText(prefix + (amount.asset == .usd ? "$" : "₮") + amount.value, textColor: color)
+        }
+    }
+}
diff --git a/Bitkit/Components/PaymentAddressInput.swift b/Bitkit/Components/PaymentAddressInput.swift
new file mode 100644
index 000000000..0d59db984
--- /dev/null
+++ b/Bitkit/Components/PaymentAddressInput.swift
@@ -0,0 +1,33 @@
+import SwiftUI
+
+struct PaymentAddressInput: View {
+    @Binding var text: String
+    var isFocused: FocusState<Bool>.Binding
+    let placeholder: String
+    let testIdentifier: String
+
+    var body: some View {
+        ZStack(alignment: .topLeading) {
+            if text.isEmpty {
+                TitleText(placeholder, textColor: .textSecondary).padding(20)
+            }
+            TextEditor(text: $text)
+                .focused(isFocused)
+                .padding(EdgeInsets(top: -10, leading: -5, bottom: -5, trailing: -5))
+                .padding(20)
+                .frame(maxHeight: .infinity)
+                .scrollContentBackground(.hidden)
+                .font(.custom(Fonts.bold, size: 22))
+                .foregroundColor(.textPrimary)
+                .accentColor(.brandAccent)
+                .submitLabel(.done)
+                .textInputAutocapitalization(.never)
+                .autocorrectionDisabled()
+                .dismissKeyboardOnReturn(text: $text, isFocused: isFocused)
+                .accessibilityValue(text)
+                .accessibilityIdentifier(testIdentifier)
+        }
+        .background(Color.white06)
+        .cornerRadius(8)
+    }
+}
diff --git a/Bitkit/Components/PaymentCelebration.swift b/Bitkit/Components/PaymentCelebration.swift
new file mode 100644
index 000000000..4e10e0fd2
--- /dev/null
+++ b/Bitkit/Components/PaymentCelebration.swift
@@ -0,0 +1,35 @@
+import Lottie
+import SwiftUI
+
+struct PaymentCelebration: View {
+    let isOnchain: Bool
+    let isReceived: Bool
+    var confettiColor: Color?
+
+    var body: some View {
+        ZStack {
+            LottieView(animation: .named(isOnchain ? "confetti-orange" : "confetti-purple"))
+                .configure { animationView in
+                    let keypath = AnimationKeypath(keypath: "**.Color")
+                    if let confettiColor {
+                        animationView.setValueProvider(ColorValueProvider(UIColor(confettiColor).lottieColorValue), keypath: keypath)
+                    } else {
+                        animationView.removeValueProvider(for: keypath)
+                    }
+                }
+                .playing(loopMode: .loop)
+                .scaleEffect(1.9)
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+
+            if isReceived {
+                Image("coins-received")
+                    .resizable()
+                    .aspectRatio(contentMode: .fit)
+                    .frame(maxWidth: .infinity, alignment: .center)
+                    .offset(y: 50)
+            }
+        }
+        .allowsHitTesting(false)
+        .accessibilityHidden(true)
+    }
+}
diff --git a/Bitkit/Components/PaymentReviewIllustration.swift b/Bitkit/Components/PaymentReviewIllustration.swift
new file mode 100644
index 000000000..d42265a26
--- /dev/null
+++ b/Bitkit/Components/PaymentReviewIllustration.swift
@@ -0,0 +1,17 @@
+import SwiftUI
+
+struct PaymentReviewIllustration: View {
+    var swipeProgress: CGFloat = 0
+    var maximumHeight: CGFloat?
+
+    var body: some View {
+        Image("coin-stack-4")
+            .resizable()
+            .aspectRatio(contentMode: .fit)
+            .frame(maxHeight: maximumHeight)
+            .frame(width: UIScreen.main.bounds.width * 0.8)
+            .frame(maxWidth: .infinity)
+            .padding(.bottom, 16)
+            .rotationEffect(.degrees(swipeProgress * 14))
+    }
+}
diff --git a/Bitkit/Components/WalletBalanceView.swift b/Bitkit/Components/WalletBalanceView.swift
index c415a7faf..1bb2b0d59 100644
--- a/Bitkit/Components/WalletBalanceView.swift
+++ b/Bitkit/Components/WalletBalanceView.swift
@@ -8,27 +8,16 @@ struct WalletBalanceView: View {
     @EnvironmentObject var currency: CurrencyViewModel
 
     var body: some View {
-        VStack(alignment: .leading) {
+        WalletBalanceContent {
             CaptionMText(type.title)
-                .padding(.bottom, 4)
-
-            HStack(spacing: 4) {
-                Image(type.imageAsset)
-                    .resizable()
-                    .scaledToFit()
-                    .frame(width: 24, height: 24)
-                    .padding(.trailing, 4)
-
-                MoneyText(
-                    sats: Int(sats),
-                    size: .subtitle,
-                    enableHide: true,
-                    symbolColor: .textPrimary,
-                    testIdentifier: amountTestIdentifier
-                )
-            }
+        } icon: {
+            Image(type.imageAsset).resizable().scaledToFit().frame(width: 24, height: 24)
+        } amount: {
+            MoneyText(
+                sats: Int(sats), size: .subtitle, enableHide: true,
+                symbolColor: .textPrimary, testIdentifier: amountTestIdentifier
+            )
         }
-        .frame(maxWidth: .infinity, alignment: .leading)
     }
 }
 
@@ -142,3 +131,20 @@ struct WalletBalanceView: View {
     .padding()
     .preferredColorScheme(.dark)
 }
+
+struct WalletBalanceContent<Label: View, Icon: View, Amount: View>: View {
+    @ViewBuilder var label: () -> Label
+    @ViewBuilder var icon: () -> Icon
+    @ViewBuilder var amount: () -> Amount
+
+    var body: some View {
+        VStack(alignment: .leading) {
+            label().padding(.bottom, 4)
+            HStack(spacing: 4) {
+                icon().padding(.trailing, 4)
+                amount()
+            }
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+}
diff --git a/Bitkit/Constants/Env.swift b/Bitkit/Constants/Env.swift
index ad0b8794c..6fe74c945 100644
--- a/Bitkit/Constants/Env.swift
+++ b/Bitkit/Constants/Env.swift
@@ -6,6 +6,36 @@ import LocalAuthentication
 enum Env {
     static let appName = "bitkit"
 
+    static var isUsdtEnabled: Bool {
+        (network == .bitcoin || isDebug) && usdtBundlerUrl != nil && usdtRpcUrl != nil
+    }
+
+    static var usdtBundlerUrl: String? {
+        configValue("USDT_BUNDLER_URL")
+    }
+
+    static var usdtDepositsUrl: String? {
+        configValue("USDT_DEPOSITS_URL")
+    }
+
+    static var usdtBridgesUrl: String? {
+        configValue("USDT_BRIDGES_URL")
+    }
+
+    static var usdtRpcUrl: String? {
+        configValue("USDT_RPC_URL")
+    }
+
+    static var usdtDestinations: [UsdtDestination] {
+        let enabled = Set((configValue("USDT_BRIDGE_NETWORKS") ?? "").split(separator: ",").map {
+            $0.trimmingCharacters(in: .whitespacesAndNewlines)
+        })
+        let bridges: [(String, UsdtDestination)] = [
+            ("ethereum", .ethereum), ("polygon", .polygon), ("plasma", .plasma), ("stable", .stable),
+        ]
+        return [.arbitrum] + bridges.filter { enabled.contains($0.0) }.map(\.1)
+    }
+
     static let isPreview = ProcessInfo.processInfo.environment["XCODE_RUNNING_FOR_PREVIEWS"] == "1"
     static let isTestFlight = Bundle.main.appStoreReceiptURL?.lastPathComponent == "sandboxReceipt"
     static let isUnitTest = ProcessInfo.processInfo.environment["XCTestConfigurationFilePath"] != nil
diff --git a/Bitkit/Info.plist b/Bitkit/Info.plist
index 78e2e253a..e59e3a2e0 100644
--- a/Bitkit/Info.plist
+++ b/Bitkit/Info.plist
@@ -2,6 +2,18 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>UIDesignRequiresCompatibility</key>
+	<true/>
+	<key>USDT_BRIDGE_NETWORKS</key>
+	<string>$(USDT_BRIDGE_NETWORKS)</string>
+	<key>USDT_BUNDLER_URL</key>
+	<string>$(USDT_BUNDLER_URL)</string>
+	<key>USDT_DEPOSITS_URL</key>
+	<string>$(USDT_DEPOSITS_URL)</string>
+	<key>USDT_BRIDGES_URL</key>
+	<string>$(USDT_BRIDGES_URL)</string>
+	<key>USDT_RPC_URL</key>
+	<string>$(USDT_RPC_URL)</string>
 	<key>CFBundleURLTypes</key>
 	<array>
 		<dict>
diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 7f87a7032..7c5fcce04 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -20,6 +20,7 @@ struct MainNavView: View {
     @Environment(TrezorManager.self) private var trezorManager
     @Environment(HwWalletManager.self) private var hwWalletManager
     @Environment(PaykitPaymentRequestManager.self) private var paykitPaymentRequestManager
+    @Environment(UsdtWalletManager.self) private var usdt
     @Environment(\.scenePhase) var scenePhase
 
     @State private var showClipboardAlert = false
@@ -286,6 +287,18 @@ struct MainNavView: View {
                 sheets.hideSheetIfActive(.hardwarePairing, reason: "Pairing code resolved")
             }
         }
+        .task(id: scenePhase) {
+            guard usdt.isConfigured, scenePhase == .active else { return }
+            while !Task.isCancelled {
+                await usdt.refresh(includeHistory: true)
+                let pending = usdt.transfers.contains { $0.status == .pending }
+                try? await Task.sleep(for: .seconds(pending ? 10 : 30))
+            }
+        }
+        .onReceive(usdt.receivedTxPublisher) { tx in
+            guard navigation.currentRoute != .usdtWallet, !wallet.isRestoringWallet else { return }
+            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount))
+        }
         .onReceive(hwWalletManager.receivedTxPublisher) { tx in
             // New inbound transaction to a watched hardware wallet — show the received celebration.
             sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, sats: tx.sats))
@@ -296,6 +309,11 @@ struct MainNavView: View {
                 .ignoresSafeArea(.keyboard)
             DrawerView()
         }
+        .onChange(of: sheets.activeSheetConfiguration?.id) { _, sheet in
+            if sheet != nil {
+                app.showDrawer = false
+            }
+        }
         .onChange(of: scenePhase) { _, newPhase in
             if newPhase == .active {
                 // Update permissions in case user changed them in OS settings
@@ -444,6 +462,7 @@ struct MainNavView: View {
                 case .savingsWallet: SavingsWalletScreen()
                 case .spendingWallet: SpendingWalletScreen()
                 case let .hardwareWallet(walletId): HardwareWalletScreen(walletId: walletId)
+                case .usdtWallet: UsdtWalletScreen()
                 case .scanner: ScannerScreen()
 
                 // Transfer
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
new file mode 100644
index 000000000..c92712210
--- /dev/null
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -0,0 +1,402 @@
+import BitkitCore
+import Combine
+import CryptoKit
+import Foundation
+import Observation
+
+@Observable @MainActor
+final class UsdtWalletManager {
+    private nonisolated(unsafe) static let backupStateChanged = PassthroughSubject<Void, Never>()
+    nonisolated static var walletBackupDataChangedPublisher: AnyPublisher<Void, Never> {
+        backupStateChanged.eraseToAnyPublisher()
+    }
+
+    let receivedTxPublisher = PassthroughSubject<UsdtTransfer, Never>()
+    private(set) var balance: UInt64?
+    private(set) var address = ""
+    private(set) var receiveUri = ""
+    private(set) var transfers: [UsdtTransfer] = [] {
+        didSet { if oldValue != transfers { Self.backupStateChanged.send() } }
+    }
+
+    private(set) var historyComplete = false
+    private(set) var refreshing = false
+    var errorMessage: String?
+    var isSendPresented = false
+    private var core: UsdtWallet?
+    private var credentialFingerprint: SHA256.Digest?
+    private let storageDirectory: URL
+    private var wiping = false
+    private var activeOperations = 0
+    private var initialization: Task<UsdtWallet, Error>?
+    private var wipeTask: Task<Void, Error>?
+    private var nextRefresh = Date.distantPast
+    private var rateLimitedUntil = Date.distantPast
+    private var idleWaiter: CheckedContinuation<Void, Never>?
+
+    var isConfigured: Bool {
+        Env.isUsdtEnabled
+    }
+
+    var networkName: String {
+        "Arbitrum One"
+    }
+
+    init(storageDirectory: URL = Env.bitkitCoreStorage(walletIndex: 0)) {
+        self.storageDirectory = storageDirectory
+    }
+
+    func refresh(includeHistory: Bool = false) async {
+        guard isConfigured, !refreshing, !wiping else { return }
+        guard Date() >= max(nextRefresh, rateLimitedUntil) else { return }
+        var refreshDelay: TimeInterval = 10
+        activeOperations += 1
+        refreshing = true
+        defer { refreshing = false; nextRefresh = max(rateLimitedUntil, Date().addingTimeInterval(refreshDelay)); finishOperation() }
+        do {
+            let wallet = try await wallet()
+            let previousTransfers = historyComplete ? transfers : nil
+            transfers = try await ServiceQueue.background(.core, wrapErrors: false) { try wallet.history() }
+            var settlementError: Error?
+            do {
+                balance = try await wallet.balance()
+                transfers = try await wallet.refreshTransfers()
+            } catch is CancellationError {
+                throw CancellationError()
+            } catch {
+                if let error = error as? UsdtError, case .RateLimited = error { throw error }
+                settlementError = error
+            }
+            try Task.checkCancellation()
+            if includeHistory, !isSendPresented {
+                let complete = try await wallet.syncHistory()
+                historyComplete = historyComplete || complete
+                transfers = try await ServiceQueue.background(.core, wrapErrors: false) { try wallet.history() }
+                for transfer in Self.newIncomingTransfers(previous: previousTransfers, current: transfers) {
+                    receivedTxPublisher.send(transfer)
+                }
+            }
+            if let settlementError { throw settlementError }
+            errorMessage = nil
+        } catch is CancellationError {
+        } catch {
+            if let error = error as? UsdtError, case .RateLimited = error { refreshDelay = 60; rateLimitedUntil = Date().addingTimeInterval(60) }
+            errorMessage = Self.message(for: error)
+            Logger.warn("Failed to refresh USDT: \(Self.message(for: error))", context: "UsdtWalletManager")
+        }
+    }
+
+    static func newIncomingTransfers(previous: [UsdtTransfer]?, current: [UsdtTransfer]) -> [UsdtTransfer] {
+        guard let previous else { return [] }
+        let knownIds = Set(previous.filter { $0.isIncoming && $0.status == .confirmed }.map(\.id))
+        return current.filter { $0.isIncoming && $0.status == .confirmed && $0.amount > 0 && !knownIds.contains($0.id) }
+    }
+
+    func quote(recipient: String, amount: String, destination: UsdtDestination) async throws -> UsdtQuote {
+        try beginOperation()
+        defer { finishOperation() }
+        let value = try usdtParseAmount(value: amount.replacingOccurrences(of: Locale.current.decimalSeparator ?? ".", with: "."))
+        let wallet = try await wallet()
+        return try await wallet.quoteTransfer(recipient: recipient, amount: value, destination: destination)
+    }
+
+    func backupSnapshot() async throws -> String? {
+        guard isConfigured else {
+            if FileManager.default.fileExists(atPath: storageDirectory.path) {
+                let files = try FileManager.default.contentsOfDirectory(at: storageDirectory, includingPropertiesForKeys: nil)
+                guard !files.contains(where: { $0.lastPathComponent.hasPrefix("usdt-") && $0.pathExtension == "sqlite" }) else {
+                    throw UsdtError.NotConfigured
+                }
+            }
+            return nil
+        }
+        try beginOperation()
+        defer { finishOperation() }
+        let wallet = try await wallet()
+        return try await ServiceQueue.background(.core, wrapErrors: false) { try wallet.exportBackup() }
+    }
+
+    func restoreBackup(_ snapshot: String) async throws {
+        try beginOperation()
+        defer { finishOperation() }
+        let wallet = try await wallet()
+        try await wallet.restoreBackup(snapshot: snapshot)
+        transfers = try wallet.history()
+        historyComplete = false
+    }
+
+    func paymentEndpoint() async throws -> PublicPaykitService.Endpoint {
+        try beginOperation()
+        defer { finishOperation() }
+        let wallet = try await wallet()
+        return try PaykitUsdt.endpoint(address: wallet.receiveAddress())
+    }
+
+    func send(_ quote: UsdtQuote) async throws {
+        try beginOperation()
+        defer { finishOperation() }
+        let wallet = try await wallet()
+        let transfer = try await ServiceQueue.background(.core, wrapErrors: false) {
+            guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
+            let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
+            return try await wallet.send(quoteId: quote.id, mnemonic: mnemonic, passphrase: passphrase)
+        }
+        transfers.removeAll { $0.id == transfer.id }
+        transfers.insert(transfer, at: 0)
+    }
+
+    func paymentProof(quoteId: String, binding: UsdtPaymentProofBinding) async throws -> UsdtPaymentProof? {
+        try beginOperation()
+        defer { finishOperation() }
+        let core = try await wallet()
+        guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
+        return try await core.createPaymentProof(transferId: quoteId, binding: binding, mnemonic: mnemonic,
+                                                 passphrase: Keychain.loadString(key: .bip39Passphrase(index: 0)))
+    }
+
+    func storedTransfer(_ id: String) async throws -> UsdtTransfer? {
+        try beginOperation()
+        defer { finishOperation() }
+        let core = try await wallet()
+        return try await ServiceQueue.background(.core, wrapErrors: false) { try core.history().first { $0.id == id } }
+    }
+
+    func verifyPayment(binding: UsdtPaymentProofBinding, proof: UsdtPaymentProof) async throws -> UsdtVerifiedPayment? {
+        try beginOperation()
+        defer { finishOperation() }
+        return try await wallet().verifyPaymentProof(binding: binding, proof: proof)
+    }
+
+    func waitForTransfer(_ id: String) async {
+        guard isConfigured, !wiping, !refreshing, !Task.isCancelled, Date() >= rateLimitedUntil else { return }
+        refreshing = true
+        defer { refreshing = false }
+        do {
+            try beginOperation()
+            defer { finishOperation() }
+            let wallet = try await wallet()
+            let clock = ContinuousClock()
+            let deadline = clock.now.advanced(by: .seconds(5))
+            while clock.now < deadline {
+                try Task.checkCancellation()
+                let transfer = try await Task.detached { try await wallet.checkRecentExecution(id: id) }.value
+                try Task.checkCancellation()
+                guard let transfer else { return }
+                transfers.removeAll { $0.id == transfer.id }
+                transfers.insert(transfer, at: 0)
+                errorMessage = nil
+                if transfer.status != .pending { return }
+                try await Task.sleep(for: .seconds(1))
+            }
+        } catch is CancellationError {
+        } catch {
+            if let error = error as? UsdtError, case .RateLimited = error {
+                rateLimitedUntil = Date().addingTimeInterval(60)
+                nextRefresh = max(nextRefresh, rateLimitedUntil)
+            }
+            guard !Task.isCancelled else { return }
+            errorMessage = Self.message(for: error)
+            Logger.warn("Failed to check USDT payment: \(Self.message(for: error))", context: "UsdtWalletManager")
+        }
+    }
+
+    var depositsConfigured: Bool {
+        isConfigured && Env.usdtDepositsUrl != nil
+    }
+
+    func sendDestinations() async throws -> [UsdtDestination] {
+        try beginOperation()
+        defer { finishOperation() }
+        let extra = try await wallet().orchestraDestinations()
+        return Env.usdtDestinations + extra.filter { !Env.usdtDestinations.contains($0) }
+    }
+
+    func depositNetworks() async throws -> [UsdtDepositNetwork] {
+        guard depositsConfigured else { return [] }
+        return try await withDeposits { client, _, _ in try await client.networks() }
+    }
+
+    func prepareDeposit(network: UsdtDepositNetwork, amount: String) async throws -> UsdtDepositAddress {
+        let value = try usdtParseAmount(value: amount.replacingOccurrences(of: Locale.current.decimalSeparator ?? ".", with: "."))
+        return try await withDeposits { client, mnemonic, passphrase in
+            try await client.receive(network: network, amount: value, mnemonic: mnemonic, passphrase: passphrase)
+        }
+    }
+
+    func depositHistory(offset: UInt32) async throws -> UsdtDepositPage {
+        try await withDeposits { client, mnemonic, passphrase in
+            try await client.history(offset: offset, mnemonic: mnemonic, passphrase: passphrase)
+        }
+    }
+
+    func depositDetail(id: String, offset: UInt32) async throws -> UsdtDepositDetail {
+        try await withDeposits { client, mnemonic, passphrase in
+            try await client.detail(depositId: id, offset: offset, mnemonic: mnemonic, passphrase: passphrase)
+        }
+    }
+
+    func refundDeposit(_ deposit: UsdtDeposit, offset: UInt32, address: String) async throws {
+        guard let network = UsdtDepositNetwork.named(deposit.network) else { throw UsdtError.DepositNeedsAttention }
+        try await withDeposits { client, mnemonic, passphrase in
+            try await client.requestRefund(depositId: deposit.id, offset: offset, refundAddress: address,
+                                           network: network, mnemonic: mnemonic, passphrase: passphrase)
+        }
+    }
+
+    private func withDeposits<T>(_ operation: @escaping @Sendable (UsdtDepositClient, String, String?) async throws -> T) async throws -> T {
+        try beginOperation()
+        defer { finishOperation() }
+        guard depositsConfigured, let url = Env.usdtDepositsUrl else { throw UsdtError.NotConfigured }
+        return try await ServiceQueue.background(.core, wrapErrors: false) {
+            guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
+            let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
+            let owner = try usdtAddress(mnemonic: mnemonic, passphrase: passphrase)
+            let client = try UsdtDepositClient(address: owner, serviceUrl: url)
+            return try await operation(client, mnemonic, passphrase)
+        }
+    }
+
+    func wipe() async throws {
+        if let wipeTask { return try await wipeTask.value }
+        wiping = true
+        let task = Task { try await performWipe() }
+        wipeTask = task
+        defer { wipeTask = nil }
+        try await task.value
+    }
+
+    private func performWipe() async throws {
+        if activeOperations > 0 {
+            await withCheckedContinuation { idleWaiter = $0 }
+        }
+        core = nil
+        credentialFingerprint = nil
+        balance = nil
+        address = ""
+        receiveUri = ""
+        transfers = []
+        historyComplete = false
+        errorMessage = nil
+        let directory = storageDirectory
+        try await ServiceQueue.background(.core, wrapErrors: false) {
+            guard FileManager.default.fileExists(atPath: directory.path) else { return }
+            let files = try FileManager.default.contentsOfDirectory(at: directory, includingPropertiesForKeys: nil)
+            for file in files where file.lastPathComponent.hasPrefix("usdt-") &&
+                ["sqlite", "sqlite-wal", "sqlite-shm"].contains(file.pathExtension)
+            {
+                try FileManager.default.removeItem(at: file)
+            }
+        }
+    }
+
+    private func beginOperation() throws {
+        guard !wiping else { throw CancellationError() }
+        activeOperations += 1
+    }
+
+    private func finishOperation() {
+        activeOperations -= 1
+        if activeOperations == 0 {
+            idleWaiter?.resume()
+            idleWaiter = nil
+        }
+    }
+
+    private func wallet() async throws -> UsdtWallet {
+        guard isConfigured, let bundlerUrl = Env.usdtBundlerUrl, let rpcUrl = Env.usdtRpcUrl else { throw UsdtError.NotConfigured }
+        if let initialization { return try await initialization.value }
+        let task = Task { try await initializeWallet(bundlerUrl: bundlerUrl, rpcUrl: rpcUrl) }
+        initialization = task
+        defer { initialization = nil }
+        return try await task.value
+    }
+
+    private func initializeWallet(bundlerUrl: String, rpcUrl: String) async throws -> UsdtWallet {
+        let credentials = try await ServiceQueue.background(.core, wrapErrors: false) {
+            guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
+            let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
+            return (mnemonic, passphrase)
+        }
+        let fingerprint = try SHA256.hash(data: JSONEncoder().encode([credentials.0, credentials.1 ?? ""]))
+        if credentialFingerprint != fingerprint { core = nil; balance = nil; transfers = []; historyComplete = false }
+        if let core { return core }
+        let address = try await ServiceQueue.background(.core, wrapErrors: false) {
+            try usdtAddress(mnemonic: credentials.0, passphrase: credentials.1)
+        }
+        let path = storageDirectory.appendingPathComponent("usdt-\(address).sqlite").path
+        let wallet = try await ServiceQueue.background(.core, wrapErrors: false) {
+            try UsdtWallet(
+                address: address,
+                storagePath: path,
+                rpcUrl: rpcUrl,
+                bundlerUrl: bundlerUrl,
+                bridgeUrl: Env.usdtBridgesUrl,
+                backup: UsdtVssBackup()
+            )
+        }
+        credentialFingerprint = fingerprint
+        self.address = wallet.receiveAddress()
+        receiveUri = wallet.receiveUri()
+        core = wallet
+        return wallet
+    }
+
+    static func message(for error: Error) -> String {
+        guard let error = error as? UsdtError else { return t("usdt__error_network") }
+        switch error {
+        case .NotConfigured: return t("usdt__error_configuration")
+        case .InvalidAmount: return t("usdt__error_amount")
+        case .InvalidAddress, .WrongNetwork: return t("usdt__error_address")
+        case .InsufficientBalance: return t("usdt__error_balance")
+        case .QuoteExpired: return t("usdt__error_expired")
+        case .PendingTransfer: return t("usdt__error_pending")
+        case .DepositNeedsAttention: return t("usdt__deposit_attention")
+        case .DepositNotFound: return t("usdt__deposit_not_found")
+        case .DepositAuthorizationRejected: return t("usdt__deposit_authorization")
+        case let .DepositAmountOutOfRange(minUsdCents, maxUsdCents):
+            let message = t("usdt__deposit_amount_out_of_range")
+            guard minUsdCents != nil || maxUsdCents != nil else { return message }
+            return t("usdt__deposit_limits") + ": " +
+                (minUsdCents?.usdCents ?? "—") + " – " + (maxUsdCents?.usdCents ?? "—")
+        case .UnsupportedRoute: return t("usdt__error_route")
+        case .InvalidCredentials: return t("usdt__error_wallet")
+        case .ClockSkew: return t("usdt__error_clock")
+        case .UnsupportedDelegation: return t("usdt__error_delegation")
+        case .BackupUnavailable: return t("usdt__error_backup")
+        case .InvalidBackup: return t("usdt__error_storage")
+        case .Storage: return t("usdt__error_storage")
+        case .RateLimited: return t("usdt__error_rate_limit")
+        case .LogRangeTooLarge: return t("usdt__error_response")
+        case .InvalidPaymentProof, .InvalidResponse: return t("usdt__error_response")
+        case .TransactionRejected: return t("usdt__error_rejected")
+        case .NetworkUnavailable: return t("usdt__error_network")
+        }
+    }
+}
+
+extension UsdtDepositNetwork {
+    static func named(_ value: String) -> Self? {
+        switch value { case "solana": .solana
+        case "polygon": .polygon
+        case "bsc": .bsc
+        case "base": .base
+        case "tron": .tron; case "ethereum": .ethereum; default: nil }
+    }
+}
+
+extension String {
+    var usdCents: String {
+        guard let value = UInt64(self) else { return "—" }
+        return "$\((value / 100).formatted()).\(String(format: "%02d", value % 100))"
+    }
+}
+
+private final class UsdtVssBackup: UsdtBackup, @unchecked Sendable {
+    func persist(snapshot: String) async throws {
+        do {
+            try await BackupService.shared.persistWalletBackup(usdt: snapshot)
+        } catch {
+            throw UsdtError.BackupUnavailable
+        }
+    }
+}
diff --git a/Bitkit/Models/BackupPayloads.swift b/Bitkit/Models/BackupPayloads.swift
index 2c9e26d83..0b99b5de6 100644
--- a/Bitkit/Models/BackupPayloads.swift
+++ b/Bitkit/Models/BackupPayloads.swift
@@ -11,6 +11,7 @@ struct WalletBackupV1: Codable {
     let paykitSdkBackupState: String?
     let watchOnlyAccounts: [WatchOnlyAccountRecord]?
     let watchOnlyAccountAllocationState: WatchOnlyAccountAllocationState?
+    var usdtWallet: String? = nil
     var paykitPaymentState: PaykitPaymentStateBackup? = nil
 }
 
diff --git a/Bitkit/Models/PaykitAmount.swift b/Bitkit/Models/PaykitAmount.swift
new file mode 100644
index 000000000..049dc47d7
--- /dev/null
+++ b/Bitkit/Models/PaykitAmount.swift
@@ -0,0 +1,122 @@
+import Foundation
+
+enum PaykitAsset: String, Codable, CaseIterable {
+    case btc
+    case usd
+    case usdt
+
+    var decimals: Int {
+        switch self {
+        case .btc: 8
+        case .usd: 2
+        case .usdt: 6
+        }
+    }
+}
+
+enum PaykitAmountError: LocalizedError, Equatable {
+    case invalidAmount
+    case rateUnavailable
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidAmount: t("wallet__payment_request_mismatch")
+        case .rateUnavailable: t("wallet__payment_request_rate_unavailable")
+        }
+    }
+}
+
+struct PaykitExchangeRate: Codable, Equatable, Hashable {
+    static let maximumAge: TimeInterval = 10 * 60
+    private static let maximumPriceDigits = 18
+
+    let price: String
+    let timestamp: Date
+
+    func value(at date: Date) throws -> Decimal {
+        guard timestamp <= date, date.timeIntervalSince(timestamp) <= Self.maximumAge,
+              price.filter({ $0 != "." }).count <= Self.maximumPriceDigits,
+              price.range(of: "^[0-9]+(?:\\.[0-9]+)?$", options: .regularExpression) != nil,
+              let value = Decimal(string: price, locale: Locale(identifier: "en_US_POSIX")),
+              !value.isNaN, value > 0
+        else { throw PaykitAmountError.rateUnavailable }
+        return value
+    }
+}
+
+struct PaykitAmount: Codable, Hashable {
+    let asset: PaykitAsset
+    let atomic: UInt64
+
+    init(asset: PaykitAsset, atomic: UInt64) {
+        self.asset = asset
+        self.atomic = atomic
+    }
+
+    init(asset: PaykitAsset, value: String) throws {
+        let parts = value.split(separator: ".", omittingEmptySubsequences: false)
+        guard !parts.isEmpty, parts.count <= 2, !parts[0].isEmpty,
+              parts.allSatisfy({ !$0.isEmpty && $0.utf8.allSatisfy { (48 ... 57).contains($0) } }),
+              let whole = UInt64(parts[0])
+        else { throw PaykitAmountError.invalidAmount }
+        var fraction = parts.count == 2 ? String(parts[1]) : ""
+        while fraction.last == "0" {
+            fraction.removeLast()
+        }
+        guard fraction.count <= asset.decimals else { throw PaykitAmountError.invalidAmount }
+        let fractional = UInt64(fraction.padding(toLength: asset.decimals, withPad: "0", startingAt: 0)) ?? 0
+        let (base, overflow) = whole.multipliedReportingOverflow(by: NSDecimalNumber(decimal: Self.scale(asset)).uint64Value)
+        let (atomic, additionOverflow) = base.addingReportingOverflow(fractional)
+        guard !overflow, !additionOverflow, atomic > 0 else { throw PaykitAmountError.invalidAmount }
+        self.init(asset: asset, atomic: atomic)
+    }
+
+    var value: String {
+        NSDecimalNumber(decimal: Decimal(atomic) / Self.scale(asset)).stringValue
+    }
+
+    func converted(to paymentAsset: PaykitAsset, rate: PaykitExchangeRate?, at date: Date) throws -> PaykitAmount {
+        let value = try value(in: paymentAsset, rate: rate, at: date)
+        return try PaykitAmount(asset: paymentAsset, atomic: Self.integer(value * Self.scale(paymentAsset), rounding: .up))
+    }
+
+    func quoted(to asset: PaykitAsset, multiplier: String) throws -> PaykitAmount {
+        guard multiplier.count <= 80,
+              multiplier.replacingOccurrences(of: ".", with: "").trimmingCharacters(in: CharacterSet(charactersIn: "0")).count <= 38,
+              multiplier.range(of: "^(?:[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+)$", options: .regularExpression) != nil,
+              let rate = Decimal(string: multiplier, locale: Locale(identifier: "en_US_POSIX")),
+              !rate.isNaN, rate > 0
+        else { throw PaykitAmountError.rateUnavailable }
+        var amount = Decimal(atomic)
+        var factor = rate
+        var product = Decimal()
+        guard NSDecimalMultiply(&product, &amount, &factor, .plain) == .noError else { throw PaykitAmountError.invalidAmount }
+        let shift = asset.decimals - self.asset.decimals
+        var scaled = Decimal()
+        guard NSDecimalMultiplyByPowerOf10(&scaled, &product, Int16(shift), .plain) == .noError else {
+            throw PaykitAmountError.invalidAmount
+        }
+        return try PaykitAmount(asset: asset, atomic: Self.integer(scaled, rounding: .up))
+    }
+
+    private func value(in target: PaykitAsset, rate: PaykitExchangeRate?, at date: Date) throws -> Decimal {
+        let amount = Decimal(atomic) / Self.scale(asset)
+        guard (asset == .btc) != (target == .btc) else { return amount }
+        guard let rate else { throw PaykitAmountError.rateUnavailable }
+        let price = try rate.value(at: date)
+        return asset == .btc ? amount * price : amount / price
+    }
+
+    private static func scale(_ asset: PaykitAsset) -> Decimal {
+        pow(Decimal(10), asset.decimals)
+    }
+
+    private static func integer(_ value: Decimal, rounding: Decimal.RoundingMode) throws -> UInt64 {
+        guard !value.isNaN else { throw PaykitAmountError.invalidAmount }
+        var source = value
+        var rounded = Decimal()
+        NSDecimalRound(&rounded, &source, 0, rounding)
+        guard rounded >= 0, rounded <= Decimal(UInt64.max) else { throw PaykitAmountError.invalidAmount }
+        return NSDecimalNumber(decimal: rounded).uint64Value
+    }
+}
diff --git a/Bitkit/Models/PaykitPaymentStateBackup.swift b/Bitkit/Models/PaykitPaymentStateBackup.swift
index 3bfd51b43..a8365ec33 100644
--- a/Bitkit/Models/PaykitPaymentStateBackup.swift
+++ b/Bitkit/Models/PaykitPaymentStateBackup.swift
@@ -6,6 +6,7 @@ struct PaykitPaymentStateBackup: Codable {
     let subscriptions: [String: Subscription]
     let pendingProofs: [Proof]
     var activeOnchainAttempt: ActiveOnchainAttempt? = nil
+    var usdt: PaykitUsdtStateBackup? = nil
     var acceptedOneTimeRequests: [String: [RequestID]]? = nil
 
     struct RequestID: Codable {
@@ -13,6 +14,12 @@ struct PaykitPaymentStateBackup: Codable {
         let counterparty: String
         let billingPeriodStartsAt: String?
 
+        init(paymentRequestId: String, counterparty: String, billingPeriodStartsAt: String?) {
+            self.paymentRequestId = paymentRequestId
+            self.counterparty = counterparty
+            self.billingPeriodStartsAt = billingPeriodStartsAt
+        }
+
         init(_ id: PaykitPaymentRequest.ID, billingPeriod: PaykitBillingPeriod?) {
             paymentRequestId = id.paymentRequestId
             counterparty = id.counterparty
@@ -68,6 +75,7 @@ struct PaykitPaymentStateBackup: Codable {
         let paymentStarted: Bool
         let paymentIdentifier: String?
         let proofData: String?
+        let conversionQuoteId: String?
         let billingPeriod: Period?
         let onchainAddress: String?
         let onchainAmountSats: UInt64?
@@ -91,6 +99,7 @@ struct PaykitPaymentStateBackup: Codable {
             paymentStarted = proof.paymentStarted
             paymentIdentifier = proof.paymentIdentifier
             proofData = proof.proofData
+            conversionQuoteId = proof.conversionQuoteId
             billingPeriod = proof.billingPeriod.map { Period(startsAt: $0.sdkValue.startsAt, endsAt: $0.sdkValue.endsAt) }
             onchainAddress = proof.onchainAddress
             onchainAmountSats = proof.onchainAmountSats
@@ -123,6 +132,7 @@ struct PaykitPaymentStateBackup: Codable {
                 paymentStarted: paymentStarted,
                 paymentIdentifier: paymentIdentifier,
                 proofData: proofData,
+                conversionQuoteId: conversionQuoteId,
                 onchainAddress: onchainAddress,
                 onchainAmountSats: onchainAmountSats,
                 onchainWalletId: onchainWalletId,
diff --git a/Bitkit/Models/PaykitRequestPricing.swift b/Bitkit/Models/PaykitRequestPricing.swift
new file mode 100644
index 000000000..908b97a24
--- /dev/null
+++ b/Bitkit/Models/PaykitRequestPricing.swift
@@ -0,0 +1,117 @@
+import Foundation
+import Paykit
+
+/// Immutable request terms. Market rates are only used when creating request terms.
+struct PaykitRequestPricing: Hashable {
+    var conversion: Paykit.PaymentConversion?
+    var deadline: Paykit.PaymentDeadline?
+    var quotes: [Paykit.PaymentConversionQuoteRecord] = []
+
+    struct Payment: Codable, Hashable {
+        let amount: PaykitAmount
+        let quoteId: String?
+        let validFrom: Date?
+        let expiresAt: Date?
+
+        func isValid(at date: Date) -> Bool {
+            (validFrom.map { date >= $0 } ?? true) && (expiresAt.map { date <= $0 } ?? true)
+        }
+    }
+
+    func payment(
+        requested: PaykitAmount,
+        asset: PaykitAsset,
+        period: PaykitBillingPeriod?,
+        at date: Date,
+        quoteId: String? = nil
+    ) throws -> Payment {
+        let deadline = try paymentDeadline(period: period)
+        if requested.asset == asset {
+            guard quoteId == nil else { throw PaykitAmountError.invalidAmount }
+            return Payment(amount: requested, quoteId: nil, validFrom: nil, expiresAt: deadline)
+        }
+        let rates: [Paykit.ConversionRate]
+        var selected: Paykit.PaymentConversionQuoteRecord?
+        switch conversion {
+        case let .fixed(values):
+            guard quoteId == nil else { throw PaykitAmountError.invalidAmount }
+            rates = values
+        case .perPeriod:
+            guard let period else { throw PaykitAmountError.invalidAmount }
+            selected = quotes.last { quote in
+                guard let quotedPeriod = PaykitBillingPeriod(sdkPeriod: quote.billingPeriod), quotedPeriod == period else { return false }
+                if let quoteId { return quote.eventId == quoteId }
+                guard let start = PaykitPaymentRequest.parseDate(quote.validFrom),
+                      let end = PaykitPaymentRequest.parseDate(quote.expiresAt)
+                else { return false }
+                return date >= start && date <= end
+            }
+            guard let selected else { throw PaykitAmountError.rateUnavailable }
+            rates = selected.rates
+        case nil:
+            // External requests without rates can only be paid in their denominating asset.
+            throw PaykitAmountError.rateUnavailable
+        }
+        guard let rate = rates.first(where: { $0.asset == asset.rawValue }) else { throw PaykitAmountError.rateUnavailable }
+        let quoteExpiry = selected.flatMap { PaykitPaymentRequest.parseDate($0.expiresAt) }
+        return try Payment(
+            amount: requested.quoted(to: asset, multiplier: rate.value),
+            quoteId: selected?.eventId,
+            validFrom: selected.flatMap { PaykitPaymentRequest.parseDate($0.validFrom) },
+            expiresAt: [deadline, quoteExpiry].compactMap { $0 }.min()
+        )
+    }
+
+    func precisePaymentDeadline(period: PaykitBillingPeriod?) -> PaykitPreciseInstant? {
+        guard let deadline,
+              let timestamp = try? Paykit.paymentDeadlineAt(deadline: deadline, billingPeriod: period?.sdkValue)
+        else { return nil }
+        return PaykitPreciseInstant(timestamp: timestamp)
+    }
+
+    func paymentDeadline(period: PaykitBillingPeriod?) throws -> Date? {
+        switch deadline {
+        case nil: return nil
+        case let .at(timestamp):
+            guard period == nil, let date = PaykitPaymentRequest.parseDate(timestamp) else { throw PaykitAmountError.invalidAmount }
+            return date
+        case let .periodStart(seconds):
+            guard let period, seconds <= UInt64(Int64.max) else { throw PaykitAmountError.invalidAmount }
+            return period.startsAt.addingTimeInterval(TimeInterval(seconds))
+        }
+    }
+
+    static func subscriptionEndpoints(requested: PaykitAsset, available: [String]) -> [String] {
+        available.filter {
+            guard let method = PublicPaykitService.MethodId(rawValue: $0) else { return false }
+            switch requested {
+            case .btc: return method != .usdtArbitrum
+            case .usd: return method == .usdtArbitrum
+            case .usdt: return false
+            }
+        }
+    }
+
+    static func rates(
+        requested: PaykitAsset,
+        endpoints: [String],
+        market: PaykitExchangeRate?,
+        at date: Date
+    ) throws -> [Paykit.ConversionRate] {
+        let assets = Set(endpoints.compactMap { PublicPaykitService.MethodId(rawValue: $0) }
+            .map { $0 == .usdtArbitrum ? PaykitAsset.usdt : .btc })
+        return try assets.sorted { $0.rawValue < $1.rawValue }.filter { $0 != requested }.map { asset in
+            var value = Decimal(1)
+            if (requested == .btc) != (asset == .btc) {
+                guard let market else { throw PaykitAmountError.rateUnavailable }
+                let price = try market.value(at: date)
+                value = requested == .btc ? price : Decimal(1) / price
+                var rounded = Decimal()
+                NSDecimalRound(&rounded, &value, 18, .bankers)
+                value = rounded
+            }
+            guard !value.isNaN, value > 0 else { throw PaykitAmountError.rateUnavailable }
+            return Paykit.ConversionRate(asset: asset.rawValue, value: NSDecimalNumber(decimal: value).stringValue)
+        }
+    }
+}
diff --git a/Bitkit/Models/PaykitUsdt.swift b/Bitkit/Models/PaykitUsdt.swift
new file mode 100644
index 000000000..55a1542de
--- /dev/null
+++ b/Bitkit/Models/PaykitUsdt.swift
@@ -0,0 +1,31 @@
+import BitkitCore
+import Foundation
+
+enum PaykitUsdt {
+    static let chainId = "42161"
+    static let token = "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9"
+
+    static func address(from payload: String) -> String? {
+        guard let data = payload.data(using: .utf8),
+              let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              object["chain_id"] as? String == chainId,
+              (object["token"] as? String)?.lowercased() == token,
+              let value = object["value"] as? String,
+              value.count == 42,
+              let request = try? usdtParsePaymentRequest(value: value),
+              request.chainId == nil, request.amount == nil
+        else { return nil }
+        return request.recipient
+    }
+
+    static func endpoint(address: String) throws -> PublicPaykitService.Endpoint {
+        let data = try JSONSerialization.data(withJSONObject: ["value": address, "chain_id": chainId, "token": token])
+        let payload = String(decoding: data, as: UTF8.self)
+        guard let address = self.address(from: payload) else { throw PublicPaykitError.invalidPayload }
+        return PublicPaykitService.Endpoint(methodId: .usdtArbitrum, value: address, min: nil, max: nil, rawPayload: payload)
+    }
+
+    static func paymentURI(address: String) -> String {
+        "ethereum:\(token)@\(chainId)/transfer?address=\(address)"
+    }
+}
diff --git a/Bitkit/Models/PaykitUsdtStateBackup.swift b/Bitkit/Models/PaykitUsdtStateBackup.swift
new file mode 100644
index 000000000..4aeef57a2
--- /dev/null
+++ b/Bitkit/Models/PaykitUsdtStateBackup.swift
@@ -0,0 +1,96 @@
+import BitkitCore
+import Foundation
+import Paykit
+
+struct PaykitUsdtStateBackup: Codable {
+    let attempts: [Attempt]
+    let receipts: [Receipt]
+
+    struct Attempt: Codable {
+        let quoteId: String
+        let wallet: String
+        let identity: String
+        let contact: String
+        let requestId: PaykitPaymentStateBackup.RequestID?
+        let binding: UsdtPaymentProofBinding?
+        let billingPeriod: PaykitPaymentStateBackup.Proof.Period?
+        let proof: PaykitUsdtPaymentService.Proof?
+        let proofQueued: Bool
+        let paymentStarted: Bool
+
+        init(_ value: PaykitUsdtPaymentService.Attempt) {
+            quoteId = value.quoteId
+            wallet = value.wallet
+            identity = value.identity
+            contact = value.contact
+            requestId = value.requestId.map { PaykitPaymentStateBackup.RequestID($0, billingPeriod: value.billingPeriod) }
+            binding = value.binding
+            billingPeriod = value.billingPeriod.map {
+                PaykitPaymentStateBackup.Proof.Period(startsAt: $0.sdkValue.startsAt, endsAt: $0.sdkValue.endsAt)
+            }
+            proof = value.proof
+            proofQueued = value.proofQueued
+            paymentStarted = value.paymentStarted
+        }
+
+        func restored() throws -> PaykitUsdtPaymentService.Attempt {
+            let period = try billingPeriod.map {
+                guard let value = PaykitBillingPeriod(sdkPeriod: BillingPeriod(startsAt: $0.startsAt, endsAt: $0.endsAt)) else {
+                    throw PaykitPaymentRequestError.requestUnavailable
+                }
+                return value
+            }
+            return PaykitUsdtPaymentService.Attempt(
+                quoteId: quoteId, wallet: wallet, identity: identity, contact: contact,
+                requestId: requestId?.restored(billingPeriod: period), binding: binding, billingPeriod: period,
+                proof: proof, proofQueued: proofQueued, paymentStarted: paymentStarted
+            )
+        }
+    }
+
+    struct Receipt: Codable {
+        let wallet: String
+        let identity: String
+        let requestId: PaykitPaymentStateBackup.RequestID
+        let paymentId: String
+        let proofEventId: String
+        let verified: Bool
+        let transferId: String
+        let amountAtomic: UInt64
+        let receivedAtMillis: Int64
+        let underpaid: Bool
+        let afterExpiry: Bool
+
+        init(_ value: PaykitUsdtPaymentService.Receipt) {
+            wallet = value.wallet
+            identity = value.identity
+            requestId = PaykitPaymentStateBackup.RequestID(
+                paymentRequestId: value.requestId.paymentRequestId, counterparty: value.requestId.counterparty,
+                billingPeriodStartsAt: value.requestId.billingPeriodStartsAt.map { PaykitPreciseInstant(date: $0).timestamp }
+            )
+            paymentId = value.paymentId
+            proofEventId = value.proofEventId
+            verified = value.verified
+            transferId = value.transferId
+            amountAtomic = value.amount.atomic
+            receivedAtMillis = Int64(value.receivedAt.timeIntervalSince1970 * 1000)
+            underpaid = value.underpaid
+            afterExpiry = value.afterExpiry
+        }
+
+        func restored() throws -> PaykitUsdtPaymentService.Receipt {
+            let periodStart = try requestId.billingPeriodStartsAt.map {
+                guard let instant = PaykitPreciseInstant(timestamp: $0) else { throw PaykitPaymentRequestError.requestUnavailable }
+                return instant.date
+            }
+            return PaykitUsdtPaymentService.Receipt(
+                wallet: wallet, identity: identity,
+                requestId: .init(paymentRequestId: requestId.paymentRequestId, counterparty: requestId.counterparty,
+                                 billingPeriodStartsAt: periodStart),
+                paymentId: paymentId, proofEventId: proofEventId, verified: verified, transferId: transferId,
+                amount: PaykitAmount(asset: .usdt, atomic: amountAtomic),
+                receivedAt: Date(timeIntervalSince1970: Double(receivedAtMillis) / 1000), underpaid: underpaid, afterExpiry: afterExpiry
+            )
+        }
+    }
+}
diff --git a/Bitkit/Models/PubkyAuthRequest.swift b/Bitkit/Models/PubkyAuthRequest.swift
index fd480d169..7ea45e683 100644
--- a/Bitkit/Models/PubkyAuthRequest.swift
+++ b/Bitkit/Models/PubkyAuthRequest.swift
@@ -6,10 +6,14 @@ struct PubkyAuthClaim: Equatable {
     private enum Item: String {
         case paykitAccessV1 = "paykit-access-v1"
         case watchOnlyAccountV1 = "watch-only-account-v1"
+        case usdtAddressV1 = "usdt-address-v1"
+        case paymentDetailsV1 = "payment-details-v1"
     }
 
     static let watchOnlyAccountV1 = Self(items: [.watchOnlyAccountV1])
     static let paykitAccessV1 = Self(items: [.paykitAccessV1])
+    static let usdtAddressV1 = Self(items: [.usdtAddressV1])
+    static let paymentDetailsV1 = Self(items: [.paymentDetailsV1])
 
     private let items: [Item]
 
@@ -21,6 +25,7 @@ struct PubkyAuthClaim: Equatable {
         let values = rawValue.split(separator: ".", omittingEmptySubsequences: false)
         let items = values.compactMap { Item(rawValue: String($0)) }
         guard !items.isEmpty, items.count == values.count, Set(items).count == items.count else { return nil }
+        guard items.count == 1 || !items.contains(where: { $0 == .usdtAddressV1 || $0 == .paymentDetailsV1 }) else { return nil }
         self.items = items
     }
 
@@ -33,14 +38,49 @@ struct PubkyAuthClaim: Equatable {
     static let requiredCapabilities = Paykit.requiredSessionCapabilities()
 
     var includesWatchOnlyAccount: Bool {
-        items.contains(.watchOnlyAccountV1)
+        items.contains(.watchOnlyAccountV1) || items.contains(.paymentDetailsV1)
     }
 
     var includesPaykitAccess: Bool {
         items.contains(.paykitAccessV1)
     }
 
+    var sharesBitcoin: Bool {
+        includesWatchOnlyAccount
+    }
+
+    var sharesUsdt: Bool {
+        items.contains(.usdtAddressV1) || items.contains(.paymentDetailsV1)
+    }
+
+    var sharesReceivingDetails: Bool {
+        sharesBitcoin || sharesUsdt
+    }
+
+    func unsignedPayload(account: WatchOnlyAccountRecord?, usdtEndpoint: PublicPaykitService.Endpoint?) throws -> Data? {
+        guard sharesUsdt else {
+            return try account.map { try WatchOnlyAccountClaimCodec.encode(record: $0) }
+        }
+        guard let usdtEndpoint, usdtEndpoint.methodId == .usdtArbitrum,
+              PaykitUsdt.address(from: usdtEndpoint.rawPayload) == usdtEndpoint.value
+        else { throw PubkyAuthRequestError.invalidPaymentDetails }
+        var payload: [String: Any] = try [
+            PublicPaykitService.MethodId.usdtArbitrum.rawValue:
+                JSONSerialization.jsonObject(with: Data(usdtEndpoint.rawPayload.utf8)),
+        ]
+        if sharesBitcoin {
+            guard let account else { throw PubkyAuthRequestError.invalidPaymentDetails }
+            _ = try WatchOnlyAccountClaimCodec.encode(record: account)
+            payload["bitcoin_account"] = ["account_index": account.accountIndex, "address_type": account.addressType, "xpub": account.xpub]
+        }
+        return try JSONSerialization.data(withJSONObject: payload, options: [.sortedKeys])
+    }
+
     func encode(accountPayload: Data?, paykitKey: PaykitIdentitySecretKey?) throws -> Data {
+        if sharesUsdt {
+            guard let accountPayload, !includesPaykitAccess else { throw PubkyAuthRequestError.invalidPaymentDetails }
+            return accountPayload
+        }
         guard includesWatchOnlyAccount == (accountPayload != nil),
               includesPaykitAccess == (paykitKey != nil)
         else {
@@ -68,6 +108,7 @@ struct PubkyAuthClaim: Equatable {
 
 enum PubkyAuthRequestError: Error, Equatable {
     case invalidUrl
+    case invalidPaymentDetails
     case missingBitkitClaim
     case duplicateBitkitClaim
     case duplicateRelay
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index c273e1dc6..1a4d3cdde 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1806,3 +1806,117 @@
 "wallet__onchain_retry_invalid_fee" = "Enter a whole-number fee rate from 1 to 4,294,967,295 sat/vB.";
 
 "wallet__onchain_retry_max_note" = "Retry {amount} sats to {address} using the same original coins and original fee rate of {fee} sat/vB. Send-all leaves no coins for a higher fee without reducing the recipient amount. The amount stays unchanged. This cannot create a separate payment.";
+// USDT
+"usdt__activity" = "Activity";
+"usdt__address" = "Recipient address";
+"usdt__amount" = "Amount (USDT)";
+"usdt__bridge_attention" = "Bridge needs attention";
+"usdt__bridging" = "Delivering to destination";
+"usdt__confirmed" = "Confirmed";
+"usdt__destination" = "Recipient network";
+"usdt__empty" = "No activity found yet.";
+"usdt__error_address" = "Enter a valid address for the selected network.";
+"usdt__error_amount" = "Enter a valid amount with up to 6 decimal places.";
+"usdt__error_backup" = "Unable to back up this payment. It will be retried when backup is available.";
+"usdt__error_balance" = "Not enough USDT to cover the amount and fees.";
+"usdt__error_clock" = "Set your device date and time automatically, then try again.";
+"usdt__error_configuration" = "USDT is currently unavailable. Please try again later.";
+"usdt__error_delegation" = "This address uses another wallet’s smart account. Disable its smart account mode there before sending with Bitkit.";
+"usdt__error_expired" = "The fee quote expired. Review the payment again.";
+"usdt__error_network" = "Could not update USDT. Check your connection and try again.";
+"usdt__error_pending" = "A payment is still pending. Wait for confirmation before sending again.";
+"usdt__error_rate_limit" = "Too many requests. Please try again shortly.";
+"usdt__error_rejected" = "The USDT network rejected the request. Please try again.";
+"usdt__error_response" = "The USDT service returned an invalid response. Please try again later.";
+"usdt__error_storage" = "Could not access USDT wallet data. Please try again.";
+"usdt__error_wallet" = "Could not access your USDT wallet. Reopen Bitkit and try again.";
+"usdt__error_route" = "This network is currently unavailable.";
+"usdt__expected_amount" = "Expected amount";
+"usdt__failed" = "Failed";
+"usdt__fee_note" = "All fees are paid in USDT. The final network fee may be lower than this maximum.";
+"usdt__history_sync" = "Older activity is still syncing. Your balance is up to date when the connection is available.";
+"usdt__maximum_fee" = "Maximum fee";
+"usdt__network_warning" = "Select the network used by the recipient. Sending to an address on the wrong network can lose funds.";
+"usdt__pending" = "Pending";
+"usdt__receive" = "Receive";
+"usdt__receive_warning" = "Receive USDT on Arbitrum One only. Bridge funds from other networks before sending.";
+"usdt__received" = "Received";
+"usdt__recipient_gets" = "Recipient gets";
+"usdt__send" = "Send";
+"usdt__sent" = "Sent";
+"usdt__submitted" = "Payment submitted";
+"usdt__submitted_description" = "Your payment is being processed. You can track its status in Activity.";
+"usdt__track_bridge" = "Track cross-network delivery";
+"usdt__replaced" = "Replaced by another payment";
+
+"usdt__balance" = "Balance";
+"usdt__receive_title" = "Receive USDT";
+"usdt__send_title" = "Send USDT";
+
+"usdt__deposit_amount" = "Deposit amount";
+"usdt__deposit_attention" = "This deposit needs provider assistance. Contact Bitkit support with the deposit reference.";
+"usdt__deposit_cost" = "Estimated deduction (USDT)";
+"usdt__deposit_create" = "Get Deposit Address";
+"usdt__deposit_empty" = "No deposits yet.";
+"usdt__deposit_estimate" = "Estimated received (USDT)";
+"usdt__deposit_estimate_note" = "Indicative price only. Costs are deducted from the USDT received and may change before conversion. The sender pays their network gas separately.";
+"usdt__deposit_fee_note" = "Fees are deducted from your deposit.";
+"usdt__deposit_history" = "Cross-network Deposits";
+"usdt__deposit_limits" = "Deposit limits";
+"usdt__deposit_limits_note" = "Live liquidity and network costs can further restrict these limits. Amounts outside the limits may be held.";
+"usdt__deposit_more" = "Load more";
+"usdt__deposit_needs_attention" = "Needs attention";
+"usdt__deposit_notice" = "Send only USDT on the selected network. Orchestra delivers USDT0 to your Arbitrum One wallet. This address is reusable; pricing is set when each deposit is processed. Deposits may be held for review.";
+"usdt__deposit_reference" = "Deposit reference";
+"usdt__deposit_refresh" = "Refresh";
+"usdt__deposit_refund" = "Request Refund";
+"usdt__deposit_refunded" = "Refunded";
+"usdt__deposit_status_note" = "Provider status is shown here. Your spendable balance updates only when USDT arrives on Arbitrum.";
+"usdt__deposit_unavailable" = "Cross-network receiving is currently unavailable. Direct Arbitrum receive still works.";
+"usdt__deposit_wrong_asset" = "Unsupported deposit asset — contact support";
+
+"usdt__payment_sent" = "USDT Sent";
+
+"usdt__payment_received" = "Received USDT";
+
+"usdt__bridge_submitted_description" = "Your payment is pending. You can track confirmation and cross-network delivery in Activity.";
+
+"usdt__send_failed_description" = "Your payment was not completed. Check Activity for details.";
+
+"usdt__deposit_authorization" = "The deposit service could not verify this request. Try again.";
+"usdt__deposit_amount_out_of_range" = "Amount outside deposit limits.";
+"usdt__deposit_not_found" = "Deposit details changed. Refresh the deposit history and select it again.";
+
+"wallet__payment_request_accepted_methods" = "Accept payment with";
+"wallet__payment_request_rate_unavailable" = "Payment rates are unavailable or expired. Try again when online.";
+
+"wallet__payment_request_payment_verified" = "Payment verified";
+"wallet__payment_request_review_received" = "Received · Review needed";
+
+"wallet__payment_request_underpaid" = "Received · Underpaid";
+"wallet__payment_request_after_expiry" = "Received · After expiry";
+
+"pubky_auth__bitcoin_account" = "Separate watch-only account · xpub";
+"pubky_auth__payment_details" = "PAYMENT DETAILS TO SHARE";
+"pubky_auth__payment_details_intro_title" = "<accent>EARN BITCOIN\nAND USDT</accent>\nFROM YOUR CONTENT";
+"pubky_auth__payment_details_intro_description" = "Share a separate Bitcoin account and your existing USDT address to receive earnings. Sharing these details does not let the service spend your funds.";
+"pubky_auth__usdt_intro_title" = "<accent>EARN USDT</accent>\nFROM YOUR\nCONTENT";
+"pubky_auth__usdt_intro_description" = "Share your existing USDT address on Arbitrum One to receive earnings directly in Bitkit. The service cannot spend your funds.";
+"pubky_auth__usdt_privacy" = "This is your existing USDT account. The service can see its balance and transaction history, but cannot spend your funds.";
+"pubky_auth__usdt_unavailable" = "Your USDT address is unavailable. Try again before authorizing.";
+"pubky_auth__shared_usdt" = "Your USDT receiving address was shared.";
+"pubky_auth__shared_bitcoin" = "Your Bitcoin watch-only account was shared.";
+"pubky_auth__shared_both" = "Your Bitcoin watch-only account and USDT receiving address were shared.";
+"usdt__deposit_batch" = "Converted batch";
+"usdt__deposit_refund_address" = "Refund address on the source network";
+"usdt__deposit_refund_note" = "Confirm a refund address with the sender. Do not assume an exchange deposit can be returned to its sending address. Refund fees may apply. TRON refunds can require Orchestra operator assistance.";
+"usdt__deposit_refund_requested" = "Refund requested. This is not a confirmed refund; check the deposit status.";
+"usdt__deposit_refunding" = "Refund in progress";
+
+"usdt__bridge_provider" = "Bridge";
+"usdt__bridge_deducted_fee" = "Estimated bridge cost (included)";
+"usdt__maximum_total" = "Maximum total debit";
+"usdt__bridge_estimate_note" = "Delivery is estimated. Bridge costs are deducted from the amount; the network fee is additional.";
+"usdt__bridge_refunded_description" = "USDT was returned to your wallet. See details for the refunded amount.";
+"usdt__destination_tx" = "Destination transaction";
+"usdt__refund_tx" = "Refund transaction";
diff --git a/Bitkit/Services/BackupService.swift b/Bitkit/Services/BackupService.swift
index 3998eba25..975a9aa8d 100644
--- a/Bitkit/Services/BackupService.swift
+++ b/Bitkit/Services/BackupService.swift
@@ -94,6 +94,8 @@ class BackupService {
 
     private let vssBackupClient = VssBackupClient.shared
     private let walletRestoreGate = WalletBackupRestoreGate.keychain
+    private let walletBackupWriter = WalletBackupWriter()
+    @MainActor weak var usdtWallet: UsdtWalletManager?
     private var backupJobs: [BackupCategory: Task<Void, Never>] = [:]
     private var runningBackupTasks: [BackupCategory: Task<Void, Never>] = [:]
     private var cancellables = Set<AnyCancellable>()
@@ -204,6 +206,7 @@ class BackupService {
             return true
         }
 
+        await walletBackupWriter.waitUntilIdle()
         guard shouldStop == true else { return }
         cancellables.removeAll()
         Logger.debug("Stopped observing backup statuses and data store changes", context: "BackupService")
@@ -227,12 +230,12 @@ class BackupService {
             }
 
             do {
-                let data = if let backupData {
-                    try await backupData(category)
+                if category == .wallet {
+                    try await persistWalletBackup()
                 } else {
-                    try await getBackupDataBytes(category: category)
+                    let data = try await getBackupDataBytes(category: category)
+                    try await uploadBackup(category.rawValue, data)
                 }
-                try await uploadBackup(category.rawValue, data)
 
                 updateBackupStatus(category: category) { status in
                     BackupItemStatus(
@@ -273,6 +276,19 @@ class BackupService {
         }
     }
 
+    func persistWalletBackup(usdt: String? = nil) async throws {
+        do {
+            try await walletBackupWriter.write {
+                guard !self.shouldSkipBackup() else { throw UsdtError.BackupUnavailable }
+                let data = try await self.getBackupDataBytes(category: .wallet, usdt: usdt)
+                try await self.uploadBackup(BackupCategory.wallet.rawValue, data)
+            }
+        } catch {
+            markBackupRequired(category: .wallet)
+            throw error
+        }
+    }
+
     func hasPendingWalletRestore() -> Bool {
         do {
             return try walletRestoreGate.hasPendingRestore()
@@ -335,6 +351,10 @@ class BackupService {
             try await performRestore(category: .wallet, retainedData: retainedWalletBackup) { dataBytes in
                 try walletRestoreGate.retain(dataBytes)
                 let payload = try JSONDecoder().decode(WalletBackupV1.self, from: dataBytes)
+                if let usdt = payload.usdtWallet {
+                    guard let wallet = await self.usdtWallet else { throw UsdtError.InvalidBackup }
+                    try await wallet.restoreBackup(usdt)
+                }
                 if let paymentState = payload.paykitPaymentState {
                     // VssBackupClient's existing custom backup namespace is explicitly wallet index 0.
                     let backupWallet = try await PaykitPaymentStateBackup.ActiveOnchainAttempt.Wallet.backupNamespace(index: 0)
@@ -856,7 +876,8 @@ class BackupService {
         }
     }
 
-    private func getBackupDataBytes(category: BackupCategory) async throws -> Data {
+    private func getBackupDataBytes(category: BackupCategory, usdt: String? = nil) async throws -> Data {
+        if let backupData { return try await backupData(category) }
         switch category {
         case .settings:
             let settingsDict = await SettingsViewModel.shared.getSettingsDictionary()
@@ -891,6 +912,15 @@ class BackupService {
             let privatePaykitHighestReservedReceiveIndexByAddressType = await PrivatePaykitAddressReservationStore.shared.backupSnapshot()
             let paykitSdkBackupState = try await PrivatePaykitService.shared.backupSnapshot()
             let watchOnlyAccountSnapshot = try WatchOnlyAccountStore.backupSnapshot()
+            let usdtSnapshot: String?
+            if let usdt {
+                usdtSnapshot = usdt
+            } else if let wallet = await usdtWallet {
+                usdtSnapshot = try await wallet.backupSnapshot()
+            } else {
+                guard !Env.isUsdtEnabled else { throw UsdtError.BackupUnavailable }
+                usdtSnapshot = nil
+            }
             let payload = try await WalletBackupV1(
                 version: 1,
                 createdAt: UInt64(Date().timeIntervalSince1970 * 1000),
@@ -1043,3 +1073,22 @@ class BackupService {
         }
     }
 }
+
+actor WalletBackupWriter {
+    private var previous: Task<Void, Error>?
+
+    func waitUntilIdle() async {
+        _ = try? await previous?.value
+    }
+
+    func write(_ operation: @escaping @Sendable () async throws -> Void) async throws {
+        let preceding = previous
+        let task = Task {
+            _ = try? await preceding?.value
+            try Task.checkCancellation()
+            try await operation()
+        }
+        previous = task
+        try await task.value
+    }
+}
diff --git a/Bitkit/Services/ContactPaymentsService.swift b/Bitkit/Services/ContactPaymentsService.swift
index cbf872653..26f20f2d6 100644
--- a/Bitkit/Services/ContactPaymentsService.swift
+++ b/Bitkit/Services/ContactPaymentsService.swift
@@ -67,6 +67,7 @@ enum ContactPaymentsService {
     static func enableAllPaymentOptions(defaults: UserDefaults = .standard) {
         defaults.set(true, forKey: PublicPaykitService.lightningPaymentOptionEnabledKey)
         defaults.set(true, forKey: PublicPaykitService.onchainPaymentOptionEnabledKey)
+        defaults.set(true, forKey: PublicPaykitService.usdtPaymentOptionEnabledKey)
     }
 
     /// Applies the latest sharing preference for the current session. Enabling waits for saved contacts;
diff --git a/Bitkit/Services/PaykitIssuerInterop.swift b/Bitkit/Services/PaykitIssuerInterop.swift
index e6f2bbc49..0fc09ca22 100644
--- a/Bitkit/Services/PaykitIssuerInterop.swift
+++ b/Bitkit/Services/PaykitIssuerInterop.swift
@@ -21,7 +21,7 @@ enum PaykitIssuerInterop {
                 return onchainNetwork == network
             }
 
-            return methodId == .bitcoinLightningBolt11 || methodId == .bitcoinLightningLnurl
+            return methodId == .bitcoinLightningBolt11 || methodId == .bitcoinLightningLnurl || methodId == .usdtArbitrum
         }
     }
 
diff --git a/Bitkit/Services/PaykitPaymentProofService.swift b/Bitkit/Services/PaykitPaymentProofService.swift
index e416ccd36..fac915aa1 100644
--- a/Bitkit/Services/PaykitPaymentProofService.swift
+++ b/Bitkit/Services/PaykitPaymentProofService.swift
@@ -8,10 +8,11 @@ import Paykit
 enum PaykitPaymentProofKind: String, Codable {
     case lightning = "bitcoin-bolt11-preimage"
     case onchain = "bitcoin-onchain-txid"
+    case usdt = "erc20-transfer-eip712"
 
     init?(paymentEndpointIdentifier: String) {
         guard let method = PublicPaykitService.MethodId(rawValue: paymentEndpointIdentifier) else { return nil }
-        self = method.onchainNetwork == nil ? .lightning : .onchain
+        self = method == .usdtArbitrum ? .usdt : method.onchainNetwork == nil ? .lightning : .onchain
     }
 }
 
@@ -53,6 +54,7 @@ struct PendingPaykitPaymentProof: Codable, Equatable {
     var paymentStarted: Bool
     var paymentIdentifier: String?
     var proofData: String?
+    var conversionQuoteId: String?
     var onchainAddress: String?
     var onchainAmountSats: UInt64?
     var onchainWalletId: String?
@@ -103,6 +105,7 @@ struct PendingPaykitPaymentProof: Codable, Equatable {
         paymentStarted: Bool = false,
         paymentIdentifier: String?,
         proofData: String?,
+        conversionQuoteId: String? = nil,
         onchainAddress: String? = nil,
         onchainAmountSats: UInt64? = nil,
         onchainWalletId: String? = nil,
@@ -119,6 +122,7 @@ struct PendingPaykitPaymentProof: Codable, Equatable {
         self.paymentStarted = paymentStarted
         self.paymentIdentifier = paymentIdentifier
         self.proofData = proofData
+        self.conversionQuoteId = conversionQuoteId
         self.onchainAddress = onchainAddress
         self.onchainAmountSats = onchainAmountSats
         self.onchainWalletId = onchainWalletId
@@ -1459,6 +1463,7 @@ actor PaykitPaymentProofService {
             let isAlreadyQueued = request.paymentProofs.contains(where: {
                 Self.billingPeriod($0.billingPeriod, matches: pendingProof.billingPeriod) &&
                     $0.paymentAppId == pendingProof.paymentAppId &&
+                    $0.conversionQuoteId == pendingProof.conversionQuoteId &&
                     $0.paymentEndpointIdentifier == pendingProof.paymentEndpointIdentifier &&
                     Self.proofValues($0.proof.exportText()) == Self.proofValues(proofText)
             })
@@ -1472,7 +1477,7 @@ actor PaykitPaymentProofService {
                         paymentAppId: pendingProof.paymentAppId,
                         paymentEndpointIdentifier: pendingProof.paymentEndpointIdentifier,
                         allowanceId: nil,
-                        conversionQuoteId: nil,
+                        conversionQuoteId: pendingProof.conversionQuoteId,
                         proof: Paykit.PrivateJsonObject(text: proofText)
                     )
                 )
@@ -1483,7 +1488,7 @@ actor PaykitPaymentProofService {
                     logWarning("Paykit payment proof remains queued for private delivery: \(error)")
                 }
             }
-            await removeRequestProofs(pendingProof)
+            if pendingProof.kind != .usdt { await removeRequestProofs(pendingProof) }
             return true
         } catch {
             logWarning("Failed to queue a Paykit payment proof: \(error)")
@@ -1593,6 +1598,8 @@ actor PaykitPaymentProofService {
             return methodId == .bitcoinLightningBolt11 || methodId == .bitcoinLightningLnurl
         case .onchain:
             return methodId.onchainNetwork != nil
+        case .usdt:
+            return methodId == .usdtArbitrum
         }
     }
 
@@ -1620,8 +1627,10 @@ actor PaykitPaymentProofService {
     }
 
     private static func proofText(kind: PaykitPaymentProofKind, data: String) throws -> String {
+        if kind == .usdt { return data }
+        let values = ["data": data, "type": kind.rawValue]
         let encoded = try JSONSerialization.data(
-            withJSONObject: ["data": data, "type": kind.rawValue],
+            withJSONObject: values,
             options: [.sortedKeys]
         )
         return String(decoding: encoded, as: UTF8.self)
diff --git a/Bitkit/Services/PaykitPaymentRequestService.swift b/Bitkit/Services/PaykitPaymentRequestService.swift
index 2658ddfb6..99ba2a1fc 100644
--- a/Bitkit/Services/PaykitPaymentRequestService.swift
+++ b/Bitkit/Services/PaykitPaymentRequestService.swift
@@ -57,8 +57,13 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
     let paymentRequestId: String
     let counterparty: String
     let proposalStreamItemId: UInt64?
-    let amountValue: String
-    let amountSats: UInt64
+    let amount: PaykitAmount
+    let paymentReference: String
+    let pricing: PaykitRequestPricing
+    var amountValue: String {
+        amount.value
+    }
+
     let note: String?
     let createdAt: Date?
     let expiresAt: Date?
@@ -69,6 +74,7 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
     let lifecycleState: Paykit.PaymentRequestLifecycleState
     let billingPeriod: PaykitBillingPeriod?
     let paymentProofKind: PaykitPaymentProofKind?
+    let paymentProofEventId: String?
 
     var requiresAcceptance: Bool {
         billingPeriod == nil && lifecycleState == .proposed
@@ -191,8 +197,9 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
             paymentRequestId: record.paymentRequestId,
             counterparty: record.counterparty,
             proposalStreamItemId: record.proposalStreamItemId,
-            amountValue: terms.amount.value,
-            amountSats: amountSats,
+            amount: amount,
+            paymentReference: terms.paymentReference.exportText(),
+            pricing: PaykitRequestPricing(conversion: terms.conversion, deadline: terms.paymentDeadline, quotes: record.conversionQuotes),
             note: Self.note(from: terms.metadata),
             createdAt: record.lastEventAt.flatMap(Self.parseDate),
             expiresAt: expiresAt,
@@ -204,7 +211,8 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
             billingPeriod: nil,
             paymentProofKind: record.paymentProofs.last.flatMap {
                 PaykitPaymentProofKind(paymentEndpointIdentifier: $0.paymentEndpointIdentifier)
-            }
+            },
+            paymentProofEventId: record.paymentProofs.last?.eventId
         ))
     }
 
@@ -236,19 +244,21 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         paymentRequestId = createdRecord.paymentRequestId
         counterparty = target.publicKey
         proposalStreamItemId = createdRecord.proposalStreamItemId
-        amountValue = WalletViewModel.formatBitcoinAmount(sats: draft.amountSats)
-        amountSats = draft.amountSats
+        amount = draft.amount
+        paymentReference = createdRecord.terms?.paymentReference.exportText() ?? ""
+        pricing = PaykitRequestPricing(conversion: createdRecord.terms?.conversion, deadline: createdRecord.terms?.paymentDeadline)
         let trimmedNote = draft.note.trimmingCharacters(in: .whitespacesAndNewlines)
         note = trimmedNote.isEmpty ? nil : trimmedNote
         createdAt = createdRecord.lastEventAt.flatMap(Self.parseDate) ?? fallbackCreatedAt
         expiresAt = draft.expiresAt
-        paymentDeadline = nil
+        paymentDeadline = pricing.precisePaymentDeadline(period: nil)
         self.acceptedPaymentEndpointIdentifiers = acceptedPaymentEndpointIdentifiers
         self.deliveryStatus = deliveryStatus
         direction = .outgoing
         lifecycleState = .proposed
         billingPeriod = nil
         paymentProofKind = nil
+        paymentProofEventId = nil
     }
 
     func updatingLifecycleState(
@@ -259,8 +269,9 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
             paymentRequestId: paymentRequestId,
             counterparty: counterparty,
             proposalStreamItemId: proposalStreamItemId,
-            amountValue: amountValue,
-            amountSats: amountSats,
+            amount: amount,
+            paymentReference: paymentReference,
+            pricing: pricing,
             note: note,
             createdAt: createdAt,
             expiresAt: expiresAt,
@@ -270,7 +281,8 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
             direction: direction,
             lifecycleState: state,
             billingPeriod: billingPeriod,
-            paymentProofKind: paymentProofKind ?? self.paymentProofKind
+            paymentProofKind: paymentProofKind ?? self.paymentProofKind,
+            paymentProofEventId: paymentProofEventId
         )
     }
 
@@ -284,26 +296,29 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         paymentRequestId = subscription.paymentRequestId
         counterparty = subscription.counterparty
         proposalStreamItemId = subscription.proposalStreamItemId
-        amountValue = subscription.amountValue
-        amountSats = subscription.amountSats
+        amount = subscription.amount
+        paymentReference = subscription.paymentReference
+        pricing = subscription.pricing
         note = subscription.note
         createdAt = billingPeriod.startsAt
         expiresAt = nil
-        paymentDeadline = nil
+        paymentDeadline = pricing.precisePaymentDeadline(period: billingPeriod)
         acceptedPaymentEndpointIdentifiers = subscription.acceptedPaymentEndpointIdentifiers
         deliveryStatus = nil
         self.direction = direction
         self.lifecycleState = lifecycleState
         self.billingPeriod = billingPeriod
         self.paymentProofKind = paymentProofKind
+        paymentProofEventId = subscription.payments.last { $0.billingPeriod == billingPeriod }?.proofEventId
     }
 
     private init(
         paymentRequestId: String,
         counterparty: String,
         proposalStreamItemId: UInt64?,
-        amountValue: String,
-        amountSats: UInt64,
+        amount: PaykitAmount,
+        paymentReference: String,
+        pricing: PaykitRequestPricing,
         note: String?,
         createdAt: Date?,
         expiresAt: Date?,
@@ -313,13 +328,15 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         direction: Direction,
         lifecycleState: Paykit.PaymentRequestLifecycleState,
         billingPeriod: PaykitBillingPeriod?,
-        paymentProofKind: PaykitPaymentProofKind?
+        paymentProofKind: PaykitPaymentProofKind?,
+        paymentProofEventId: String?
     ) {
         self.paymentRequestId = paymentRequestId
         self.counterparty = counterparty
         self.proposalStreamItemId = proposalStreamItemId
-        self.amountValue = amountValue
-        self.amountSats = amountSats
+        self.amount = amount
+        self.paymentReference = paymentReference
+        self.pricing = pricing
         self.note = note
         self.createdAt = createdAt
         self.expiresAt = expiresAt
@@ -330,6 +347,7 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         self.lifecycleState = lifecycleState
         self.billingPeriod = billingPeriod
         self.paymentProofKind = paymentProofKind
+        self.paymentProofEventId = paymentProofEventId
     }
 
     func isExpired(at date: Date) -> Bool {
@@ -346,18 +364,33 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         }
     }
 
-    func acceptsLightningInvoiceAmount(milliSatoshis: UInt64?) -> Bool {
+    func payment(to asset: PaykitAsset, at date: Date = Date(), quoteId: String? = nil) throws -> PaykitRequestPricing.Payment {
+        try pricing.payment(requested: amount, asset: asset, period: billingPeriod, at: date, quoteId: quoteId)
+    }
+
+    func acceptsLightningInvoiceAmount(milliSatoshis: UInt64?, paymentTerms: PaykitRequestPricing.Payment? = nil, at date: Date = Date()) -> Bool {
         guard let milliSatoshis else { return true }
-        let (requestedMilliSatoshis, overflow) = amountSats.multipliedReportingOverflow(by: 1000)
-        return !overflow && milliSatoshis == requestedMilliSatoshis
+        guard let payment = try? payment(to: .btc, at: date, quoteId: paymentTerms?.quoteId),
+              paymentTerms == nil || paymentTerms == payment, payment.isValid(at: date) else { return false }
+        let (required, overflow) = payment.amount.atomic.multipliedReportingOverflow(by: 1000)
+        return !overflow && milliSatoshis == required
     }
 
     func acceptsLightningInvoiceAmount(satoshis: UInt64) -> Bool {
-        satoshis == 0 || satoshis == amountSats
+        satoshis == 0 || acceptsPaymentAmount(satoshis)
     }
 
-    func acceptsPaymentAmount(_ amountSats: UInt64) -> Bool {
-        amountSats == self.amountSats
+    func acceptsPaymentAmount(_ amountSats: UInt64, paymentTerms: PaykitRequestPricing.Payment? = nil, at date: Date = Date()) -> Bool {
+        guard let payment = try? payment(to: .btc, at: date, quoteId: paymentTerms?.quoteId),
+              paymentTerms == nil || paymentTerms == payment, payment.isValid(at: date) else { return false }
+        return payment.amount.atomic == amountSats
+    }
+
+    func acceptsPayment(_ amount: PaykitAmount, paymentTerms: PaykitRequestPricing.Payment?, at date: Date = Date()) -> Bool {
+        guard let paymentTerms, paymentTerms.amount == amount, paymentTerms.isValid(at: date),
+              let current = try? payment(to: amount.asset, at: date, quoteId: paymentTerms.quoteId)
+        else { return false }
+        return current == paymentTerms
     }
 
     func belongs(to subscription: PaykitSubscription) -> Bool {
@@ -432,13 +465,21 @@ struct PaykitPaymentRequestTargetDiscovery: Equatable {
 }
 
 struct PaykitPaymentRequestDraft: Hashable {
-    let amountSats: UInt64
+    let amount: PaykitAmount
+    var acceptedPaymentEndpointIdentifiers: [String]?
     let note: String
     let expiresAt: Date
+
+    init(amount: PaykitAmount, acceptedPaymentEndpointIdentifiers: [String]? = nil, note: String, expiresAt: Date) {
+        self.amount = amount
+        self.acceptedPaymentEndpointIdentifiers = acceptedPaymentEndpointIdentifiers
+        self.note = note
+        self.expiresAt = expiresAt
+    }
 }
 
 struct PaykitSubscriptionDraft: Hashable {
-    var amountSats: UInt64
+    var amount: PaykitAmount
     var name: String
     var description: String
     var frequency: PaykitSubscriptionRecurrence.Unit
@@ -446,14 +487,8 @@ struct PaykitSubscriptionDraft: Hashable {
     var iconData: Data?
 
     static var empty: PaykitSubscriptionDraft {
-        PaykitSubscriptionDraft(
-            amountSats: 0,
-            name: "",
-            description: "",
-            frequency: .month,
-            expiresAt: Date().addingTimeInterval(7 * 24 * 60 * 60),
-            iconData: nil
-        )
+        PaykitSubscriptionDraft(amount: PaykitAmount(asset: .btc, atomic: 0), name: "", description: "", frequency: .month,
+                                expiresAt: Date().addingTimeInterval(7 * 24 * 60 * 60), iconData: nil)
     }
 }
 
@@ -591,6 +626,8 @@ struct PaykitPaymentRequestService {
     private let now: @Sendable () -> Date
     private let subscriptionNow: @Sendable () -> Date
     private let isPrivatePaymentPublishingEnabled: @Sendable () -> Bool
+    private let canReceiveLightning: @MainActor @Sendable () -> Bool
+    private let marketRate: @MainActor @Sendable () -> PaykitExchangeRate?
     private let logWarning: @Sendable (String) -> Void
     private let incomingRejectionLog = IncomingPaykitPaymentRequestRejectionLog()
 
@@ -601,11 +638,21 @@ struct PaykitPaymentRequestService {
         isPrivatePaymentPublishingEnabled: @escaping @Sendable () -> Bool = {
             UserDefaults.standard.bool(forKey: PrivatePaykitService.publishingEnabledKey)
         },
+        canReceiveLightning: @escaping @MainActor @Sendable () -> Bool = {
+            LightningService.shared.channels?.contains(where: \.isUsable) ?? false
+        },
+        marketRate: @escaping @MainActor @Sendable ()
+            -> PaykitExchangeRate? = { CurrencyService.shared.loadCachedRates()?.first { $0.quote == "USD" }.map { PaykitExchangeRate(
+                price: $0.lastPrice,
+                timestamp: $0.timestamp
+            ) } },
         logWarning: @escaping @Sendable (String) -> Void = {
             Logger.warn($0, context: "PaykitPaymentRequest")
         }
     ) {
         self.sdk = sdk
+        self.canReceiveLightning = canReceiveLightning
+        self.marketRate = marketRate
         self.now = now
         self.subscriptionNow = subscriptionNow ?? { SubscriptionClock.subscriptionDate(from: now()) }
         self.isPrivatePaymentPublishingEnabled = isPrivatePaymentPublishingEnabled
@@ -692,7 +739,8 @@ struct PaykitPaymentRequestService {
         priority: PaykitPublicReadPriority = .interactive
     ) async throws -> PaykitPaymentRequestTargetDiscovery {
         let unavailable = PaykitPaymentRequestTargetDiscovery(targets: [], isComplete: true, capabilityCheckedPublicKeys: [])
-        guard isPrivatePaymentPublishingEnabled(), !Self.acceptedPaymentEndpointIdentifiers().isEmpty else { return unavailable }
+        guard isPrivatePaymentPublishingEnabled(),
+              await !Self.acceptedPaymentEndpointIdentifiers(canReceiveLightning: canReceiveLightning()).isEmpty else { return unavailable }
         let sdkPriority: PaykitSdkOperationLock.Priority = priority == .bulk ? .background : .interactive
         guard let identityStatus = try await sdk.identityStatus(priority: sdkPriority),
               identityStatus.capability == .privateLinkCapable,
@@ -766,9 +814,12 @@ struct PaykitPaymentRequestService {
         savedPublicKeys: [String],
         expectedIdentity: String
     ) async throws -> PaykitPaymentRequest {
-        let acceptedPaymentEndpointIdentifiers = Self.acceptedPaymentEndpointIdentifiers()
+        let enabled = await Self.acceptedPaymentEndpointIdentifiers(canReceiveLightning: canReceiveLightning())
+        let acceptedPaymentEndpointIdentifiers = draft.acceptedPaymentEndpointIdentifiers.map { selected in
+            enabled.filter { selected.contains($0) }
+        } ?? enabled
         let proposalDate = now()
-        guard draft.amountSats > 0, !acceptedPaymentEndpointIdentifiers.isEmpty else {
+        guard draft.amount.atomic > 0, !acceptedPaymentEndpointIdentifiers.isEmpty else {
             throw PaykitPaymentRequestError.requestUnavailable
         }
         guard draft.expiresAt > proposalDate else {
@@ -781,10 +832,12 @@ struct PaykitPaymentRequestService {
         }
         let metadataData = try JSONSerialization.data(withJSONObject: ["note": draft.note])
         let metadataText = String(decoding: metadataData, as: UTF8.self)
+        let rates = try await PaykitRequestPricing.rates(requested: draft.amount.asset,
+                                                         endpoints: acceptedPaymentEndpointIdentifiers, market: marketRate(), at: proposalDate)
         let terms = try Paykit.PaymentRequestTerms(
             amount: Paykit.PaymentRequestAmount(
-                value: WalletViewModel.formatBitcoinAmount(sats: draft.amountSats),
-                asset: PaykitIssuerInterop.bitcoinAsset
+                value: draft.amount.value,
+                asset: draft.amount.asset.rawValue
             ),
             paymentReference: Paykit.PaymentReference(text: "bitkit-\(UUID().uuidString)"),
             proposalExpiresAt: Self.timestamp(draft.expiresAt),
@@ -792,8 +845,8 @@ struct PaykitPaymentRequestService {
             acceptedPaymentEndpointIdentifiers: acceptedPaymentEndpointIdentifiers,
             paymentEndpoints: nil,
             requiredAppId: "bitkit",
-            conversion: nil,
-            paymentDeadline: nil,
+            conversion: rates.isEmpty ? nil : .fixed(rates: rates),
+            paymentDeadline: .at(timestamp: Self.timestamp(draft.expiresAt)),
             metadata: Paykit.PrivateJsonObject(text: metadataText)
         )
         let record = try await sdk.proposePaymentRequest(
@@ -820,10 +873,13 @@ struct PaykitPaymentRequestService {
         expectedIdentity: String,
         validateBeforeProposing: @MainActor () throws -> Void
     ) async throws -> PaykitSubscription {
-        let acceptedPaymentEndpointIdentifiers = Self.acceptedPaymentEndpointIdentifiers()
+        let acceptedPaymentEndpointIdentifiers = await PaykitRequestPricing.subscriptionEndpoints(
+            requested: draft.amount.asset,
+            available: Self.acceptedPaymentEndpointIdentifiers(canReceiveLightning: canReceiveLightning())
+        )
         let validationDate = now()
         let name = draft.name.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard draft.amountSats > 0,
+        guard draft.amount.atomic > 0,
               !name.isEmpty,
               draft.frequency.isSupported,
               !acceptedPaymentEndpointIdentifiers.isEmpty
@@ -858,7 +914,10 @@ struct PaykitPaymentRequestService {
             throw PaykitPaymentRequestError.requestUnavailable
         }
         try await validateBeforeProposing()
-        guard Self.acceptedPaymentEndpointIdentifiers() == acceptedPaymentEndpointIdentifiers else {
+        guard await PaykitRequestPricing.subscriptionEndpoints(
+            requested: draft.amount.asset,
+            available: Self.acceptedPaymentEndpointIdentifiers(canReceiveLightning: canReceiveLightning())
+        ) == acceptedPaymentEndpointIdentifiers else {
             throw PaykitPaymentRequestError.requestUnavailable
         }
         let proposalDate = now()
@@ -905,6 +964,7 @@ struct PaykitPaymentRequestService {
             "subscription": subscriptionMetadata,
         ])
         let metadataText = String(decoding: metadataData, as: UTF8.self)
+        let rates = try PaykitRequestPricing.rates(requested: draft.amount.asset, endpoints: endpoints, market: nil, at: proposalDate)
         let timestamp = Self.timestamp(proposalDate)
         let recurrence = Paykit.PaymentRequestRecurrence(
             every: 1,
@@ -915,8 +975,8 @@ struct PaykitPaymentRequestService {
         )
         return try Paykit.PaymentRequestTerms(
             amount: Paykit.PaymentRequestAmount(
-                value: WalletViewModel.formatBitcoinAmount(sats: draft.amountSats),
-                asset: PaykitIssuerInterop.bitcoinAsset
+                value: draft.amount.value,
+                asset: draft.amount.asset.rawValue
             ),
             paymentReference: Paykit.PaymentReference(text: "bitkit-\(UUID().uuidString)"),
             proposalExpiresAt: Self.timestamp(draft.expiresAt),
@@ -924,7 +984,7 @@ struct PaykitPaymentRequestService {
             acceptedPaymentEndpointIdentifiers: endpoints,
             paymentEndpoints: nil,
             requiredAppId: "bitkit",
-            conversion: nil,
+            conversion: rates.isEmpty ? nil : .fixed(rates: rates),
             paymentDeadline: nil,
             metadata: Paykit.PrivateJsonObject(text: metadataText)
         )
@@ -1024,10 +1084,11 @@ struct PaykitPaymentRequestService {
         return subscription
     }
 
-    private static func acceptedPaymentEndpointIdentifiers() -> [String] {
+    static func acceptedPaymentEndpointIdentifiers(canReceiveLightning: Bool) -> [String] {
         PublicPaykitService.MethodId.publishableMethodIds.compactMap { methodId in
+            if methodId == .usdtArbitrum { return PublicPaykitService.isUsdtPaymentOptionEnabled() ? methodId.rawValue : nil }
             if methodId == .bitcoinLightningBolt11 {
-                return PublicPaykitService.isLightningPaymentOptionEnabled() ? methodId.rawValue : nil
+                return canReceiveLightning && PublicPaykitService.isLightningPaymentOptionEnabled() ? methodId.rawValue : nil
             }
             guard methodId.onchainNetwork == Env.network,
                   PublicPaykitService.isOnchainPaymentOptionEnabled()
@@ -1350,10 +1411,14 @@ final class PaykitPaymentRequestManager {
         subscriptionStateStore: any PaykitSubscriptionStateStoring = PaykitSubscriptionStateStore(),
         subscriptionNotificationScheduler: PaykitSubscriptionNotificationScheduler = PaykitSubscriptionNotificationScheduler(),
         completedPaymentProofKinds: @escaping @Sendable (String) async -> [PaykitPaymentRequest.ID: PaykitPaymentProofKind] = { identity in
-            await PaykitPaymentProofService.shared.completedRequestProofKindsAwaitingSubmission(identity: identity)
+            let bitcoin = await PaykitPaymentProofService.shared.completedRequestProofKindsAwaitingSubmission(identity: identity)
+            let usdt = (try? PaykitUsdtPaymentService.shared.paymentProtection(identity: identity).completed) ?? [:]
+            return bitcoin.merging(usdt) { existing, _ in existing }
         },
         inFlightPaymentRequestIds: @escaping @Sendable (String) async -> Set<PaykitPaymentRequest.ID> = { identity in
-            await PaykitPaymentProofService.shared.inFlightRequestIds(identity: identity)
+            let bitcoin = await PaykitPaymentProofService.shared.inFlightRequestIds(identity: identity)
+            let usdt = (try? PaykitUsdtPaymentService.shared.paymentProtection(identity: identity).inFlight) ?? []
+            return bitcoin.union(usdt)
         },
         retainedHardwarePaymentsForRetry: @escaping @Sendable (String) async -> [PaykitPaymentRequest.ID: PendingPaykitPaymentProof] = { identity in
             await PaykitPaymentProofService.shared.retainedHardwarePaymentsForRetry(identity: identity)
@@ -1362,10 +1427,15 @@ final class PaykitPaymentRequestManager {
             String,
             PaykitSubscription.ID
         ) async throws -> Set<PaykitPaymentRequest.ID> = { identity, subscriptionId in
-            try await PaykitPaymentProofService.shared.protectedRequestIdsForSubscriptionCancellation(
+            let bitcoin = try await PaykitPaymentProofService.shared.protectedRequestIdsForSubscriptionCancellation(
                 identity: identity,
                 subscriptionId: subscriptionId
             )
+            let usdt = try PaykitUsdtPaymentService.shared.paymentProtection(identity: identity).inFlight.filter {
+                $0.billingPeriodStartsAt != nil && $0.paymentRequestId == subscriptionId.paymentRequestId &&
+                    $0.counterparty == subscriptionId.counterparty
+            }
+            return bitcoin.union(usdt)
         },
         now: @escaping @Sendable () -> Date = { Date() },
         subscriptionNow: (@Sendable () -> Date)? = nil,
@@ -1601,7 +1671,7 @@ final class PaykitPaymentRequestManager {
     }
 
     func propose(_ draft: PaykitPaymentRequestDraft, to target: PaykitPaymentRequestTarget) async throws -> PaykitPaymentRequest {
-        guard draft.amountSats > 0,
+        guard draft.amount.atomic > 0,
               isAvailable(),
               let activeIdentity,
               eligibleTargets.contains(target)
@@ -1643,7 +1713,7 @@ final class PaykitPaymentRequestManager {
         _ draft: PaykitSubscriptionDraft,
         to target: PaykitPaymentRequestTarget
     ) async throws -> PaykitSubscription {
-        guard draft.amountSats > 0,
+        guard draft.amount.atomic > 0,
               isAvailable(),
               let activeIdentity,
               eligibleTargets.contains(target)
@@ -1763,13 +1833,15 @@ final class PaykitPaymentRequestManager {
             guard !request.isPaymentDeadlineExpired(at: now()) else {
                 throw PaykitPaymentRequestError.requestExpired
             }
-            guard let identity = activeIdentity, isApprovedForPayment(request) else {
+            guard let identity = activeIdentity, isApprovedForPayment(request),
+                  request.billingPeriod == nil || !isProcessingSubscription
+            else {
                 throw PaykitPaymentRequestError.requestUnavailable
             }
             try await service.ensurePaymentAllowed(request)
             guard generation == stateGeneration,
                   PubkyPublicKeyFormat.matches(activeIdentity, identity),
-                  isApprovedForPayment(request)
+                  isApprovedForPayment(request), request.billingPeriod == nil || !isProcessingSubscription
             else { throw PaykitPaymentRequestError.requestUnavailable }
         } catch {
             if error as? PaykitPaymentRequestError == .requestUnavailable || error as? PaykitPaymentRequestError == .requestExpired {
@@ -2387,7 +2459,10 @@ final class PaykitPaymentRequestManager {
             let handledRequestedExpirationId = recordRequestedPresentationExpiration(at: refreshDate)
             let previousPending = pendingRequests
             receivedPaymentContacts = snapshot.receivedPaymentContacts
-            subscriptions = snapshot.subscriptions.map { $0.withExpiredLifecycle(at: subscriptionDate) }
+            let satisfiedUsdtProofs = (try? PaykitUsdtPaymentService.shared.satisfiedProofs(identity: activeIdentity)) ?? [:]
+            subscriptions = snapshot.subscriptions.map {
+                $0.withVerifiedUsdtPayments(satisfiedUsdtProofs).withExpiredLifecycle(at: subscriptionDate)
+            }
             let visibleProposalIds = Set(subscriptions.filter {
                 $0.isPayer && $0.isProposalVisible(at: subscriptionDate)
             }.map(\.id))
@@ -2431,7 +2506,7 @@ final class PaykitPaymentRequestManager {
             dismissedSubscriptionPaymentIds.formIntersection(activeRecurringRequestIds)
             persistSubscriptionState()
             let recurringPending = recurringRequestsBySubscription
-                .filter { $0.0.lifecycleState == .activeRecurring && !$0.0.hasPaymentDeadline }
+                .filter { $0.0.lifecycleState == .activeRecurring }
                 .flatMap { _, requests in
                     requests.filter {
                         $0.lifecycleState != .proofSubmitted &&
@@ -2512,6 +2587,8 @@ final class PaykitPaymentRequestManager {
 
     private func applyCommittedSubscription(_ subscription: PaykitSubscription, at date: Date) async {
         guard let activeIdentity else { return }
+        let satisfiedUsdtProofs = (try? PaykitUsdtPaymentService.shared.satisfiedProofs(identity: activeIdentity)) ?? [:]
+        let subscription = subscription.withVerifiedUsdtPayments(satisfiedUsdtProofs)
         subscriptions.removeAll { $0.id == subscription.id }
         subscriptions.append(subscription)
 
@@ -2533,7 +2610,7 @@ final class PaykitPaymentRequestManager {
             subscription.requests(through: date, acceptedAt: $0)
         } ?? []
         pendingRequests.removeAll { $0.belongs(to: subscription) }
-        if subscription.lifecycleState == .activeRecurring, !subscription.hasPaymentDeadline {
+        if subscription.lifecycleState == .activeRecurring {
             pendingRequests.append(contentsOf: recurringRequests.filter { $0.lifecycleState != .proofSubmitted })
             pendingRequests.sort { ($0.createdAt ?? .distantFuture) < ($1.createdAt ?? .distantFuture) }
         }
diff --git a/Bitkit/Services/PaykitSubscription.swift b/Bitkit/Services/PaykitSubscription.swift
index aa7acfeda..7afbecf1c 100644
--- a/Bitkit/Services/PaykitSubscription.swift
+++ b/Bitkit/Services/PaykitSubscription.swift
@@ -429,17 +429,22 @@ struct PaykitSubscription: Identifiable, Hashable {
     struct Payment: Hashable {
         let billingPeriod: PaykitBillingPeriod
         let proofKind: PaykitPaymentProofKind?
+        let proofEventId: String
     }
 
     let paymentRequestId: String
     let counterparty: String
     let proposalStreamItemId: UInt64?
-    let amountValue: String
-    let amountSats: UInt64
+    let amount: PaykitAmount
+    let paymentReference: String
+    let pricing: PaykitRequestPricing
+    var amountValue: String {
+        amount.value
+    }
+
     let note: String?
     let createdAt: Date?
     let proposalExpiresAt: Date?
-    let hasPaymentDeadline: Bool
     let recurrence: PaykitSubscriptionRecurrence
     let metadata: PaykitSubscriptionMetadata
     let acceptedPaymentEndpointIdentifiers: [String]
@@ -448,9 +453,20 @@ struct PaykitSubscription: Identifiable, Hashable {
     let deliveryStatus: PaykitPaymentRequest.DeliveryStatus?
     var lifecycleState: Paykit.PaymentRequestLifecycleState
     let payments: [Payment]
+    private var verifiedUsdtPeriods: Set<PaykitBillingPeriod> = []
 
     var paidPeriods: [PaykitBillingPeriod] {
-        payments.map(\.billingPeriod)
+        payments.filter { isPayer || $0.proofKind != .usdt || verifiedUsdtPeriods.contains($0.billingPeriod) }.map(\.billingPeriod)
+    }
+
+    func withVerifiedUsdtPayments(_ proofs: [PaykitPaymentRequest.ID: Set<String>]) -> Self {
+        var subscription = self
+        subscription.verifiedUsdtPeriods = Set(payments.compactMap { payment in
+            let id = PaykitPaymentRequest.ID(paymentRequestId: paymentRequestId, counterparty: counterparty,
+                                             billingPeriodStartsAt: payment.billingPeriod.startsAt)
+            return proofs[id]?.contains(payment.proofEventId) == true ? payment.billingPeriod : nil
+        })
+        return subscription
     }
 
     var id: ID {
@@ -474,7 +490,6 @@ struct PaykitSubscription: Identifiable, Hashable {
 
     func isProposalActionable(at date: Date) -> Bool {
         isProposalVisible(at: date) &&
-            !hasPaymentDeadline &&
             recurrence.unit.isSupported &&
             recurrence.canMaterializePeriods &&
             !acceptedPaymentEndpointIdentifiers.isEmpty
@@ -563,9 +578,9 @@ struct PaykitSubscription: Identifiable, Hashable {
         guard let terms = record.terms,
               terms.conversion == nil,
               let recurrence = terms.recurrence.flatMap(PaykitSubscriptionRecurrence.init),
-              terms.amount.asset == PaykitIssuerInterop.bitcoinAsset,
-              let amountSats = PaykitPaymentRequest.sats(fromBitcoinAmount: terms.amount.value),
-              amountSats <= UInt64.max / 1000
+              let asset = PaykitAsset(rawValue: terms.amount.asset),
+              let amount = try? PaykitAmount(asset: asset, value: terms.amount.value),
+              asset != .btc || amount.atomic <= UInt64.max / 1000
         else { return nil }
 
         let proposalExpiresAt = terms.proposalExpiresAt.flatMap(PaykitPaymentRequest.parseDate)
@@ -576,12 +591,12 @@ struct PaykitSubscription: Identifiable, Hashable {
         paymentRequestId = record.paymentRequestId
         proposalStreamItemId = record.proposalStreamItemId
         counterparty = record.counterparty
-        amountValue = terms.amount.value
-        self.amountSats = amountSats
+        self.amount = amount
+        paymentReference = terms.paymentReference.exportText()
+        pricing = PaykitRequestPricing(conversion: terms.conversion, deadline: terms.paymentDeadline, quotes: record.conversionQuotes)
         note = PaykitPaymentRequest.note(from: terms.metadata).map { String($0.prefix(256)) }
         createdAt = record.lastEventAt.flatMap(PaykitPaymentRequest.parseDate)
         self.proposalExpiresAt = proposalExpiresAt
-        hasPaymentDeadline = terms.paymentDeadline != nil
         self.recurrence = recurrence
         metadata = PaykitSubscriptionMetadata(terms.metadata)
         acceptedPaymentEndpointIdentifiers = PaykitIssuerInterop.supportedEndpointIdentifiers(
@@ -601,7 +616,8 @@ struct PaykitSubscription: Identifiable, Hashable {
             else { continue }
             paymentsByPeriod[billingPeriod] = Payment(
                 billingPeriod: billingPeriod,
-                proofKind: PaykitPaymentProofKind(paymentEndpointIdentifier: proof.paymentEndpointIdentifier)
+                proofKind: PaykitPaymentProofKind(paymentEndpointIdentifier: proof.paymentEndpointIdentifier),
+                proofEventId: proof.eventId
             )
         }
         payments = paymentsByPeriod.values.sorted { $0.billingPeriod.startsAt < $1.billingPeriod.startsAt }
@@ -623,7 +639,7 @@ struct PaykitSubscription: Identifiable, Hashable {
     /// The period that accepting at `acceptedAt` makes due on the schedule clock `date`; `acceptedAt` is real time, which
     /// differs from `date` only while the subscription clock offset is on.
     func paymentDueOnAcceptance(at date: Date, acceptedAt: Date? = nil) -> PaykitPaymentRequest? {
-        guard isPayer, !hasPaymentDeadline else { return nil }
+        guard isPayer else { return nil }
         let acceptedAt = PaykitPreciseInstant(date: acceptedAt ?? date)
         guard let period = recurrence.periods(through: date, acceptedAt: acceptedAt).first else { return nil }
         return PaykitPaymentRequest(subscription: self, billingPeriod: period, lifecycleState: .activeRecurring)
@@ -751,7 +767,6 @@ actor PaykitSubscriptionNotificationScheduler {
         let previousClockOffset = lastClockOffset
         let eligibleSubscriptions = subscriptions.filter {
             $0.isPayer &&
-                !$0.hasPaymentDeadline &&
                 $0.recurrence.unit.isSupported &&
                 acceptedAt[$0.id] != nil
         }
diff --git a/Bitkit/Services/PaykitSubscriptionProposal.swift b/Bitkit/Services/PaykitSubscriptionProposal.swift
index f1da75b1d..4bbca27a4 100644
--- a/Bitkit/Services/PaykitSubscriptionProposal.swift
+++ b/Bitkit/Services/PaykitSubscriptionProposal.swift
@@ -2,47 +2,49 @@ import Foundation
 import Paykit
 
 enum PaykitSubscriptionProposal {
-    // Paykit's proposal wire format is carried in a pubky-noise message capped at 1,000 UTF-8 bytes.
-    static let maximumMessageBytes = 1000
     static let reservedIconURI = "pubky://" + String(repeating: "x", count: 122)
 
     static func validate(_ terms: Paykit.PaymentRequestTerms) throws {
-        guard try encodedSize(terms) <= maximumMessageBytes else {
+        guard try encodedSize(terms) <= PaykitSdkService.maximumMessageBytes else {
             throw PaykitPaymentRequestError.subscriptionTooLong
         }
     }
 
     static func encodedSize(_ terms: Paykit.PaymentRequestTerms) throws -> Int {
-        // Unmodeled fields must not silently reduce the estimated transport size.
-        guard let recurrence = terms.recurrence,
-              terms.paymentEndpoints == nil, terms.conversion == nil, terms.paymentDeadline == nil
-        else {
+        guard let recurrence = terms.recurrence, terms.paymentEndpoints == nil else {
             throw PaykitPaymentRequestError.requestUnavailable
         }
         let metadata = try JSONSerialization.jsonObject(with: Data(terms.metadata.exportText().utf8))
         let uuid = "00000000-0000-0000-0000-000000000000"
-        let wire: [String: Any] = [
-            "version": 1,
-            "kind": "paykit.payment_request",
-            "app_id": "bitkit",
-            "event_id": uuid,
-            "payment_request_id": uuid,
-            "request": [
-                "amount": ["value": terms.amount.value, "asset": terms.amount.asset],
-                "payment_reference": terms.paymentReference.exportText(),
-                "proposal_expires_at": terms.proposalExpiresAt as Any? ?? NSNull(),
-                "recurrence": [
-                    "every": recurrence.every,
-                    "unit": recurrence.unit,
-                    "starts_at": recurrence.startsAt,
-                    "anchor": recurrence.anchor,
-                    "ends_at": recurrence.endsAt as Any? ?? NSNull(),
-                ],
-                "accepted_payment_endpoint_identifiers": terms.acceptedPaymentEndpointIdentifiers,
-                "required_app_id": terms.requiredAppId as Any? ?? NSNull(),
-                "metadata": metadata,
+        var request: [String: Any] = [
+            "amount": ["value": terms.amount.value, "asset": terms.amount.asset],
+            "payment_reference": terms.paymentReference.exportText(),
+            "proposal_expires_at": terms.proposalExpiresAt as Any? ?? NSNull(),
+            "recurrence": [
+                "every": recurrence.every,
+                "unit": recurrence.unit,
+                "starts_at": recurrence.startsAt,
+                "anchor": recurrence.anchor,
+                "ends_at": recurrence.endsAt as Any? ?? NSNull(),
             ],
+            "accepted_payment_endpoint_identifiers": terms.acceptedPaymentEndpointIdentifiers,
+            "required_app_id": terms.requiredAppId as Any? ?? NSNull(),
+            "metadata": metadata,
         ]
+        if let conversion = terms.conversion {
+            switch conversion {
+            case let .fixed(rates): request["conversion"] = ["type": "fixed", "rates": rates.map { ["asset": $0.asset, "value": $0.value] }]
+            case .perPeriod: request["conversion"] = ["type": "per_period"]
+            }
+        }
+        if let deadline = terms.paymentDeadline {
+            switch deadline {
+            case let .at(timestamp): request["payment_deadline"] = ["type": "at", "timestamp": timestamp]
+            case let .periodStart(seconds): request["payment_deadline"] = ["type": "period_start", "seconds": seconds]
+            }
+        }
+        let wire: [String: Any] = ["version": 1, "kind": "paykit.payment_request", "app_id": "bitkit",
+                                   "event_id": uuid, "payment_request_id": uuid, "request": request]
         return try JSONSerialization.data(withJSONObject: wire, options: [.withoutEscapingSlashes]).count
     }
 }
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
new file mode 100644
index 000000000..4770f7799
--- /dev/null
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -0,0 +1,423 @@
+import BitkitCore
+import Combine
+import Foundation
+import Observation
+import Paykit
+
+/// The request binding survives proof delivery so a retry cannot start another payment.
+@Observable @MainActor
+final class PaykitUsdtPaymentService {
+    static let shared = PaykitUsdtPaymentService()
+
+    struct Proof: Codable, Equatable {
+        let type: String
+        let chainId: String
+        let transactionHash: String
+        let receiptLogIndex: String
+        let signature: String
+
+        enum CodingKeys: String, CodingKey {
+            case type, signature
+            case chainId = "chain_id"
+            case transactionHash = "transaction_hash"
+            case receiptLogIndex = "receipt_log_index"
+        }
+
+        init(_ value: UsdtPaymentProof) {
+            type = "erc20-transfer-eip712"
+            chainId = value.chainId
+            transactionHash = value.transactionHash
+            receiptLogIndex = value.receiptLogIndex
+            signature = value.signature
+        }
+
+        var coreValue: UsdtPaymentProof {
+            UsdtPaymentProof(chainId: chainId, transactionHash: transactionHash, receiptLogIndex: receiptLogIndex, signature: signature)
+        }
+    }
+
+    struct Attempt: Codable, Equatable {
+        let quoteId: String
+        let wallet: String
+        let identity: String
+        let contact: String
+        let requestId: PaykitPaymentRequest.ID?
+        let binding: UsdtPaymentProofBinding?
+        let billingPeriod: PaykitBillingPeriod?
+        var proof: Proof?
+        var proofQueued = false
+        var paymentStarted = false
+    }
+
+    struct Receipt: Codable, Equatable {
+        let wallet: String
+        let identity: String
+        let requestId: PaykitPaymentRequest.ID
+        let paymentId: String
+        let proofEventId: String
+        var verified: Bool
+        let transferId: String
+        let amount: PaykitAmount
+        let receivedAt: Date
+        let underpaid: Bool
+        let afterExpiry: Bool
+        var satisfied: Bool {
+            verified && !underpaid && !afterExpiry
+        }
+    }
+
+    private struct State: Codable {
+        var attempts: [Attempt] = []
+        var receipts: [Receipt] = []
+    }
+
+    private(set) var attempts: [Attempt] = []
+    private(set) var receipts: [Receipt] = []
+    private var activeWallet: String?
+    private var activeIdentity: String?
+    private var reconciling = false
+    private var preparing = false
+    private(set) var resumableRequests: Set<PaykitPaymentRequest.ID> = []
+
+    private nonisolated(unsafe) static let stateChanged = PassthroughSubject<Void, Never>()
+    nonisolated static var walletBackupDataChangedPublisher: AnyPublisher<Void, Never> {
+        stateChanged.eraseToAnyPublisher()
+    }
+
+    func backupSnapshot() throws -> PaykitUsdtStateBackup {
+        let state = try load()
+        return PaykitUsdtStateBackup(attempts: state.attempts.map(PaykitUsdtStateBackup.Attempt.init),
+                                     receipts: state.receipts.map(PaykitUsdtStateBackup.Receipt.init))
+    }
+
+    func restoreBackup(_ backup: PaykitUsdtStateBackup) throws {
+        var state = try load()
+        for attempt in try backup.attempts.map({ try $0.restored() }) {
+            if let index = state.attempts.firstIndex(where: { $0.wallet == attempt.wallet && $0.quoteId == attempt.quoteId }) {
+                state.attempts[index].paymentStarted = state.attempts[index].paymentStarted || attempt.paymentStarted
+                state.attempts[index].proof = state.attempts[index].proof ?? attempt.proof
+            } else {
+                state.attempts.append(attempt)
+            }
+        }
+        // Restored delivery queues may be older than local payment evidence; reconciliation deduplicates proofs.
+        for index in state.attempts.indices {
+            state.attempts[index].proofQueued = false
+        }
+        for receipt in try backup.receipts.map({ try $0.restored() }) where !state.receipts.contains(where: {
+            $0.wallet == receipt.wallet && $0.paymentId == receipt.paymentId
+        }) {
+            state.receipts.append(receipt)
+        }
+        try save(state)
+    }
+
+    func send(_ quote: UsdtQuote, context: ContactPaymentContext, paymentTerms: PaykitRequestPricing.Payment?,
+              wallet: UsdtWalletManager, authorize: () async throws -> Void) async throws
+    {
+        try setPaymentStarted(quoteId: quote.id, started: true)
+        do {
+            try await authorize()
+            try Task.checkCancellation()
+            if let request = context.incomingPaymentRequest {
+                guard !request.isExpired(at: Date()),
+                      request.acceptsPayment(PaykitAmount(asset: .usdt, atomic: quote.amount), paymentTerms: paymentTerms)
+                else { throw PaykitPaymentRequestError.amountMismatch }
+            }
+        } catch {
+            try? setPaymentStarted(quoteId: quote.id, started: false)
+            throw error
+        }
+        do {
+            try await wallet.send(quote)
+        } catch {
+            // Core persists signed operations before broadcast. Only this completed send can establish non-submission.
+            if !(error is CancellationError), await (try? wallet.storedTransfer(quote.id) == nil) == true {
+                try? setPaymentStarted(quoteId: quote.id, started: false)
+            }
+            throw error
+        }
+    }
+
+    private func setPaymentStarted(quoteId: String, started: Bool) throws {
+        var state = try load()
+        guard let index = state.attempts.firstIndex(where: {
+            $0.quoteId == quoteId && $0.wallet == activeWallet && $0.identity == activeIdentity
+        }) else { throw PaykitPaymentRequestError.requestUnavailable }
+        state.attempts[index].paymentStarted = started
+        if started, let id = state.attempts[index].requestId { resumableRequests.remove(id) }
+        try save(state)
+    }
+
+    private func load() throws -> State {
+        guard let data = try Keychain.load(key: .paykitUsdtPayments) else { return State() }
+        return try JSONDecoder().decode(State.self, from: data)
+    }
+
+    private func save(_ state: State) throws {
+        try Keychain.upsert(key: .paykitUsdtPayments, data: JSONEncoder().encode(state))
+        publish(state)
+        Self.stateChanged.send()
+    }
+
+    private func publish(_ state: State) {
+        attempts = state.attempts.filter { $0.wallet == activeWallet && $0.identity == activeIdentity }
+        receipts = state.receipts.filter { $0.wallet == activeWallet && $0.identity == activeIdentity }
+    }
+
+    func hasBinding(for requestId: PaykitPaymentRequest.ID) -> Bool {
+        attempts.contains { $0.requestId == requestId }
+    }
+
+    func paymentProtection(identity: String) throws
+        -> (inFlight: Set<PaykitPaymentRequest.ID>, completed: [PaykitPaymentRequest.ID: PaykitPaymentProofKind])
+    {
+        var inFlight = Set<PaykitPaymentRequest.ID>()
+        var completed: [PaykitPaymentRequest.ID: PaykitPaymentProofKind] = [:]
+        for attempt in try load().attempts where PubkyPublicKeyFormat.matches(attempt.identity, identity) && !attempt.proofQueued {
+            guard let id = attempt.requestId,
+                  attempt.wallet != activeWallet || !PubkyPublicKeyFormat.matches(activeIdentity, identity) || !resumableRequests.contains(id)
+            else { continue }
+            if attempt.paymentStarted || attempt.proof != nil { inFlight.insert(id) }
+            if attempt.proof != nil { completed[id] = .usdt }
+        }
+        return (inFlight, completed)
+    }
+
+    func satisfiedProofs(identity: String) throws -> [PaykitPaymentRequest.ID: Set<String>] {
+        guard PubkyPublicKeyFormat.matches(activeIdentity, identity), let activeWallet else { return [:] }
+        var proofs: [PaykitPaymentRequest.ID: Set<String>] = [:]
+        for receipt in try load().receipts where receipt.wallet == activeWallet &&
+            PubkyPublicKeyFormat.matches(receipt.identity, identity) && receipt.satisfied
+        {
+            proofs[receipt.requestId, default: []].insert(receipt.proofEventId)
+        }
+        return proofs
+    }
+
+    func receipt(for request: PaykitPaymentRequest) -> Receipt? {
+        receipts.last { $0.requestId == request.id && $0.proofEventId == request.paymentProofEventId }
+    }
+
+    func contact(for transferId: String) -> String? {
+        attempts.first { $0.quoteId == transferId }?.contact ?? receipts.first { $0.transferId == transferId }?.requestId.counterparty
+    }
+
+    static func binding(request: PaykitPaymentRequest, identity: String, paymentAppId: String, quoteId: String?,
+                        period: Paykit.BillingPeriod?) throws -> UsdtPaymentProofBinding
+    {
+        let local = try PaykitPublicKeys.raw(identity)
+        let remote = try PaykitPublicKeys.raw(request.counterparty)
+        guard let uuid = UUID(uuidString: request.paymentRequestId) else { throw PaykitPaymentRequestError.requestUnavailable }
+        let incoming = request.direction == .incoming
+        return UsdtPaymentProofBinding(
+            payer: incoming ? local : remote, payee: incoming ? remote : local,
+            paymentAppId: paymentAppId,
+            paymentRequestId: uuid.uuidString.lowercased(), paymentReference: request.paymentReference,
+            paymentEndpointIdentifier: PublicPaykitService.MethodId.usdtArbitrum.rawValue,
+            // EIP-712 binds the proof's timestamp strings, not their normalized spelling.
+            periodStartsAt: period?.startsAt ?? "", periodEndsAt: period?.endsAt ?? "",
+            conversionQuoteId: quoteId ?? ""
+        )
+    }
+
+    /// Check the complete wire message, including its outer request fields, before spending funds.
+    static func validateProofSize(binding: UsdtPaymentProofBinding) throws {
+        let placeholder = Proof(UsdtPaymentProof(chainId: "42161", transactionHash: "0x" + String(repeating: "0", count: 64),
+                                                 receiptLogIndex: String(repeating: "9", count: 78),
+                                                 signature: "0x" + String(repeating: "0", count: 130)))
+        var message: [String: Any] = try [
+            "version": 1, "kind": "paykit.payment_proof", "app_id": "bitkit", "event_id": UUID().uuidString.lowercased(),
+            "payment_request_id": binding.paymentRequestId, "payment_reference": binding.paymentReference,
+            "payment_app_id": binding.paymentAppId,
+            "payment_endpoint_identifier": binding.paymentEndpointIdentifier,
+            "billing_period": NSNull(), "proof": JSONSerialization.jsonObject(with: JSONEncoder().encode(placeholder)),
+        ]
+        if !binding.periodStartsAt.isEmpty {
+            message["billing_period"] = ["starts_at": binding.periodStartsAt, "ends_at": binding.periodEndsAt]
+        }
+        if !binding.conversionQuoteId.isEmpty { message["conversion_quote_id"] = binding.conversionQuoteId }
+        guard try JSONSerialization.data(withJSONObject: message, options: [.withoutEscapingSlashes]).count <= PaykitSdkService.maximumMessageBytes
+        else {
+            throw PaykitPaymentRequestError.requestUnavailable
+        }
+    }
+
+    func prepare(context: ContactPaymentContext, quote: UsdtQuote, wallet: UsdtWalletManager,
+                 amount: PaykitAmount?, paymentTerms: PaykitRequestPricing.Payment?) async throws
+    {
+        guard !preparing else { throw PaykitPaymentRequestError.operationInProgress }
+        preparing = true
+        defer { preparing = false }
+        guard quote.destination == .arbitrum, quote.amount > 0,
+              let endpoint = context.endpoints.first(where: { $0.methodId == .usdtArbitrum }),
+              let address = PaykitUsdt.address(from: endpoint.rawPayload),
+              address.caseInsensitiveCompare(quote.recipient) == .orderedSame,
+              let identity = try await currentIdentity()
+        else { throw PaykitPaymentRequestError.requestUnavailable }
+        let payment = PaykitAmount(asset: .usdt, atomic: quote.amount)
+        guard amount == payment else { throw PaykitPaymentRequestError.amountMismatch }
+        let request = context.incomingPaymentRequest
+        if let request {
+            guard request.acceptedPaymentEndpointIdentifiers.contains(PublicPaykitService.MethodId.usdtArbitrum.rawValue),
+                  !request.isExpired(at: Date()),
+                  request.acceptsPayment(payment, paymentTerms: paymentTerms)
+            else { throw PaykitPaymentRequestError.amountMismatch }
+        }
+        let owner = wallet.address.lowercased()
+        activeWallet = owner
+        activeIdentity = identity
+        if let previous = try load().attempts.first(where: {
+            $0.wallet == owner && $0.identity == identity && request != nil && $0.requestId == request?.id
+        }), previous.quoteId != quote.id {
+            // Only an unstarted or definitively unexecuted payment may be replaced by a fresh quote.
+            let transfer = try await wallet.storedTransfer(previous.quoteId)
+            guard (transfer == nil && !previous.paymentStarted) || transfer?.status == .failed || transfer?.status == .replaced else {
+                throw PaykitPaymentRequestError.operationInProgress
+            }
+        }
+        let binding: UsdtPaymentProofBinding?
+        if let request {
+            guard let privateContext = context.privatePaymentContext else {
+                throw PaykitPaymentRequestError.requestUnavailable
+            }
+            binding = try Self.binding(request: request, identity: identity,
+                                       paymentAppId: privateContext.paymentAppId(for: PublicPaykitService.MethodId.usdtArbitrum.rawValue),
+                                       quoteId: paymentTerms?.quoteId, period: request.billingPeriod?.sdkValue)
+        } else {
+            binding = nil
+        }
+        if let binding { try Self.validateProofSize(binding: binding) }
+        let attempt = Attempt(quoteId: quote.id, wallet: owner, identity: identity, contact: context.publicKey,
+                              requestId: request?.id, binding: binding, billingPeriod: request?.billingPeriod)
+        var state = try load()
+        state.attempts.removeAll {
+            $0.wallet == owner && $0.identity == identity && ($0.quoteId == quote.id || (request != nil && $0.requestId == request?.id))
+        }
+        state.attempts.append(attempt)
+        try save(state)
+    }
+
+    func reconcile(wallet: UsdtWalletManager) async {
+        guard !reconciling, wallet.isConfigured else { return }
+        reconciling = true
+        defer { reconciling = false }
+        do {
+            guard let identity = try await currentIdentity() else { return }
+            _ = try await wallet.paymentEndpoint()
+            let owner = wallet.address.lowercased()
+            activeWallet = owner
+            activeIdentity = identity
+            let state = try load()
+            publish(state)
+            var resumable: [Attempt] = []
+            for attempt in state.attempts where attempt.wallet == owner && attempt.identity == identity {
+                guard attempt.requestId != nil else { continue }
+                let transfer = try await wallet.storedTransfer(attempt.quoteId)
+                if (transfer == nil && !attempt.paymentStarted) || transfer?.status == .failed || transfer?
+                    .status == .replaced { resumable.append(attempt) }
+            }
+            guard activeWallet == owner, activeIdentity == identity else { return }
+            let currentAttempts = try load().attempts
+            resumableRequests = Set(resumable.filter { currentAttempts.contains($0) }.compactMap(\.requestId))
+            for attempt in state.attempts where attempt.wallet == owner && attempt.identity == identity && !attempt.proofQueued {
+                guard let requestId = attempt.requestId, let binding = attempt.binding else { continue }
+                let transfer = try await wallet.storedTransfer(attempt.quoteId)
+                guard attempt.proof != nil || transfer?.status == .confirmed else { continue }
+                let proof: Proof
+                if let saved = attempt.proof { proof = saved }
+                else {
+                    guard let signed = try await wallet.paymentProof(quoteId: attempt.quoteId, binding: binding) else { continue }
+                    proof = Proof(signed)
+                    var current = try load()
+                    guard let index = current.attempts.firstIndex(where: { $0.quoteId == attempt.quoteId && $0.wallet == owner }) else { continue }
+                    current.attempts[index].proof = proof
+                    try save(current)
+                }
+                let encoder = JSONEncoder()
+                encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes]
+                let data = try String(decoding: encoder.encode(proof), as: UTF8.self)
+                let pending = PendingPaykitPaymentProof(identity: identity, requestId: requestId,
+                                                        paymentAppId: binding.paymentAppId,
+                                                        paymentEndpointIdentifier: binding.paymentEndpointIdentifier,
+                                                        kind: .usdt, billingPeriod: attempt.billingPeriod,
+                                                        paymentIdentifier: attempt.quoteId, proofData: data,
+                                                        conversionQuoteId: binding.conversionQuoteId.isEmpty ? nil : binding.conversionQuoteId)
+                if await PaykitPaymentProofService.shared.submit(pending) {
+                    var current = try load()
+                    if let index = current.attempts.firstIndex(where: { $0.quoteId == attempt.quoteId && $0.wallet == owner }) {
+                        current.attempts[index].proofQueued = true
+                        try save(current)
+                    }
+                }
+            }
+            for record in try await PaykitSdkService.shared.paymentRequests() where record.localRole == .payee {
+                for submission in record.paymentProofs
+                    where submission.paymentEndpointIdentifier == PublicPaykitService.MethodId.usdtArbitrum.rawValue
+                {
+                    let request: PaykitPaymentRequest? = if let sdkPeriod = submission.billingPeriod {
+                        if let subscription = PaykitSubscription(record: record), let period = PaykitBillingPeriod(sdkPeriod: sdkPeriod),
+                           subscription.recurrence.contains(period)
+                        {
+                            PaykitPaymentRequest(subscription: subscription, billingPeriod: period,
+                                                 lifecycleState: .proofSubmitted, paymentProofKind: .usdt, direction: .outgoing)
+                        } else { nil }
+                    } else { PaykitPaymentRequest(historyRecord: record, now: Date()) }
+                    guard let request, submission.paymentAppId == "bitkit",
+                          request.acceptedPaymentEndpointIdentifiers.contains(submission.paymentEndpointIdentifier),
+                          let proof = try? JSONDecoder().decode(Proof.self, from: Data(submission.proof.exportText().utf8)),
+                          proof.type == "erc20-transfer-eip712" else { continue }
+                    let binding = try Self.binding(
+                        request: request,
+                        identity: identity,
+                        paymentAppId: submission.paymentAppId,
+                        quoteId: submission.conversionQuoteId,
+                        period: submission.billingPeriod
+                    )
+                    do {
+                        guard let payment = try await wallet.verifyPayment(binding: binding, proof: proof.coreValue) else {
+                            try invalidateReceipt(proofEventId: submission.eventId, requestId: request.id, owner: owner, identity: identity)
+                            continue
+                        }
+                        var current = try load()
+                        guard !current.receipts.contains(where: {
+                            $0.wallet == owner && $0.paymentId == payment.paymentId && ($0.identity != identity || $0.requestId != request.id)
+                        }) else { continue }
+                        let receivedAt = Date(timeIntervalSince1970: TimeInterval(payment.timestamp))
+                        let terms = try request.payment(to: .usdt, at: receivedAt, quoteId: submission.conversionQuoteId)
+                        let received = PaykitAmount(asset: .usdt, atomic: payment.amount)
+                        current.receipts.removeAll { $0.wallet == owner && $0.identity == identity && $0.paymentId == payment.paymentId }
+                        current.receipts.append(Receipt(wallet: owner, identity: identity, requestId: request.id,
+                                                        paymentId: payment.paymentId, proofEventId: submission.eventId, verified: true,
+                                                        transferId: payment.transferId, amount: received,
+                                                        receivedAt: receivedAt, underpaid: received.atomic < terms.amount.atomic,
+                                                        afterExpiry: !terms.isValid(at: receivedAt)))
+                        try save(current)
+                    } catch let error as UsdtError {
+                        if case .InvalidPaymentProof = error {
+                            try invalidateReceipt(proofEventId: submission.eventId, requestId: request.id, owner: owner, identity: identity)
+                            continue
+                        }
+                        throw error
+                    } catch is PaykitAmountError { continue }
+                }
+            }
+        } catch {
+            Logger.warn("Unable to reconcile Paykit USDT payments: \(error)", context: "PaykitUsdt")
+        }
+    }
+
+    private func invalidateReceipt(proofEventId: String, requestId: PaykitPaymentRequest.ID, owner: String, identity: String) throws {
+        var current = try load()
+        guard let index = current.receipts.firstIndex(where: {
+            $0.wallet == owner && $0.identity == identity && $0.requestId == requestId && $0.proofEventId == proofEventId && $0.verified
+        }) else { return }
+        current.receipts[index].verified = false
+        try save(current)
+    }
+
+    private func currentIdentity() async throws -> String? {
+        guard let status = try await PaykitSdkService.shared.identityStatus(), status.capability == .privateLinkCapable else { return nil }
+        return status.publicKey.flatMap(PubkyPublicKeyFormat.normalized)
+    }
+}
diff --git a/Bitkit/Services/PrivatePaykitService+Endpoints.swift b/Bitkit/Services/PrivatePaykitService+Endpoints.swift
index 990a7b646..06d1965b9 100644
--- a/Bitkit/Services/PrivatePaykitService+Endpoints.swift
+++ b/Bitkit/Services/PrivatePaykitService+Endpoints.swift
@@ -94,6 +94,10 @@ extension PrivatePaykitService {
             }
         }
 
+        if PublicPaykitService.isUsdtPaymentOptionEnabled() {
+            try await endpoints.append(wallet.usdtWallet.paymentEndpoint())
+        }
+
         guard !endpoints.isEmpty else {
             throw PublicPaykitError.noSupportedEndpoint
         }
diff --git a/Bitkit/Services/PrivatePaykitService+Payments.swift b/Bitkit/Services/PrivatePaykitService+Payments.swift
index b4a24f005..7160274d7 100644
--- a/Bitkit/Services/PrivatePaykitService+Payments.swift
+++ b/Bitkit/Services/PrivatePaykitService+Payments.swift
@@ -249,7 +249,8 @@ extension PrivatePaykitService {
                     uniquingKeysWith: { first, _ in first }
                 ),
                 paymentListVersion: paymentListVersion
-            )
+            ),
+            endpoints: payableEndpoints
         )
     }
 
diff --git a/Bitkit/Services/PubkyService.swift b/Bitkit/Services/PubkyService.swift
index b7fe6b4c8..6dc86a3a2 100644
--- a/Bitkit/Services/PubkyService.swift
+++ b/Bitkit/Services/PubkyService.swift
@@ -172,6 +172,8 @@ enum PubkyService {
         accountName: String,
         secretKeyHex: String,
         accountManager: WatchOnlyAccountManager? = nil,
+        approvedUsdtAddress: String? = nil,
+        usdtEndpoint: (() async throws -> PublicPaykitService.Endpoint)? = nil,
         ordinaryApproval: @escaping OrdinaryAuthApproval = { authUrl, capabilities, clientID, secretKeyHex in
             try await approveAuth(
                 authUrl: authUrl,
@@ -191,6 +193,12 @@ enum PubkyService {
         }
     ) async throws {
         guard authUrl == request.rawUrl else { throw PubkyServiceError.invalidAuthUrl }
+        let endpoint: PublicPaykitService.Endpoint?
+        if request.bitkitClaim?.sharesUsdt == true {
+            guard let usdtEndpoint, let approvedUsdtAddress else { throw PubkyAuthRequestError.invalidPaymentDetails }
+            endpoint = try await usdtEndpoint()
+            guard endpoint?.value == approvedUsdtAddress else { throw PubkyAuthRequestError.invalidPaymentDetails }
+        } else { endpoint = nil }
         if let claim = request.bitkitClaim, claim.includesWatchOnlyAccount {
             let accountManager = accountManager ?? .shared
             let preparedClaim = try await accountManager.prepareUnsignedClaim(
@@ -210,7 +218,8 @@ enum PubkyService {
             }
 
             do {
-                try await companionApproval(authUrl, request.clientID, claim, preparedClaim.1, secretKeyHex)
+                let payload = try claim.unsignedPayload(account: preparedClaim.0, usdtEndpoint: endpoint)
+                try await companionApproval(authUrl, request.clientID, claim, payload, secretKeyHex)
             } catch {
                 if !didDeliverCompanionClaim(error: error) {
                     await cancelIncompleteAuthorization(
@@ -223,7 +232,8 @@ enum PubkyService {
 
             try await accountManager.markSetupActive(attempt: authorizationAttempt)
         } else if let claim = request.bitkitClaim {
-            try await companionApproval(authUrl, request.clientID, claim, nil, secretKeyHex)
+            let payload = try claim.unsignedPayload(account: nil, usdtEndpoint: endpoint)
+            try await companionApproval(authUrl, request.clientID, claim, payload, secretKeyHex)
         } else {
             try await ordinaryApproval(authUrl, request.capabilities, request.clientID, secretKeyHex)
         }
@@ -384,6 +394,8 @@ actor PaykitSdkService {
     }
 
     static let shared = PaykitSdkService()
+    /// Maximum plaintext size accepted by Paykit's pubky-noise transport.
+    static let maximumMessageBytes = 1000
     private static let walletBackupDataChangedSubject = PassthroughSubject<Void, Never>()
 
     nonisolated static var walletBackupDataChangedPublisher: AnyPublisher<Void, Never> {
diff --git a/Bitkit/Services/PublicPaykitService.swift b/Bitkit/Services/PublicPaykitService.swift
index f5fe158ca..e7bae7c00 100644
--- a/Bitkit/Services/PublicPaykitService.swift
+++ b/Bitkit/Services/PublicPaykitService.swift
@@ -56,7 +56,7 @@ enum IncomingPaykitPaymentRequestFailureReason: String, Hashable {
 }
 
 enum PublicPaykitPaymentLaunchResult {
-    case opened(paymentRequest: String, privatePaymentContext: PrivatePaykitPaymentContext?)
+    case opened(paymentRequest: String, privatePaymentContext: PrivatePaykitPaymentContext?, endpoints: [PublicPaykitService.Endpoint] = [])
     case noEndpoint
     case notOpened
     case privateLinkPending
@@ -123,6 +123,7 @@ enum PublicPaykitService {
     static let publishingEnabledKey = "sharesPublicPaykitEndpoints"
     static let lightningPaymentOptionEnabledKey = "paykitPaymentOptionLightningEnabled"
     static let onchainPaymentOptionEnabledKey = "paykitPaymentOptionOnchainEnabled"
+    static let usdtPaymentOptionEnabledKey = "paykitPaymentOptionUsdtEnabled"
     static let cleanupPendingKey = "publicPaykitCleanupPending"
 
     static func setCleanupPending(_ isPending: Bool) {
@@ -146,6 +147,7 @@ enum PublicPaykitService {
     }
 
     enum MethodId: String, Hashable, CaseIterable {
+        case usdtArbitrum = "usdt-arbitrum-address"
         case bitcoinLightningBolt11 = "btc-lightning-bolt11"
         case bitcoinLightningLnurl = "btc-lightning-lnurl"
         case bitcoinOnchainP2tr = "btc-bitcoin-p2tr"
@@ -168,11 +170,11 @@ enum PublicPaykitService {
         static let payablePreferenceOrder: [MethodId] = [
             .bitcoinLightningBolt11,
             .bitcoinLightningLnurl,
-        ] + onchainPreferenceOrder
+        ] + onchainPreferenceOrder + [.usdtArbitrum]
 
         static let publishableMethodIds: [MethodId] = [
             .bitcoinLightningBolt11,
-        ] + onchainPreferenceOrder
+        ] + onchainPreferenceOrder + [.usdtArbitrum]
 
         static let onchainPreferenceOrder: [MethodId] = [
             .bitcoinOnchainP2tr,
@@ -203,7 +205,7 @@ enum PublicPaykitService {
                 .signet
             case .regtestOnchainP2tr, .regtestOnchainP2wpkh, .regtestOnchainP2sh, .regtestOnchainP2pkh:
                 .regtest
-            case .bitcoinLightningBolt11, .bitcoinLightningLnurl:
+            case .bitcoinLightningBolt11, .bitcoinLightningLnurl, .usdtArbitrum:
                 nil
             }
         }
@@ -246,7 +248,7 @@ enum PublicPaykitService {
         var appId: String?
 
         var paymentRequest: String {
-            value
+            methodId == .usdtArbitrum ? PaykitUsdt.paymentURI(address: value) : value
         }
     }
 
@@ -278,6 +280,7 @@ enum PublicPaykitService {
         guard let payload = PaykitIssuerInterop.parseEndpointPayload(endpointData) else {
             return nil
         }
+        if methodId == .usdtArbitrum, PaykitUsdt.address(from: endpointData) == nil { return nil }
 
         return Endpoint(
             methodId: methodId,
@@ -426,7 +429,7 @@ enum PublicPaykitService {
             return endpoints.isEmpty ? .noEndpoint : .notOpened
         }
 
-        return .opened(paymentRequest: paymentRequest(from: payableEndpoints), privatePaymentContext: nil)
+        return .opened(paymentRequest: paymentRequest(from: payableEndpoints), privatePaymentContext: nil, endpoints: payableEndpoints)
     }
 
     static func paymentRequest(from endpoints: [Endpoint]) -> String {
@@ -468,6 +471,10 @@ enum PublicPaykitService {
         defaults.object(forKey: onchainPaymentOptionEnabledKey) as? Bool ?? true
     }
 
+    static func isUsdtPaymentOptionEnabled(defaults: UserDefaults = .standard) -> Bool {
+        Env.isUsdtEnabled && (defaults.object(forKey: usdtPaymentOptionEnabledKey) as? Bool ?? true)
+    }
+
     static func hasLightningRouteHints(bolt11: String) -> Bool {
         guard let invoice = try? Bolt11Invoice.fromStr(invoiceStr: bolt11) else {
             return false
@@ -515,7 +522,7 @@ enum PublicPaykitService {
         let includeOnchain = isOnchainPaymentOptionEnabled()
         let includeLightning = isLightningPaymentOptionEnabled()
 
-        if refreshIfNeeded {
+        if refreshIfNeeded, includeOnchain || includeLightning {
             let isNodeReady = await wallet.waitForNodeToRun()
             let lifecycleState = wallet.nodeLifecycleState
             guard isNodeReady || lifecycleState == .running else {
@@ -562,6 +569,10 @@ enum PublicPaykitService {
             )
         }
 
+        if isUsdtPaymentOptionEnabled() {
+            try await endpoints.append(wallet.usdtWallet.paymentEndpoint())
+        }
+
         guard !endpoints.isEmpty || !requireEndpoint else {
             throw PublicPaykitError.noSupportedEndpoint
         }
@@ -571,6 +582,8 @@ enum PublicPaykitService {
 
     private static func isPayableEndpoint(_ endpoint: Endpoint) async -> Bool {
         switch endpoint.methodId {
+        case .usdtArbitrum:
+            return Env.isUsdtEnabled && PaykitUsdt.address(from: endpoint.rawPayload) != nil
         case .bitcoinLightningBolt11:
             guard case let .lightning(invoice) = try? await decode(invoice: endpoint.paymentRequest) else {
                 return false
diff --git a/Bitkit/Utilities/AppReset.swift b/Bitkit/Utilities/AppReset.swift
index d95b9037c..6ca7f6116 100644
--- a/Bitkit/Utilities/AppReset.swift
+++ b/Bitkit/Utilities/AppReset.swift
@@ -46,6 +46,10 @@ enum AppReset {
         // Before the paired devices are wiped, so a reconnect still running cannot save one back.
         await hardwareWallets?.resetForWipe()
 
+        var usdtCleanupError: Error?
+        do { try await wallet.usdtWallet.wipe() }
+        catch { usdtCleanupError = error }
+
         // Stop node and wipe LDK persistence via the wallet API.
         try await wallet.wipe()
 
@@ -85,6 +89,8 @@ enum AppReset {
         session.skipSplashOnce = true
         session.bump()
 
+        if let usdtCleanupError { throw usdtCleanupError }
+
         // Show toast
         app.toast(
             type: toastType,
diff --git a/Bitkit/Utilities/Keychain.swift b/Bitkit/Utilities/Keychain.swift
index 67a7701fa..157cee373 100644
--- a/Bitkit/Utilities/Keychain.swift
+++ b/Bitkit/Utilities/Keychain.swift
@@ -9,6 +9,7 @@ enum KeychainEntryType {
     case paykitSession
     case paykitPendingPaymentProofs
     case onchainSendAttempts
+    case paykitUsdtPayments
     case paykitPresentedPaymentRequests
     case paykitAcceptedPaymentRequests
     case paykitSubscriptionState
@@ -26,6 +27,7 @@ enum KeychainEntryType {
         case .paykitSession: "paykit_session"
         case .paykitPendingPaymentProofs: "paykit_pending_payment_proofs"
         case .onchainSendAttempts: "onchain_send_attempts"
+        case .paykitUsdtPayments: "paykit_usdt_payments"
         case .paykitPresentedPaymentRequests: "paykit_presented_payment_requests"
         case .paykitAcceptedPaymentRequests: "paykit_accepted_payment_requests"
         case .paykitSubscriptionState: "paykit_subscription_state"
diff --git a/Bitkit/Utilities/PaymentNavigationHelper.swift b/Bitkit/Utilities/PaymentNavigationHelper.swift
index 3bf47921e..dc650331e 100644
--- a/Bitkit/Utilities/PaymentNavigationHelper.swift
+++ b/Bitkit/Utilities/PaymentNavigationHelper.swift
@@ -44,6 +44,11 @@ struct PaymentNavigationHelper {
         spendStore: QuickPaySpendStore = .shared,
         coordinator: QuickPayPaymentCoordinator? = nil
     ) {
+        if app.contactPaymentContext?.requiresAssetSelection == true {
+            sheetViewModel.showSheet(.send, data: SendConfig(view: .amount))
+            return
+        }
+
         // Handle LNURL withdraw
         if let lnurlWithdrawData = app.lnurlWithdrawData {
             Logger.info("LNURL withdraw data: \(lnurlWithdrawData)")
@@ -108,6 +113,7 @@ struct PaymentNavigationHelper {
         spendStore: QuickPaySpendStore = .shared,
         coordinator: QuickPayPaymentCoordinator? = nil
     ) -> SendRoute? {
+        if app.contactPaymentContext?.requiresAssetSelection == true { return .amount }
         if let lnurlWithdrawData = app.lnurlWithdrawData {
             if lnurlWithdrawData.isFixedAmount {
                 return .lnurlWithdrawConfirm
@@ -196,6 +202,7 @@ struct PaymentNavigationHelper {
         spendStore: QuickPaySpendStore = .shared,
         coordinator: QuickPayPaymentCoordinator? = nil
     ) -> SendRoute? {
+        if app.contactPaymentContext?.requiresAssetSelection == true { return .amount }
         guard let route = appropriateSendRoute(
             app: app,
             currency: currency,
@@ -238,8 +245,8 @@ struct PaymentNavigationHelper {
             let result = try await PrivatePaykitService.shared.beginSavedContactPayment(to: publicKey, wallet: wallet)
             guard !Task.isCancelled else { return }
             switch result {
-            case let .opened(paymentRequest, privatePaymentContext):
-                let context = ContactPaymentContext(publicKey: publicKey, privatePaymentContext: privatePaymentContext)
+            case let .opened(paymentRequest, privatePaymentContext, endpoints):
+                let context = ContactPaymentContext(publicKey: publicKey, privatePaymentContext: privatePaymentContext, endpoints: endpoints)
                 guard app.claimContactPaymentContext(context) else { return }
 
                 do {
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index 609a47b49..c5e127b30 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -28,21 +28,34 @@ struct ContactPaymentContext: Equatable {
     let id: UUID
     let publicKey: String
     let privatePaymentContext: PrivatePaykitPaymentContext?
-    let incomingPaymentRequest: PaykitPaymentRequest?
+    var incomingPaymentRequest: PaykitPaymentRequest?
     let isInitialSubscriptionPayment: Bool
+    let endpoints: [PublicPaykitService.Endpoint]
+
+    var requiresAssetSelection: Bool {
+        endpoints.contains { $0.methodId == .usdtArbitrum } || incomingPaymentRequest.map { $0.amount.asset != .btc } == true
+    }
+
+    func prefersUsdt(onchainBalanceSats: UInt64) -> Bool {
+        endpoints.contains { $0.methodId == .usdtArbitrum } &&
+            (incomingPaymentRequest.map { $0.amount.asset != .btc } == true ||
+                !endpoints.contains { $0.methodId != .usdtArbitrum } || onchainBalanceSats == 0)
+    }
 
     init(
         id: UUID = UUID(),
         publicKey: String,
         privatePaymentContext: PrivatePaykitPaymentContext? = nil,
         incomingPaymentRequest: PaykitPaymentRequest? = nil,
-        isInitialSubscriptionPayment: Bool = false
+        isInitialSubscriptionPayment: Bool = false,
+        endpoints: [PublicPaykitService.Endpoint] = []
     ) {
         self.id = id
         self.publicKey = publicKey
         self.privatePaymentContext = privatePaymentContext
         self.incomingPaymentRequest = incomingPaymentRequest
         self.isInitialSubscriptionPayment = isInitialSubscriptionPayment
+        self.endpoints = endpoints
     }
 }
 
@@ -116,6 +129,9 @@ class AppViewModel: ObservableObject {
     @Published var manualEntryValidationResult: ManualEntryValidationResult = .empty
     @Published var contactPaymentContext: ContactPaymentContext?
     private(set) var didRejectScannedPayment = false
+    @Published var paykitUsesUsdt = false
+    @Published var paykitReviewedAmount: PaykitAmount?
+    @Published var paykitPaymentTerms: PaykitRequestPricing.Payment?
 
     // LNURL
     @Published var lnurlPayData: LnurlPayData?
@@ -618,6 +634,23 @@ extension AppViewModel {
             }
         }
 
+        if let context = claimedContactPaymentContext, context.requiresAssetSelection {
+            resetSendState(preservingContactPaymentContext: true)
+            for endpoint in context.endpoints where endpoint.methodId != .usdtArbitrum {
+                switch try await decode(invoice: endpoint.paymentRequest) {
+                case let .onChain(invoice): scannedOnchainInvoice = invoice
+                case let .lightning(invoice): scannedLightningInvoice = invoice
+                case let .lnurlPay(data): lnurlPayData = data
+                default: break
+                }
+                try ensureScannedDataHandlingOwnership(handlingId, claimedContactPaymentContext: context)
+            }
+            paykitUsesUsdt = context.prefersUsdt(onchainBalanceSats: lightningService.balances?.spendableOnchainBalanceSats ?? 0) ||
+                context.incomingPaymentRequest.map { PaykitUsdtPaymentService.shared.hasBinding(for: $0.id) } == true
+            selectedWalletToPayFrom = scannedLightningInvoice != nil || lnurlPayData != nil ? .lightning : .onchain
+            return
+        }
+
         let rawUri = uri
         let sourceURI = rawUri.removingLightningSchemes()
         let uri = PubkyAuthRequest.normalizedProtocolURL(sourceURI)
@@ -703,7 +736,7 @@ extension AppViewModel {
             data = try await decode(invoice: uri)
             try ensureScannedDataHandlingOwnership(handlingId, claimedContactPaymentContext: claimedContactPaymentContext)
         }
-        let requestedAmount = contactPaymentContext?.incomingPaymentRequest?.amountSats
+        let requestedAmount = try contactPaymentContext?.incomingPaymentRequest?.payment(to: .btc, at: Date()).amount.atomic
         let paymentState = scanPaymentOperations.state()
 
         if scope == .onchainPayments {
@@ -961,7 +994,7 @@ extension AppViewModel {
     }
 
     func handleLnurlPayInvoice(_ data: LnurlPayData) throws {
-        let requestedAmount = contactPaymentContext?.incomingPaymentRequest?.amountSats
+        let requestedAmount = try contactPaymentContext?.incomingPaymentRequest?.payment(to: .btc, at: Date()).amount.atomic
         if let requestedAmount,
            requestedAmount < data.minSendableSat || requestedAmount > data.maxSendableSat
         {
@@ -1117,10 +1150,13 @@ extension AppViewModel {
     }
 
     var hasSendPaymentTarget: Bool {
-        scannedLightningInvoice != nil || scannedOnchainInvoice != nil || lnurlPayData != nil
+        paykitUsesUsdt || scannedLightningInvoice != nil || scannedOnchainInvoice != nil || lnurlPayData != nil
     }
 
     func resetSendState(preservingContactPaymentContext: Bool = false) {
+        paykitUsesUsdt = false
+        paykitReviewedAmount = nil
+        paykitPaymentTerms = nil
         scannedLightningInvoice = nil
         scannedOnchainInvoice = nil
         selectedWalletToPayFrom = .onchain // Reset to default
diff --git a/Bitkit/ViewModels/CurrencyViewModel.swift b/Bitkit/ViewModels/CurrencyViewModel.swift
index e74b50813..e2472fff2 100644
--- a/Bitkit/ViewModels/CurrencyViewModel.swift
+++ b/Bitkit/ViewModels/CurrencyViewModel.swift
@@ -9,6 +9,11 @@ enum PrimaryDisplay: String {
 @MainActor
 class CurrencyViewModel: ObservableObject {
     @Published private(set) var rates: [FxRate] = []
+
+    var paykitRate: PaykitExchangeRate? {
+        rates.first { $0.quote == "USD" }.map { PaykitExchangeRate(price: $0.lastPrice, timestamp: $0.timestamp) }
+    }
+
     @Published private(set) var error: Error?
     @Published private(set) var hasStaleData: Bool = false
     @Published private(set) var isRefreshing = false
diff --git a/Bitkit/ViewModels/NavigationViewModel.swift b/Bitkit/ViewModels/NavigationViewModel.swift
index 872e03c0b..c53bc8bb4 100644
--- a/Bitkit/ViewModels/NavigationViewModel.swift
+++ b/Bitkit/ViewModels/NavigationViewModel.swift
@@ -10,6 +10,7 @@ enum Route: Hashable {
     case savingsWallet
     case spendingWallet
     case hardwareWallet(walletId: String)
+    case usdtWallet
     case activityList
     case activityDetail(Activity)
     case activityExplorer(Activity)
diff --git a/Bitkit/ViewModels/WalletViewModel.swift b/Bitkit/ViewModels/WalletViewModel.swift
index 41a401efc..815bda074 100644
--- a/Bitkit/ViewModels/WalletViewModel.swift
+++ b/Bitkit/ViewModels/WalletViewModel.swift
@@ -4,6 +4,7 @@ import SwiftUI
 
 @MainActor
 class WalletViewModel: ObservableObject {
+    let usdtWallet = UsdtWalletManager()
     @Published var walletExists: Bool? = nil
     @Published var isSyncingWallet = false // Syncing both LN and on chain
     @AppStorage("totalBalanceSats") var totalBalanceSats: Int = 0 // Combined onchain and LN
@@ -113,6 +114,7 @@ class WalletViewModel: ObservableObject {
         self.transferService = transferService
         self.sheetViewModel = sheetViewModel
         self.feeEstimatesManager = feeEstimatesManager
+        BackupService.shared.usdtWallet = usdtWallet
         balanceManager = BalanceManager(
             lightningService: lightningService,
             transferService: transferService,
diff --git a/Bitkit/Views/Contacts/AddContactView.swift b/Bitkit/Views/Contacts/AddContactView.swift
index b963b7388..45a7d1942 100644
--- a/Bitkit/Views/Contacts/AddContactView.swift
+++ b/Bitkit/Views/Contacts/AddContactView.swift
@@ -267,8 +267,8 @@ struct AddContactView: View {
             let result = try await PublicPaykitService.beginPayment(to: normalizedPublicKey)
 
             switch result {
-            case let .opened(paymentRequest, _):
-                _ = await openContactPayment(paymentRequest: paymentRequest, publicKey: normalizedPublicKey)
+            case let .opened(paymentRequest, _, endpoints):
+                _ = await openContactPayment(paymentRequest: paymentRequest, publicKey: normalizedPublicKey, endpoints: endpoints)
             case .noEndpoint, .notOpened, .privateLinkPending, .waitingForUpdatedPaymentList:
                 if let messageKey = result.contactPaymentFailureMessageKey {
                     app.toast(
@@ -287,8 +287,8 @@ struct AddContactView: View {
     }
 
     @MainActor
-    private func openContactPayment(paymentRequest: String, publicKey: String) async -> Bool {
-        let contactPaymentContext = ContactPaymentContext(publicKey: publicKey)
+    private func openContactPayment(paymentRequest: String, publicKey: String, endpoints: [PublicPaykitService.Endpoint]) async -> Bool {
+        let contactPaymentContext = ContactPaymentContext(publicKey: publicKey, endpoints: endpoints)
         guard app.claimContactPaymentContext(contactPaymentContext) else { return false }
 
         do {
diff --git a/Bitkit/Views/Home/HomeWalletView.swift b/Bitkit/Views/Home/HomeWalletView.swift
index 136ce6e56..e017f2e61 100644
--- a/Bitkit/Views/Home/HomeWalletView.swift
+++ b/Bitkit/Views/Home/HomeWalletView.swift
@@ -1,3 +1,4 @@
+import BitkitCore
 import SwiftUI
 
 struct HomeWalletView: View {
@@ -6,6 +7,7 @@ struct HomeWalletView: View {
     @EnvironmentObject var navigation: NavigationViewModel
     @EnvironmentObject var settings: SettingsViewModel
     @EnvironmentObject var wallet: WalletViewModel
+    @Environment(UsdtWalletManager.self) private var usdt
     @Environment(HwWalletManager.self) private var hwWalletManager
 
     var hasActivity: Bool {
@@ -59,6 +61,27 @@ struct HomeWalletView: View {
                 .padding(.bottom, 32)
             }
 
+            if usdt.isConfigured {
+                HStack(spacing: 16) {
+                    Button { navigation.navigate(.usdtWallet) } label: {
+                        WalletBalanceContent {
+                            CaptionMText("USDT")
+                        } icon: {
+                            CircularIcon(icon: "coins", iconColor: .greenAccent, backgroundColor: .green16, size: 24)
+                        } amount: {
+                            SubtitleText(settings.hideBalance ? " • • • • •" : usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—")
+                                .lineLimit(1).minimumScaleFactor(0.7)
+                        }
+                    }
+                    .buttonStyle(.plain)
+                    .accessibilityIdentifier("UsdtWallet")
+                    CustomDivider(color: .gray4, type: .vertical)
+                    Color.clear.frame(maxWidth: .infinity)
+                }
+                .frame(height: 50)
+                .padding(.bottom, 32)
+            }
+
             if hasActivity {
                 ActivityLatest()
 
@@ -69,7 +92,7 @@ struct HomeWalletView: View {
                 }
             } else {
                 Spacer()
-                WalletOnboardingView(type: .home)
+                if usdt.balance ?? 0 == 0 { WalletOnboardingView(type: .home) }
             }
         }
         .padding(.top, ScreenLayout.topPaddingWithSafeArea)
diff --git a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
index df40d3de3..6136bae7c 100644
--- a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
+++ b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
@@ -310,6 +310,13 @@ struct PaymentRequestAmountView: View {
     var testIdentifierPrefix = "PaymentRequest"
 
     @State private var amountViewModel = AmountInputViewModel()
+    @State private var asset: PaykitAsset = .btc
+    @State private var dollarAmount = ""
+    @State private var conversionError = false
+
+    private var amount: PaykitAmount? {
+        asset == .btc ? PaykitAmount(asset: .btc, atomic: amountViewModel.amountSats) : try? PaykitAmount(asset: .usd, value: dollarAmount)
+    }
 
     var body: some View {
         VStack(spacing: 0) {
@@ -320,41 +327,54 @@ struct PaymentRequestAmountView: View {
                 onBack: onBack
             )
 
-            NumberPadTextField(
-                viewModel: amountViewModel,
-                showEditButton: false,
-                isFocused: true,
-                testIdentifier: "\(testIdentifierPrefix)AmountField"
-            )
+            if asset == .usd {
+                NumberPadAmountText(value: dollarAmount.isEmpty ? "0" : dollarAmount, symbol: "$")
+                    .accessibilityIdentifier("\(testIdentifierPrefix)AmountField")
+            } else {
+                NumberPadTextField(viewModel: amountViewModel, showEditButton: false, isFocused: true,
+                                   testIdentifier: "\(testIdentifierPrefix)AmountField")
+            }
 
             Spacer()
 
             HStack {
                 Spacer()
-                NumberPadActionButton(
-                    text: currency.primaryDisplay == .bitcoin ? "Bitcoin" : currency.selectedCurrency,
-                    imageName: "arrow-up-down",
-                    color: .brandAccent
-                ) {
-                    withAnimation {
-                        amountViewModel.togglePrimaryDisplay(currency: currency)
+                ForEach([PaykitAsset.btc, .usd], id: \.self) { choice in
+                    NumberPadActionButton(text: choice.rawValue.uppercased(), color: choice == .usd ? .greenAccent : .brandAccent,
+                                          variant: asset == choice ? .primary : .secondary)
+                    {
+                        guard choice != asset else { return }
+                        do {
+                            if let current = amount, current.atomic > 0 {
+                                let converted = try current.converted(to: choice, rate: currency.paykitRate, at: Date())
+                                if choice == .usd { dollarAmount = converted.value }
+                                else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
+                            }
+                            asset = choice
+                            conversionError = false
+                        } catch { conversionError = true }
                     }
+                    .accessibilityIdentifier("\(testIdentifierPrefix)Asset-\(choice.rawValue)")
                 }
-                .accessibilityIdentifier("\(testIdentifierPrefix)AmountUnit")
             }
             .padding(.bottom, 12)
 
+            if conversionError {
+                BodySText(t("wallet__payment_request_rate_unavailable"), textColor: .white64)
+            }
             NumberPad(
-                type: amountViewModel.getNumberPadType(currency: currency),
+                type: asset == .usd ? .decimal : amountViewModel.getNumberPadType(currency: currency),
                 errorKey: amountViewModel.errorKey
             ) { key in
-                amountViewModel.handleNumberPadInput(key, currency: currency)
+                if asset == .usd { dollarAmount = NumberPadInputHandler.handleInput(key: key, current: dollarAmount, maxLength: 16, maxDecimals: 2) }
+                else { amountViewModel.handleNumberPadInput(key, currency: currency) }
             }
 
-            CustomButton(title: t("common__continue"), isDisabled: amountViewModel.amountSats == 0) {
+            CustomButton(title: t("common__continue"), isDisabled: (amount?.atomic ?? 0) == 0) {
+                guard let amount else { return }
                 onContinue(
                     PaykitPaymentRequestDraft(
-                        amountSats: amountViewModel.amountSats,
+                        amount: amount, acceptedPaymentEndpointIdentifiers: initialDraft.acceptedPaymentEndpointIdentifiers,
                         note: initialDraft.note,
                         expiresAt: initialDraft.expiresAt
                     )
@@ -366,7 +386,9 @@ struct PaymentRequestAmountView: View {
         .sheetBackground()
         .navigationBarHidden(true)
         .task {
-            amountViewModel.updateFromSats(initialDraft.amountSats, currency: currency)
+            asset = initialDraft.amount.asset == .btc ? .btc : .usd
+            if asset == .btc { amountViewModel.updateFromSats(initialDraft.amount.atomic, currency: currency) }
+            else { dollarAmount = initialDraft.amount.value }
         }
     }
 
@@ -393,6 +415,8 @@ struct PaymentRequestDetailsView: View {
     let onSent: (PaykitPaymentRequest) -> Void
 
     @State private var note = ""
+    @EnvironmentObject private var wallet: WalletViewModel
+    @State private var restrictedEndpoints: [String]?
     @State private var expiration = PaymentRequestExpiration.week
     @FocusState private var isNoteFocused: Bool
 
@@ -409,6 +433,7 @@ struct PaymentRequestDetailsView: View {
                     amount
                     noteInput
                     recipient
+                    acceptedMethods
                     expirationPicker
                 }
             }
@@ -416,6 +441,7 @@ struct PaymentRequestDetailsView: View {
             CustomButton(
                 title: t("wallet__payment_request_send_request"),
                 icon: Image("airplane").resizable().frame(width: 16, height: 16),
+                isDisabled: (restrictedEndpoints ?? enabledEndpoints).isEmpty,
                 isLoading: paymentRequests.isCreatingRequest
             ) {
                 await sendRequest()
@@ -428,6 +454,7 @@ struct PaymentRequestDetailsView: View {
         .navigationBarHidden(true)
         .interactiveDismissDisabled(paymentRequests.isCreatingRequest)
         .task {
+            restrictedEndpoints = initialDraft.acceptedPaymentEndpointIdentifiers
             note = initialDraft.note
             if initialDraft.expiresAt > Date() {
                 expiration = .closest(to: initialDraft.expiresAt, from: Date())
@@ -441,33 +468,51 @@ struct PaymentRequestDetailsView: View {
     }
 
     private var amount: some View {
+        Button { onEditAmount(currentDraft) } label: {
+            HStack(spacing: 8) {
+                if initialDraft.amount.asset == .btc {
+                    MoneyText(sats: Int(clamping: initialDraft.amount.atomic), unitType: .primary, size: .display,
+                              symbol: true, color: .textPrimary, symbolColor: .textSecondary)
+                } else { NumberPadAmountText(value: initialDraft.amount.value, symbol: "$") }
+                Image("pencil").resizable().frame(width: 24, height: 24).foregroundColor(.textPrimary)
+            }
+        }.buttonStyle(.plain)
+    }
+
+    private var enabledEndpoints: [String] {
+        PaykitPaymentRequestService.acceptedPaymentEndpointIdentifiers(canReceiveLightning: wallet.hasUsableChannels)
+    }
+
+    private var acceptedMethodGroups: [[PublicPaykitService.MethodId]] {
+        let groups: [[PublicPaykitService.MethodId]] = [
+            PublicPaykitService.MethodId.onchainPreferenceOrder,
+            [.bitcoinLightningBolt11, .bitcoinLightningLnurl],
+            [.usdtArbitrum],
+        ]
+        return groups.map { $0.filter { enabledEndpoints.contains($0.rawValue) } }.filter { !$0.isEmpty }
+    }
+
+    private var acceptedMethods: some View {
         VStack(alignment: .leading, spacing: 8) {
-            MoneyText(
-                sats: Int(clamping: initialDraft.amountSats),
-                unitType: .secondary,
-                size: .caption,
-                symbol: true,
-                color: .white64
-            )
-            Button {
-                onEditAmount(currentDraft)
-            } label: {
-                HStack(spacing: 8) {
-                    MoneyText(
-                        sats: Int(clamping: initialDraft.amountSats),
-                        unitType: .primary,
-                        size: .display,
-                        symbol: true,
-                        color: .textPrimary,
-                        symbolColor: .textSecondary
-                    )
-                    Image("pencil")
-                        .resizable()
-                        .frame(width: 24, height: 24)
-                        .foregroundColor(.textPrimary)
+            CaptionMText(t("wallet__payment_request_accepted_methods"), textColor: .white64)
+            HStack {
+                ForEach(acceptedMethodGroups, id: \.self) { methods in
+                    let endpoints = methods.map(\.rawValue)
+                    let usdt = methods.contains(.usdtArbitrum)
+                    let lightning = methods.contains(.bitcoinLightningBolt11) || methods.contains(.bitcoinLightningLnurl)
+                    let selected = restrictedEndpoints ?? enabledEndpoints
+                    let isSelected = endpoints.allSatisfy(selected.contains)
+                    NumberPadActionButton(text: usdt ? "USDT" : t(lightning ? "lightning__spending" : "lightning__savings").uppercased(),
+                                          color: usdt ? .greenAccent : lightning ? .purpleAccent : .brandAccent,
+                                          variant: isSelected ? .primary : .secondary)
+                    {
+                        restrictedEndpoints = isSelected
+                            ? selected.filter { !endpoints.contains($0) }
+                            : selected + endpoints.filter { !selected.contains($0) }
+                    }
+                    .accessibilityIdentifier("PaymentRequestAccept-\(usdt ? "usdt" : lightning ? "spending" : "savings")")
                 }
             }
-            .buttonStyle(.plain)
         }
     }
 
@@ -500,7 +545,8 @@ struct PaymentRequestDetailsView: View {
                     }
                 }
                 Spacer(minLength: 8)
-                MoneyCell(sats: Int(clamping: initialDraft.amountSats), prefix: "")
+                if initialDraft.amount.asset == .btc { MoneyCell(sats: Int(clamping: initialDraft.amount.atomic), prefix: "") }
+                else { BodyMSBText("$" + initialDraft.amount.value) }
             }
             .padding(16)
             .background(Color.gray6)
@@ -517,7 +563,7 @@ struct PaymentRequestDetailsView: View {
 
     private var currentDraft: PaykitPaymentRequestDraft {
         PaykitPaymentRequestDraft(
-            amountSats: initialDraft.amountSats,
+            amount: initialDraft.amount, acceptedPaymentEndpointIdentifiers: restrictedEndpoints,
             note: note.trimmingCharacters(in: .whitespacesAndNewlines),
             expiresAt: expiration.date(from: Date())
         )
diff --git a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
index 78b78be56..53b24790a 100644
--- a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
+++ b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
@@ -1,6 +1,16 @@
 import SwiftUI
 
 enum PaymentRequestDisplay {
+    static func status(for request: PaykitPaymentRequest, isActionable: Bool, receipt: PaykitUsdtPaymentService.Receipt?) -> String {
+        if request.direction == .outgoing, request.paymentProofKind == .usdt {
+            guard let receipt, receipt.proofEventId == request.paymentProofEventId else {
+                return t("wallet__payment_request_status_pending")
+            }
+            return receipt.statusText
+        }
+        return t(statusKey(for: request, isActionable: isActionable))
+    }
+
     static func paymentDirection(for request: PaykitPaymentRequest) -> PaykitPaymentRequest.Direction? {
         request.lifecycleState == .proofSubmitted ? request.direction : nil
     }
@@ -65,6 +75,10 @@ struct PaymentRequestCard: View {
 
     @State private var isRejecting = false
 
+    private var receipt: PaykitUsdtPaymentService.Receipt? {
+        PaykitUsdtPaymentService.shared.receipt(for: request)
+    }
+
     private var contact: PubkyContact? {
         contactsManager.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, request.counterparty) }
     }
@@ -171,21 +185,15 @@ struct PaymentRequestCard: View {
 
             Spacer(minLength: 8)
 
-            if let amountStatus {
+            if let amountStatus = receipt?.statusText ?? amountStatus ??
+                (request.direction == .outgoing && request.paymentProofKind == .usdt ? t("wallet__payment_request_status_pending") : nil)
+            {
                 VStack(alignment: .trailing, spacing: 2) {
-                    MoneyText(
-                        sats: Int(clamping: request.amountSats),
-                        unitType: .primary,
-                        size: .bodyMSB,
-                        symbol: showsAmountSymbol,
-                        prefix: amountPrefix,
-                        color: .textPrimary,
-                        symbolColor: .textSecondary
-                    )
+                    PaykitAmountText(amount: request.amount, prefix: amountPrefix)
                     CaptionText(amountStatus, textColor: .white64)
                 }
             } else {
-                MoneyCell(sats: Int(clamping: request.amountSats), prefix: amountPrefix, symbol: showsAmountSymbol)
+                PaykitAmountText(amount: request.amount, prefix: amountPrefix)
             }
         }
         .padding(16)
@@ -449,7 +457,8 @@ struct PaymentRequestsView: View {
     }
 
     private func status(for request: PaykitPaymentRequest) -> String {
-        t(PaymentRequestDisplay.statusKey(for: request, isActionable: isActionable(request)))
+        PaymentRequestDisplay.status(for: request, isActionable: isActionable(request),
+                                     receipt: PaykitUsdtPaymentService.shared.receipt(for: request))
     }
 
     @ViewBuilder
@@ -578,24 +587,14 @@ struct PaymentRequestDetailView: View {
         let paymentDirection = PaymentRequestDisplay.paymentDirection(for: request)
 
         return VStack(alignment: .leading, spacing: 8) {
-            MoneyText(
-                sats: Int(clamping: request.amountSats),
-                unitType: .secondary,
-                size: .caption,
-                symbol: true,
-                color: .white64
-            )
+            if request.amount.asset == .btc {
+                MoneyText(sats: Int(clamping: request.amount.atomic), unitType: .secondary, size: .caption,
+                          symbol: true, color: .white64)
+            }
             HStack(spacing: 16) {
-                MoneyText(
-                    sats: Int(clamping: request.amountSats),
-                    unitType: .primary,
-                    size: .display,
-                    symbol: true,
-                    prefix: paymentDirection == .incoming ? "-" : paymentDirection == .outgoing ? "+" : "",
-                    color: .textPrimary,
-                    symbolColor: .textSecondary
-                )
-                .accessibilityIdentifier("PaymentRequestDetailsAmount")
+                PaykitAmountText(amount: request.amount, size: .display,
+                                 prefix: paymentDirection == .incoming ? "-" : paymentDirection == .outgoing ? "+" : "")
+                    .accessibilityIdentifier("PaymentRequestDetailsAmount")
                 Spacer()
                 if let paymentDirection {
                     CircularIcon(
@@ -611,7 +610,8 @@ struct PaymentRequestDetailView: View {
                 }
             }
             BodyMText(
-                t(PaymentRequestDisplay.statusKey(for: request, isActionable: isActionable(request))),
+                PaymentRequestDisplay.status(for: request, isActionable: isActionable(request),
+                                             receipt: PaykitUsdtPaymentService.shared.receipt(for: request)),
                 textColor: .white64
             )
             .accessibilityIdentifier("PaymentRequestDetailsStatus")
@@ -725,3 +725,12 @@ private extension PaykitPaymentRequest {
             : (.brandAccent, .brand16)
     }
 }
+
+private extension PaykitUsdtPaymentService.Receipt {
+    var statusText: String {
+        let key = !verified ? "wallet__payment_request_status_pending" :
+            underpaid ? "wallet__payment_request_underpaid" :
+            afterExpiry ? "wallet__payment_request_after_expiry" : "wallet__payment_request_payment_verified"
+        return t(key) + " · " + amount.value + " USDT"
+    }
+}
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index ea2de51a3..115e72c8c 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -69,6 +69,7 @@ struct PubkyAuthApprovalSheetItem: SheetItem {
 // MARK: - Sheet View
 
 struct PubkyAuthApprovalSheet: View {
+    @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject private var app: AppViewModel
     @EnvironmentObject private var sheets: SheetViewModel
     @EnvironmentObject private var pubkyProfile: PubkyProfileManager
@@ -78,6 +79,9 @@ struct PubkyAuthApprovalSheet: View {
 
     @State private var state: ApprovalState
     @State private var isShowingAuthCheck = false
+    @State private var usdtAddress: String?
+    @State private var usdtUnavailable = false
+    @State private var showsUsdtAddress = false
 
     private var createsIdentity: Bool {
         Self.requiresIdentityCreation(for: config.request, profile: pubkyProfile)
@@ -114,7 +118,7 @@ struct PubkyAuthApprovalSheet: View {
     }
 
     static func initialState(for request: PubkyAuthRequest) -> ApprovalState {
-        request.bitkitClaim?.includesWatchOnlyAccount == true ? .watchOnlyConsent : .authorize
+        request.bitkitClaim?.sharesReceivingDetails == true ? .watchOnlyConsent : .authorize
     }
 
     static func requiresIdentityCreation(for request: PubkyAuthRequest, profile: PubkyProfileManager) -> Bool {
@@ -144,6 +148,7 @@ struct PubkyAuthApprovalSheet: View {
                 authorizationFlowContent
             }
         }
+        .task { await loadUsdtAddress() }
         .interactiveDismissDisabled(!state.canDismiss)
         .fullScreenCover(isPresented: $isShowingAuthCheck) {
             AuthCheck(
@@ -166,12 +171,12 @@ struct PubkyAuthApprovalSheet: View {
     private var watchOnlyConsentContent: some View {
         SheetIntro(
             navTitle: t("pubky_auth__watch_only_intro_nav_title"),
-            title: t("pubky_auth__watch_only_intro_title"),
+            title: t(introTitleKey),
             description: watchOnlyConsentDescription,
             image: "coin-stack-4",
             continueText: t("pubky_auth__watch_only_intro_approve"),
             cancelText: t("common__cancel"),
-            accentColor: .blueAccent,
+            accentColor: config.request.bitkitClaim == .usdtAddressV1 ? .greenAccent : .blueAccent,
             testID: "PubkyAuthWatchOnlyConsent",
             cancelTestID: "PubkyAuthWatchOnlyCancel",
             continueTestID: "PubkyAuthWatchOnlyApprove",
@@ -217,6 +222,7 @@ struct PubkyAuthApprovalSheet: View {
                 CustomButton(title: t("pubky_auth__title")) {
                     await onAuthorize()
                 }
+                .disabled(config.request.bitkitClaim?.sharesUsdt == true && usdtAddress == nil)
                 .accessibilityIdentifier("PubkyAuthAuthorize")
             }
         }
@@ -244,6 +250,11 @@ struct PubkyAuthApprovalSheet: View {
                         successDescriptionText
                             .padding(.horizontal, 16)
                             .padding(.bottom, 16)
+                        if config.request.bitkitClaim?.sharesReceivingDetails == true {
+                            BodyMText(t(sharingSuccessKey))
+                                .accessibilityIdentifier("PubkyAuthSharedDetails")
+                                .padding(.horizontal, 16)
+                        }
 
                         Spacer(minLength: 0)
 
@@ -289,6 +300,10 @@ struct PubkyAuthApprovalSheet: View {
                             .padding(.bottom, 32)
                     }
 
+                    if config.request.bitkitClaim?.sharesReceivingDetails == true {
+                        paymentDetailsSection
+                            .padding(.bottom, 24)
+                    }
                     if !config.request.permissions.isEmpty {
                         permissionsSection
                     }
@@ -352,8 +367,84 @@ struct PubkyAuthApprovalSheet: View {
         .lineSpacing(4)
     }
 
+    private var introTitleKey: String {
+        switch config.request.bitkitClaim {
+        case .usdtAddressV1: "pubky_auth__usdt_intro_title"
+        case .paymentDetailsV1: "pubky_auth__payment_details_intro_title"
+        default: "pubky_auth__watch_only_intro_title"
+        }
+    }
+
+    private var introDescriptionKey: String {
+        switch config.request.bitkitClaim {
+        case .usdtAddressV1: "pubky_auth__usdt_intro_description"
+        case .paymentDetailsV1: "pubky_auth__payment_details_intro_description"
+        default: "pubky_auth__watch_only_intro_description"
+        }
+    }
+
+    private var sharingSuccessKey: String {
+        switch config.request.bitkitClaim {
+        case .usdtAddressV1: "pubky_auth__shared_usdt"
+        case .paymentDetailsV1: "pubky_auth__shared_both"
+        default: "pubky_auth__shared_bitcoin"
+        }
+    }
+
+    private var paymentDetailsSection: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            CaptionMText(t("pubky_auth__payment_details"), textColor: .white64)
+            if config.request.bitkitClaim?.sharesBitcoin == true {
+                VStack(alignment: .leading, spacing: 4) {
+                    BodySSBText("Bitcoin", textColor: .brandAccent)
+                    BodySText(t("pubky_auth__bitcoin_account"), textColor: .white64)
+                }
+                .accessibilityIdentifier("PubkyAuthBitcoinDetails")
+            }
+            if config.request.bitkitClaim?.sharesUsdt == true {
+                VStack(alignment: .leading, spacing: 8) {
+                    BodySSBText("USDT · Arbitrum One", textColor: .greenAccent)
+                    if let usdtAddress {
+                        Button { showsUsdtAddress.toggle() } label: {
+                            BodySText(showsUsdtAddress ? usdtAddress : String(usdtAddress.prefix(8)) + "…" + String(usdtAddress.suffix(6)))
+                                .multilineTextAlignment(.leading)
+                        }
+                        .accessibilityIdentifier("PubkyAuthUsdtAddress")
+                        if showsUsdtAddress {
+                            Button(t("common__copy")) { UIPasteboard.general.string = usdtAddress }
+                                .tint(.greenAccent)
+                                .accessibilityIdentifier("PubkyAuthCopyUsdtAddress")
+                        }
+                    } else if usdtUnavailable {
+                        BodySText(t("pubky_auth__usdt_unavailable"), textColor: .white64)
+                        Button(t("common__retry")) { Task { await loadUsdtAddress() } }
+                            .tint(.greenAccent)
+                    } else {
+                        ProgressView()
+                    }
+                    BodySText(t("pubky_auth__usdt_privacy"), textColor: .white64)
+                }
+                .accessibilityElement(children: .contain)
+                .accessibilityIdentifier("PubkyAuthUsdtDetails")
+            }
+            CustomDivider(color: .white10)
+        }
+    }
+
+    private func loadUsdtAddress() async {
+        guard config.request.bitkitClaim?.sharesUsdt == true else { return }
+        usdtAddress = nil
+        usdtUnavailable = false
+        do {
+            usdtAddress = try await usdt.paymentEndpoint().value
+        } catch {
+            usdtAddress = nil
+            usdtUnavailable = true
+        }
+    }
+
     private var watchOnlyConsentDescription: String {
-        let description = t("pubky_auth__watch_only_intro_description")
+        let description = t(introDescriptionKey)
         guard let relayOrigin = config.request.relayOrigin else { return description }
 
         return description + "\n\n" + t(
@@ -518,7 +609,9 @@ struct PubkyAuthApprovalSheet: View {
                 request: config.request,
                 authUrl: config.request.rawUrl,
                 accountName: watchOnlyAccountName,
-                secretKeyHex: secretKey
+                secretKeyHex: secretKey,
+                approvedUsdtAddress: usdtAddress,
+                usdtEndpoint: { try await usdt.paymentEndpoint() }
             )
 
             state = .success
@@ -555,7 +648,7 @@ struct PubkyAuthApprovalSheet: View {
 
     private func onBack() {
         guard state.canDismiss else { return }
-        if state == .authorize, config.request.bitkitClaim?.includesWatchOnlyAccount == true {
+        if state == .authorize, config.request.bitkitClaim?.sharesReceivingDetails == true {
             state = .watchOnlyConsent
         } else {
             sheets.hideSheet()
diff --git a/Bitkit/Views/Sheets/Sheet.swift b/Bitkit/Views/Sheets/Sheet.swift
index 79cffdd4b..6bfbbfc28 100644
--- a/Bitkit/Views/Sheets/Sheet.swift
+++ b/Bitkit/Views/Sheets/Sheet.swift
@@ -148,7 +148,8 @@ struct Sheet<Content: View>: View {
                 .padding(.top, 12)
         }
         .presentationBackgroundInteraction(.disabled)
-        .presentationDetents([.height(sheetSize.height)])
+        // The system adds the bottom safe area to a fixed-height detent.
+        .presentationDetents([.height(sheetSize.height - windowSafeAreaInsets.bottom)])
         .presentationDragIndicator(.hidden)
         .presentationCornerRadius(32)
         .presentationBackground { backgroundColor }
diff --git a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
index 0bf9eca63..bed558168 100644
--- a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
+++ b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
@@ -3,6 +3,7 @@ import SwiftUI
 
 struct CreateSubscriptionView: View {
     @EnvironmentObject private var app: AppViewModel
+    @EnvironmentObject private var wallet: WalletViewModel
 
     @Binding var draft: PaykitSubscriptionDraft
     let onEditAmount: () -> Void
@@ -29,6 +30,7 @@ struct CreateSubscriptionView: View {
                     ScrollView(showsIndicators: false) {
                         VStack(alignment: .leading, spacing: 24) {
                             amount
+                            acceptedMethods
                             frequency
                             name
                             description
@@ -49,9 +51,9 @@ struct CreateSubscriptionView: View {
 
             CustomButton(
                 title: t("subscriptions__choose_recipient"),
-                isDisabled: draft.amountSats == 0 ||
+                isDisabled: draft.amount.atomic == 0 ||
                     draft.name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ||
-                    isLoadingIcon
+                    isLoadingIcon || acceptedEndpoints.isEmpty
             ) {
                 onChooseRecipient()
             }
@@ -83,8 +85,8 @@ struct CreateSubscriptionView: View {
             CaptionMText(t("wallet__payment_request_amount").localizedUppercase, textColor: .white64)
             Button(action: onEditAmount) {
                 HStack(spacing: 8) {
-                    MoneyText(
-                        sats: Int(clamping: draft.amountSats),
+                    if draft.amount.asset == .btc { MoneyText(
+                        sats: Int(clamping: draft.amount.atomic),
                         unitType: .primary,
                         size: .display,
                         symbol: true,
@@ -94,6 +96,7 @@ struct CreateSubscriptionView: View {
                     )
                     .lineLimit(1)
                     .minimumScaleFactor(0.5)
+                    } else { NumberPadAmountText(value: draft.amount.value, symbol: "$") }
                     Image("pencil")
                         .resizable()
                         .frame(width: 24, height: 24)
@@ -105,6 +108,35 @@ struct CreateSubscriptionView: View {
         }
     }
 
+    private var acceptedEndpoints: [String] {
+        PaykitRequestPricing.subscriptionEndpoints(
+            requested: draft.amount.asset,
+            available: PaykitPaymentRequestService.acceptedPaymentEndpointIdentifiers(canReceiveLightning: wallet.hasUsableChannels)
+        )
+    }
+
+    private var acceptedMethods: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            CaptionMText(t("wallet__payment_request_accepted_methods"), textColor: .white64)
+            HStack(spacing: 16) {
+                if acceptedEndpoints.contains(PublicPaykitService.MethodId.usdtArbitrum.rawValue) {
+                    BodyMSBText("USDT", textColor: .greenAccent)
+                }
+                if acceptedEndpoints.contains(where: { PublicPaykitService.MethodId(rawValue: $0)?.onchainNetwork != nil }) {
+                    BodyMSBText(t("lightning__savings"), textColor: .brandAccent)
+                }
+                if acceptedEndpoints.contains(PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue) {
+                    BodyMSBText(t("lightning__spending"), textColor: .purpleAccent)
+                }
+                if acceptedEndpoints.isEmpty {
+                    BodySText(t("wallet__payment_request_status_unavailable"), textColor: .white64)
+                }
+            }
+        }
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("SubscriptionAcceptedMethods")
+    }
+
     private var frequency: some View {
         VStack(alignment: .leading, spacing: 8) {
             CaptionMText(t("subscriptions__frequency").localizedUppercase, textColor: .white64)
@@ -197,15 +229,15 @@ struct CreateSubscriptionView: View {
 }
 
 struct SubscriptionAmountView: View {
-    let initialAmountSats: UInt64
+    let initialAmount: PaykitAmount
     let onBack: () -> Void
-    let onContinue: (UInt64) -> Void
+    let onContinue: (PaykitAmount) -> Void
 
     var body: some View {
         PaymentRequestAmountView(
-            initialDraft: PaykitPaymentRequestDraft(amountSats: initialAmountSats, note: "", expiresAt: .distantFuture),
+            initialDraft: PaykitPaymentRequestDraft(amount: initialAmount, note: "", expiresAt: .distantFuture),
             target: nil,
-            onContinue: { onContinue($0.amountSats) },
+            onContinue: { onContinue($0.amount) },
             onBack: onBack,
             // Android tags this step PaymentRequest* on the subscription flow too; the journeys
             // share the vocabulary, so keep the odd-reading prefix rather than diverging.
diff --git a/Bitkit/Views/Subscriptions/SubscriptionsView.swift b/Bitkit/Views/Subscriptions/SubscriptionsView.swift
index 7ac8e7f1a..cc275303d 100644
--- a/Bitkit/Views/Subscriptions/SubscriptionsView.swift
+++ b/Bitkit/Views/Subscriptions/SubscriptionsView.swift
@@ -180,16 +180,11 @@ struct SubscriptionsView: View {
     private var metrics: some View {
         HStack(spacing: 16) {
             SubscriptionMetric(title: t("subscriptions__monthly_cost"), icon: "calendar") {
-                MoneyText(
-                    sats: monthlyCostSats,
-                    unitType: .primary,
-                    size: .bodyMSB,
-                    symbol: true,
-                    color: .textPrimary,
-                    symbolColor: .textSecondary
-                )
-                .lineLimit(1)
-                .minimumScaleFactor(0.5)
+                VStack(alignment: .leading, spacing: 4) {
+                    ForEach(subscriptionMonthlyCosts(subscriptions: paymentRequests.subscriptions, now: now), id: \.asset) { amount in
+                        PaykitAmountText(amount: amount).lineLimit(1).minimumScaleFactor(0.5)
+                    }
+                }
             }
             .frame(maxWidth: .infinity, alignment: .leading)
             Rectangle()
@@ -230,13 +225,9 @@ struct SubscriptionsView: View {
             }
         }
     }
-
-    private var monthlyCostSats: Int {
-        subscriptionMonthlyCostSats(subscriptions: paymentRequests.subscriptions, now: now)
-    }
 }
 
-func subscriptionMonthlyCostSats(subscriptions: [PaykitSubscription], now: Date) -> Int {
+func subscriptionMonthlyCosts(subscriptions: [PaykitSubscription], now: Date) -> [PaykitAmount] {
     let annualPeriods: (PaykitSubscriptionRecurrence.Unit) -> Decimal = { unit in
         switch unit {
         case .minute: 525_600
@@ -247,14 +238,20 @@ func subscriptionMonthlyCostSats(subscriptions: [PaykitSubscription], now: Date)
         case .year: 1
         }
     }
-    let maximum = NSDecimalNumber(value: Int.max)
-    return subscriptions.filter { $0.isPayer && $0.runsUntilPaidThrough(at: now) }.reduce(into: 0) { total, subscription in
-        var monthlyCost = Decimal(subscription.amountSats) * annualPeriods(subscription.recurrence.unit)
-            / Decimal(subscription.recurrence.every) / 12
-        var roundedMonthlyCost = Decimal()
-        NSDecimalRound(&roundedMonthlyCost, &monthlyCost, 0, .plain)
-        let number = NSDecimalNumber(decimal: roundedMonthlyCost)
-        total = total.saturatingAdd(number.compare(maximum) == .orderedDescending ? .max : number.intValue)
+    let active = subscriptions.filter { $0.isPayer && $0.runsUntilPaidThrough(at: now) }
+    let assets = Set(active.map(\.amount.asset))
+    return (assets.isEmpty ? [.btc] : PaykitAsset.allCases.filter { assets.contains($0) }).map { asset in
+        var total: UInt64 = 0
+        for subscription in active where subscription.amount.asset == asset {
+            var monthlyCost = Decimal(subscription.amount.atomic) * annualPeriods(subscription.recurrence.unit)
+                / Decimal(subscription.recurrence.every) / 12
+            var rounded = Decimal()
+            NSDecimalRound(&rounded, &monthlyCost, 0, .plain)
+            let amount = rounded > Decimal(UInt64.max) ? UInt64.max : NSDecimalNumber(decimal: rounded).uint64Value
+            let addition = total.addingReportingOverflow(amount)
+            total = addition.overflow ? .max : addition.partialValue
+        }
+        return PaykitAmount(asset: asset, atomic: total)
     }
 }
 
@@ -327,7 +324,7 @@ struct SubscriptionRow: View {
 
             Spacer(minLength: 8)
 
-            MoneyCell(sats: Int(clamping: subscription.amountSats), prefix: "", symbol: true)
+            PaykitAmountText(amount: subscription.amount)
         }
         .padding(16)
         .background(Color.gray6)
@@ -397,14 +394,7 @@ struct SubscriptionDetailView: View {
                         VStack(alignment: .leading, spacing: 16) {
                             CaptionMText(subscription.recurrence.cadenceLabel.localizedUppercase, textColor: .white64)
                             HStack(spacing: 16) {
-                                MoneyText(
-                                    sats: Int(clamping: subscription.amountSats),
-                                    unitType: .primary,
-                                    size: .display,
-                                    symbol: true,
-                                    color: .textPrimary,
-                                    symbolColor: .textSecondary
-                                )
+                                PaykitAmountText(amount: subscription.amount, size: .display)
                                 Spacer()
                                 SubscriptionAvatar(subscription: subscription, size: 48)
                             }
@@ -467,7 +457,7 @@ struct SubscriptionDetailView: View {
                 )
                 LabeledDetailCell(
                     title: t("subscriptions__payments"),
-                    value: "\(subscription.payments.count)",
+                    value: "\(subscription.paidPeriods.count)",
                     icon: "coins"
                 )
             }
@@ -581,10 +571,10 @@ struct SubscriptionSheet: View {
                 )
             case .createAmount:
                 SubscriptionAmountView(
-                    initialAmountSats: creationDraft.amountSats,
+                    initialAmount: creationDraft.amount,
                     onBack: { route = .create },
                     onContinue: {
-                        creationDraft.amountSats = $0
+                        creationDraft.amount = $0
                         route = .create
                     }
                 )
@@ -667,7 +657,7 @@ struct SubscriptionSheet: View {
                 BodyMText(t("subscriptions__unsupported_description"), textColor: .white64)
                     .frame(maxWidth: .infinity, alignment: .leading)
                     .padding(.top, 16)
-            } else if subscription.hasPaymentDeadline || subscription.acceptedPaymentEndpointIdentifiers.isEmpty {
+            } else if subscription.acceptedPaymentEndpointIdentifiers.isEmpty {
                 BodyMText(t("subscriptions__unsupported_payment_description"), textColor: .white64)
                     .frame(maxWidth: .infinity, alignment: .leading)
                     .padding(.top, 16)
@@ -732,7 +722,7 @@ struct SubscriptionSheet: View {
             try showInitialPaymentFailure(dueRequest, error: error)
             return
         }
-        guard case let .opened(paymentTarget, privatePaymentContext) = resolution else {
+        guard case let .opened(paymentTarget, privatePaymentContext, endpoints) = resolution else {
             try showInitialPaymentFailure(dueRequest, error: PaykitPaymentRequestError.requestUnavailable)
             return
         }
@@ -742,7 +732,7 @@ struct SubscriptionSheet: View {
             publicKey: dueRequest.counterparty,
             privatePaymentContext: privatePaymentContext,
             incomingPaymentRequest: dueRequest,
-            isInitialSubscriptionPayment: true
+            isInitialSubscriptionPayment: true, endpoints: endpoints
         )
         guard app.claimContactPaymentContext(context) else {
             throw PaykitPaymentRequestError.operationInProgress
@@ -783,7 +773,7 @@ struct SubscriptionSheet: View {
             return
         }
 
-        let sendRoute: SendRoute = app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
+        let sendRoute: SendRoute = context.requiresAssetSelection ? .amount : app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
         route = .payment(sendRoute)
     }
 
@@ -948,7 +938,7 @@ private struct SubscriptionAmountHeader: View {
     let subscription: PaykitSubscription
 
     var body: some View {
-        MoneyStack(sats: Int(clamping: subscription.amountSats), showSymbol: true)
+        PaykitAmountText(amount: subscription.amount, size: .display)
             .padding(.bottom, 20)
     }
 }
@@ -1082,10 +1072,10 @@ extension PaykitSubscription {
                     : t("subscriptions__proposal_queued_status")
             }
             if isActive(at: now) {
-                let key = payments.count == 1
+                let key = paidPeriods.count == 1
                     ? "subscriptions__created_summary_single_payment"
                     : "subscriptions__created_summary"
-                return t(key, variables: ["count": "\(payments.count)"])
+                return t(key, variables: ["count": "\(paidPeriods.count)"])
             }
         }
         if isProposalVisible(at: now) || !recurrence.unit.isSupported {
diff --git a/Bitkit/Views/Wallets/Activity/ActivityRow.swift b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
index 6e8f83952..ea59a2f0b 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityRow.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
@@ -62,7 +62,7 @@ struct ActivityRow: View {
     }
 
     var body: some View {
-        Group {
+        ActivityRowContainer {
             switch item {
             case let .lightning(activity):
                 ActivityRowLightning(item: activity, contact: rowContactAvatar, titleOverride: rowTitleOverride)
@@ -70,8 +70,33 @@ struct ActivityRow: View {
                 ActivityRowOnchain(item: activity, feeEstimates: feeEstimates, contact: rowContactAvatar, titleOverride: rowTitleOverride)
             }
         }
-        .padding(16)
-        .background(Color.gray6)
-        .cornerRadius(16)
+    }
+}
+
+struct ActivityRowContainer<Content: View>: View {
+    @ViewBuilder var content: () -> Content
+
+    var body: some View {
+        content().padding(16).background(Color.gray6).cornerRadius(16)
+    }
+}
+
+struct ActivityRowContent<Icon: View, Amount: View>: View {
+    let title: String
+    let subtitle: String
+    @ViewBuilder var icon: () -> Icon
+    @ViewBuilder var amount: () -> Amount
+
+    var body: some View {
+        HStack(spacing: 16) {
+            icon()
+            VStack(alignment: .leading, spacing: 2) {
+                BodyMSBText(title).lineLimit(1)
+                CaptionBText(subtitle).lineLimit(1)
+            }
+            .fixedSize(horizontal: false, vertical: true)
+            Spacer(minLength: 0)
+            amount()
+        }
     }
 }
diff --git a/Bitkit/Views/Wallets/Activity/ActivityRowLightning.swift b/Bitkit/Views/Wallets/Activity/ActivityRowLightning.swift
index de2ee65b0..ecb73b92f 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityRowLightning.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityRowLightning.swift
@@ -48,20 +48,13 @@ struct ActivityRowLightning: View {
     }
 
     var body: some View {
-        HStack(spacing: 16) {
+        ActivityRowContent(title: status, subtitle: description) {
             if let contact {
                 PubkyContactAvatar(contact: contact, size: 40)
             } else {
                 ActivityIcon(activity: .lightning(item), size: 40, context: .row)
             }
-
-            VStack(alignment: .leading, spacing: 2) {
-                BodyMSBText(status).lineLimit(1)
-                CaptionBText(description).lineLimit(1)
-            }
-
-            Spacer()
-
+        } amount: {
             MoneyCell(sats: amount, prefix: amountPrefix, enableHide: true)
         }
     }
diff --git a/Bitkit/Views/Wallets/Activity/ActivityRowOnchain.swift b/Bitkit/Views/Wallets/Activity/ActivityRowOnchain.swift
index 4bca724ca..8cb6b68d5 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityRowOnchain.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityRowOnchain.swift
@@ -79,21 +79,13 @@ struct ActivityRowOnchain: View {
     }
 
     var body: some View {
-        HStack(spacing: 16) {
+        ActivityRowContent(title: status, subtitle: description) {
             if let contact {
                 PubkyContactAvatar(contact: contact, size: 40)
             } else {
                 ActivityIcon(activity: .onchain(item), size: 40, isCpfpChild: isCpfpChild, context: .row)
             }
-
-            VStack(alignment: .leading, spacing: 2) {
-                BodyMSBText(status).lineLimit(1)
-                CaptionBText(description).lineLimit(1)
-            }
-            .fixedSize(horizontal: false, vertical: true)
-
-            Spacer()
-
+        } amount: {
             MoneyCell(sats: amount, prefix: amountPrefix, enableHide: true)
         }
         .task {
diff --git a/Bitkit/Views/Wallets/Receive/ReceiveEdit.swift b/Bitkit/Views/Wallets/Receive/ReceiveEdit.swift
index 30ab2696d..53cc9a914 100644
--- a/Bitkit/Views/Wallets/Receive/ReceiveEdit.swift
+++ b/Bitkit/Views/Wallets/Receive/ReceiveEdit.swift
@@ -108,7 +108,7 @@ struct ReceiveEdit: View {
                         ) {
                             onSendPaymentRequest(
                                 PaykitPaymentRequestDraft(
-                                    amountSats: amountSats,
+                                    amount: PaykitAmount(asset: .btc, atomic: amountSats),
                                     note: note.trimmingCharacters(in: .whitespacesAndNewlines),
                                     expiresAt: PaymentRequestExpiration.week.date(from: .now)
                                 )
diff --git a/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift b/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
index a2cdce5e1..af1a88384 100644
--- a/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
+++ b/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
@@ -2,6 +2,7 @@ import BitkitCore
 import SwiftUI
 
 enum ReceiveRoute: Hashable {
+    case usdt
     case qr(cjitInvoice: String?, tab: ReceiveQr.ReceiveTab?)
     case edit(tab: ReceiveQr.ReceiveTab, onchainOnly: Bool, replacesCurrentQr: Bool = false)
     case tag
@@ -19,7 +20,7 @@ enum ReceiveRoute: Hashable {
         switch self {
         case .qr, .edit, .tag, .cjitAmount, .cjitConfirm, .cjitLearnMore, .cjitGeoBlocked:
             return true
-        case .requestOrPay, .paymentRequestRecipient, .paymentRequestAmount, .paymentRequestDetails, .paymentRequestSent:
+        case .usdt, .requestOrPay, .paymentRequestRecipient, .paymentRequestAmount, .paymentRequestDetails, .paymentRequestSent:
             return false
         }
     }
@@ -58,6 +59,14 @@ struct ReceiveSheet: View {
     @State private var navigationPath: [ReceiveRoute] = []
 
     var body: some View {
+        if config.initialRoute == .usdt {
+            Sheet(id: .receive, data: config) { UsdtReceiveView() }
+        } else {
+            bitcoinReceiveSheet
+        }
+    }
+
+    private var bitcoinReceiveSheet: some View {
         Sheet(id: .receive, data: config) {
             NavigationStack(path: $navigationPath) {
                 viewForRoute(config.initialRoute)
@@ -101,6 +110,7 @@ struct ReceiveSheet: View {
     @ViewBuilder
     private func viewForRoute(_ route: ReceiveRoute) -> some View {
         switch route {
+        case .usdt: EmptyView()
         case let .qr(cjitInvoice, tab):
             ReceiveQr(
                 navigationPath: $navigationPath,
@@ -128,7 +138,7 @@ struct ReceiveSheet: View {
             }
         case let .paymentRequestRecipient(draft):
             PaymentRequestRecipientView { target in
-                if draft.amountSats == 0 {
+                if draft.amount.atomic == 0 {
                     navigationPath.append(.paymentRequestAmount(draft, target))
                 } else {
                     navigationPath.append(.paymentRequestDetails(draft, target))
@@ -164,7 +174,7 @@ struct ReceiveSheet: View {
 
     static var defaultPaymentRequestDraft: PaykitPaymentRequestDraft {
         PaykitPaymentRequestDraft(
-            amountSats: 0,
+            amount: PaykitAmount(asset: .btc, atomic: 0),
             note: "",
             expiresAt: PaymentRequestExpiration.week.date(from: Date())
         )
diff --git a/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift b/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
index 5da9557c6..1819d768d 100644
--- a/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
+++ b/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
@@ -287,7 +287,8 @@ struct LnurlPayConfirm: View {
                     request: incomingPaymentRequest,
                     paymentAppId: privateContext.paymentAppId(for: endpointIdentifier),
                     paymentEndpointIdentifier: endpointIdentifier,
-                    kind: .lightning
+                    kind: .lightning,
+                    paymentTerms: app.paykitPaymentTerms
                 )
                 shouldCancelPaymentProof = true
             }
@@ -397,8 +398,8 @@ struct LnurlPayConfirm: View {
         }
         guard app.ownsContactPaymentContext(context) else { throw PaykitPaymentRequestError.requestUnavailable }
         guard let amountSats = wallet.sendAmountSats,
-              request.acceptsPaymentAmount(amountSats),
-              request.acceptsLightningInvoiceAmount(milliSatoshis: amountMsats)
+              request.acceptsPaymentAmount(amountSats, paymentTerms: app.paykitPaymentTerms),
+              request.acceptsLightningInvoiceAmount(milliSatoshis: amountMsats, paymentTerms: app.paykitPaymentTerms)
         else {
             throw PaykitPaymentRequestError.amountMismatch
         }
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index 65d2d449f..54c31e06a 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -3,6 +3,7 @@ import SwiftUI
 enum SendFundingSource: Equatable {
     case spending
     case savings
+    case usdt
     case hardware(walletId: String)
 }
 
@@ -11,6 +12,8 @@ struct SendAmountView: View {
     @EnvironmentObject var currency: CurrencyViewModel
     @EnvironmentObject var settings: SettingsViewModel
     @EnvironmentObject var wallet: WalletViewModel
+    @Environment(PaykitPaymentRequestManager.self) private var paymentRequests
+    @Environment(UsdtWalletManager.self) private var usdt
     @Environment(HwWalletManager.self) private var hwWalletManager
 
     @Binding var navigationPath: [SendRoute]
@@ -20,14 +23,18 @@ struct SendAmountView: View {
     @State private var maxSendableAmount: UInt64?
     @State private var routingFee: UInt64 = 0
     @State private var isContinuing = false
+    @State private var usdtAmount = ""
+    @State private var conversionError: String?
 
     var amountSats: UInt64 {
         amountViewModel.amountSats
     }
 
     private var fundingSources: [SendFundingSource] {
+        if let request = app.contactPaymentContext?.incomingPaymentRequest,
+           PaykitUsdtPaymentService.shared.hasBinding(for: request.id) { return [.usdt] }
         var sources: [SendFundingSource] = []
-        if app.scannedLightningInvoice != nil {
+        if app.scannedLightningInvoice != nil || app.lnurlPayData != nil {
             sources.append(.spending)
         }
         if app.scannedOnchainInvoice != nil {
@@ -39,10 +46,12 @@ struct SendAmountView: View {
                 return .hardware(walletId: hardwareWallet.walletId)
             })
         }
+        if app.contactPaymentContext?.endpoints.contains(where: { $0.methodId == .usdtArbitrum }) == true { sources.append(.usdt) }
         return sources
     }
 
     private var selectedFundingSource: SendFundingSource {
+        if app.paykitUsesUsdt { return .usdt }
         if let walletId = hwSend.walletId {
             return .hardware(walletId: walletId)
         }
@@ -59,6 +68,7 @@ struct SendAmountView: View {
             t("wallet__spending__title")
         case .savings:
             t("wallet__savings__title")
+        case .usdt: "USDT"
         case let .hardware(walletId):
             hwWalletManager.wallets.first(where: { $0.id == walletId })?.name
                 ?? hwWalletManager.vendor(walletId: walletId).modelName
@@ -69,6 +79,7 @@ struct SendAmountView: View {
         switch selectedFundingSource {
         case .spending: .purpleAccent
         case .savings: .brandAccent
+        case .usdt: .greenAccent
         case .hardware: .blueAccent
         }
     }
@@ -80,6 +91,7 @@ struct SendAmountView: View {
         return switch selectedFundingSource {
         case .spending: "spending"
         case .savings: "savings"
+        case .usdt: "usdt"
         case .hardware: "trezor"
         }
     }
@@ -100,6 +112,9 @@ struct SendAmountView: View {
     }
 
     private var isValidAmount: Bool {
+        if app.paykitUsesUsdt {
+            return (try? PaykitAmount(asset: .usdt, value: usdtAmount)).map { $0.atomic > 0 && $0.atomic <= (usdt.balance ?? 0) } ?? false
+        }
         let minAmount = app.selectedWalletToPayFrom == .lightning ? 1 : Env.dustLimit
 
         return amountSats >= minAmount && amountSats <= availableAmount
@@ -107,7 +122,7 @@ struct SendAmountView: View {
 
     /// Determines if the current amount is a max amount send
     var isMaxAmountSend: Bool {
-        guard app.selectedWalletToPayFrom == .onchain else { return false }
+        guard app.selectedWalletToPayFrom == .onchain, app.contactPaymentContext?.incomingPaymentRequest == nil else { return false }
         return amountSats == availableAmount && amountSats > 0
     }
 
@@ -120,32 +135,44 @@ struct SendAmountView: View {
             )
 
             VStack(alignment: .leading, spacing: 0) {
-                NumberPadTextField(viewModel: amountViewModel, testIdentifier: "SendNumberField")
-                    .onTapGesture {
-                        amountViewModel.togglePrimaryDisplay(currency: currency)
-                    }
+                if app.paykitUsesUsdt {
+                    NumberPadAmountText(value: usdtAmount.isEmpty ? "0" : usdtAmount, symbol: "₮")
+                        .accessibilityIdentifier("SendNumberField")
+                } else {
+                    NumberPadTextField(viewModel: amountViewModel, testIdentifier: "SendNumberField")
+                        .onTapGesture { amountViewModel.togglePrimaryDisplay(currency: currency) }
+                }
+                if let conversionError { BodySText(conversionError, textColor: .brandAccent).padding(.top, 12) }
 
                 Spacer()
 
                 // Available balance section
                 HStack(alignment: .bottom) {
-                    AvailableAmount(
-                        label: t("wallet__send_available"),
-                        amount: Int(availableAmount),
-                        testIdentifier: "AvailableAmount"
-                    )
-                    .onTapGesture {
-                        amountViewModel.updateFromSats(availableAmount, currency: currency)
-
-                        if app.selectedWalletToPayFrom == .lightning {
-                            app.toast(
-                                type: .info,
-                                title: t("wallet__send_max_spending__title"),
-                                description: t("wallet__send_max_spending__description")
-                            )
+                    if app.paykitUsesUsdt {
+                        VStack(alignment: .leading, spacing: 4) {
+                            CaptionMText(t("wallet__send_available"))
+                            BodySSBText((settings.hideBalance ? "•••••" : usdt.balance.map { PaykitAmount(asset: .usdt, atomic: $0).value } ?? "—") +
+                                " USDT")
+                        }
+                    } else {
+                        AvailableAmount(
+                            label: t("wallet__send_available"),
+                            amount: Int(availableAmount),
+                            testIdentifier: "AvailableAmount"
+                        )
+                        .onTapGesture {
+                            guard app.contactPaymentContext?.incomingPaymentRequest == nil else { return }
+                            amountViewModel.updateFromSats(availableAmount, currency: currency)
+
+                            if app.selectedWalletToPayFrom == .lightning {
+                                app.toast(
+                                    type: .info,
+                                    title: t("wallet__send_max_spending__title"),
+                                    description: t("wallet__send_max_spending__description")
+                                )
+                            }
                         }
                     }
-
                     Spacer()
 
                     NumberPadActionButton(
@@ -160,31 +187,39 @@ struct SendAmountView: View {
                     }
                     .accessibilityIdentifier("AssetButton-\(assetButtonTestIdentifier)")
 
-                    NumberPadActionButton(
-                        text: currency.primaryDisplay == .bitcoin ? "Bitcoin" : currency.selectedCurrency,
-                        imageName: "arrow-up-down",
-                        color: .brandAccent
-                    ) {
-                        withAnimation {
-                            amountViewModel.togglePrimaryDisplay(currency: currency)
+                    if !app.paykitUsesUsdt {
+                        NumberPadActionButton(
+                            text: currency.primaryDisplay == .bitcoin ? "Bitcoin" : currency.selectedCurrency,
+                            imageName: "arrow-up-down",
+                            color: .brandAccent
+                        ) {
+                            withAnimation {
+                                amountViewModel.togglePrimaryDisplay(currency: currency)
+                            }
                         }
+                        .accessibilityIdentifier("SendNumberPadUnit")
                     }
-                    .accessibilityIdentifier("SendNumberPadUnit")
                 }
                 .padding(.bottom, 12)
 
                 Divider()
 
                 NumberPad(
-                    type: amountViewModel.getNumberPadType(currency: currency),
-                    errorKey: amountViewModel.errorKey
+                    type: app.paykitUsesUsdt ? .decimal : amountViewModel.getNumberPadType(currency: currency),
+                    errorKey: amountViewModel.errorKey,
+                    isDisabled: app.contactPaymentContext?.incomingPaymentRequest != nil
                 ) { key in
-                    amountViewModel.handleNumberPadInput(key, currency: currency)
+                    if app.paykitUsesUsdt { usdtAmount = NumberPadInputHandler.handleInput(
+                        key: key,
+                        current: usdtAmount,
+                        maxLength: 21,
+                        maxDecimals: 6
+                    ) } else { amountViewModel.handleNumberPadInput(key, currency: currency) }
                 }
 
                 CustomButton(
                     title: t("common__continue"),
-                    isDisabled: !isValidAmount || hwSend.isFundingSourceLoading,
+                    isDisabled: !isValidAmount || conversionError != nil || hwSend.isFundingSourceLoading,
                     isLoading: isContinuing
                 ) {
                     await onContinue()
@@ -216,6 +251,8 @@ struct SendAmountView: View {
                 amountViewModel.updateFromSats(existingAmount, currency: currency)
             }
 
+            updateRequestAmount()
+
             // Calculate max sendable amount for onchain transactions
             if hwSend.isActive || app.selectedWalletToPayFrom == .onchain {
                 Task {
@@ -227,6 +264,8 @@ struct SendAmountView: View {
                 }
             }
         }
+        .task { await usdt.refresh() }
+        .onChange(of: paymentRequests.pendingRequests) { updateRequestAmount() }
         .onChange(of: app.selectedWalletToPayFrom) { _, newValue in
             // Recalculate max sendable amount when switching wallet types
             if hwSend.isActive || newValue == .onchain {
@@ -264,6 +303,26 @@ struct SendAmountView: View {
         defer { isContinuing = false }
 
         do {
+            if let request = app.contactPaymentContext?.incomingPaymentRequest {
+                let asset: PaykitAsset = app.paykitUsesUsdt ? .usdt : .btc
+                let terms = try request.payment(to: asset)
+                guard terms.isValid(at: Date()) else { throw PaykitPaymentRequestError.requestExpired }
+                let expected = terms.amount
+                let entered = app.paykitUsesUsdt ? try PaykitAmount(asset: .usdt, value: usdtAmount) : PaykitAmount(asset: .btc, atomic: amountSats)
+                guard expected == entered else { updateRequestAmount(); return }
+                app.paykitPaymentTerms = terms
+            }
+            if app.contactPaymentContext != nil {
+                app.paykitReviewedAmount = app.paykitUsesUsdt ? try PaykitAmount(asset: .usdt, value: usdtAmount) : PaykitAmount(
+                    asset: .btc,
+                    atomic: amountSats
+                )
+            }
+            if app.paykitUsesUsdt {
+                guard let recipient = app.contactPaymentContext?.endpoints.first(where: { $0.methodId == .usdtArbitrum })?.value else { return }
+                navigationPath.append(.usdt(recipient: recipient, amount: usdtAmount))
+                return
+            }
             wallet.sendAmountSats = amountSats
             wallet.isMaxAmountSend = isMaxAmountSend
 
@@ -294,7 +353,7 @@ struct SendAmountView: View {
                     return
                 }
 
-                navigationPath.append(.confirm)
+                navigationPath.append(app.lnurlPayData != nil && app.scannedLightningInvoice == nil ? .lnurlPayConfirm : .confirm)
                 return
             }
 
@@ -354,7 +413,27 @@ struct SendAmountView: View {
     }
 
     private func selectFundingSource(_ source: SendFundingSource) {
+        let target: PaykitAsset = source == .usdt ? .usdt : .btc
+        if app.paykitUsesUsdt != (source == .usdt) {
+            do {
+                let value = app.contactPaymentContext?.incomingPaymentRequest?.amount ??
+                    (app.paykitUsesUsdt ? (try? PaykitAmount(asset: .usdt, value: usdtAmount)) : PaykitAmount(asset: .btc, atomic: amountSats))
+                if let value, value.atomic > 0 {
+                    let converted = try app.contactPaymentContext?.incomingPaymentRequest?.payment(to: target).amount ?? value.converted(
+                        to: target,
+                        rate: currency.paykitRate,
+                        at: Date()
+                    )
+                    if target == .usdt { usdtAmount = converted.value }
+                    else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
+                }
+                conversionError = nil
+            } catch { conversionError = t("wallet__payment_request_rate_unavailable"); return }
+        }
+        app.paykitUsesUsdt = source == .usdt
         switch source {
+        case .usdt:
+            hwSend.selectWallet(nil)
         case .spending:
             hwSend.selectWallet(nil)
             app.selectedWalletToPayFrom = .lightning
@@ -376,6 +455,20 @@ struct SendAmountView: View {
         }
     }
 
+    private func updateRequestAmount() {
+        guard let original = app.contactPaymentContext?.incomingPaymentRequest else { return }
+        let request = paymentRequests.pendingRequests.first { $0.id == original.id } ?? original
+        if request != original { app.contactPaymentContext?.incomingPaymentRequest = request }
+        do {
+            let terms = try request.payment(to: app.paykitUsesUsdt ? .usdt : .btc)
+            guard terms.isValid(at: Date()) else { throw PaykitPaymentRequestError.requestExpired }
+            let converted = terms.amount
+            if app.paykitUsesUsdt { usdtAmount = converted.value }
+            else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
+            conversionError = nil
+        } catch { conversionError = t("wallet__payment_request_rate_unavailable") }
+    }
+
     private func showMaxExceededToast() {
         app.toast(
             type: .warning,
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index cfdec8cfd..727ffedb3 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -267,7 +267,12 @@ struct SendConfirmationView: View {
 
             VStack(alignment: .leading, spacing: 0) {
                 if let preparingRequest {
-                    MoneyStack(sats: Int(preparingRequest.amountSats), showSymbol: true, testIdPrefix: "ReviewAmount")
+                    if preparingRequest.amount.asset == .btc {
+                        MoneyStack(sats: Int(clamping: preparingRequest.amount.atomic), showSymbol: true, testIdPrefix: "ReviewAmount")
+                    } else {
+                        PaykitAmountText(amount: preparingRequest.amount, size: .display)
+                            .accessibilityIdentifier("ReviewAmount")
+                    }
                 } else if app.selectedWalletToPayFrom == .lightning, let invoice = app.scannedLightningInvoice {
                     MoneyStack(
                         sats: Int(wallet.sendAmountSats ?? invoice.amountSatoshis),
@@ -300,13 +305,7 @@ struct SendConfirmationView: View {
                         .padding(.bottom, 16)
                 }
 
-                Image("coin-stack-4")
-                    .resizable()
-                    .aspectRatio(contentMode: .fit)
-                    .frame(width: UIScreen.main.bounds.width * 0.8)
-                    .frame(maxWidth: .infinity)
-                    .padding(.bottom, 16)
-                    .rotationEffect(.degrees(swipeProgress * 14))
+                PaymentReviewIllustration(swipeProgress: swipeProgress)
             }
 
             Spacer(minLength: 16)
@@ -735,6 +734,8 @@ struct SendConfirmationView: View {
 
     private func selectFundingSource(_ source: SendFundingSource) {
         switch source {
+        case .usdt:
+            navigationPath = [.amount]
         case .spending:
             hwSend.selectWallet(nil)
             app.selectedWalletToPayFrom = .lightning
@@ -1122,7 +1123,8 @@ struct SendConfirmationView: View {
                     request: incomingPaymentRequest,
                     paymentAppId: paymentAppId,
                     paymentEndpointIdentifier: proof.endpointIdentifier,
-                    kind: proof.kind
+                    kind: proof.kind,
+                    paymentTerms: app.paykitPaymentTerms
                 )
                 preparedPaymentProof = (proof.endpointIdentifier, proof.kind, paymentAppId)
                 if proof.kind == .onchain {
@@ -1222,6 +1224,7 @@ struct SendConfirmationView: View {
                 }
             } else if app.selectedWalletToPayFrom == .onchain, let invoice = app.scannedOnchainInvoice {
                 let amount = wallet.sendAmountSats ?? invoice.amountSatoshis
+                wallet.sendAmountSats = amount
                 let useMaxAmount = await shouldUseMaxOnchainSend(address: invoice.address, amountSats: amount)
                 let result = try await Self.sendOnchainPayment(
                     request: incomingPaymentRequest,
@@ -1358,7 +1361,6 @@ struct SendConfirmationView: View {
                 } else if onchainPaymentStarted {
                     shouldCancelPaymentProof = false
                     await contactPaymentContext?.resolvePrivatePaymentListConsumption(.uncertain)
-                    wallet.sendAmountSats = incomingPaymentRequest.amountSats
                     Logger.warn("On-chain payment outcome is uncertain after broadcast started: \(error)", context: "SendConfirmation")
                     navigationPath.append(.pending(
                         paymentHash: nil,
@@ -1434,7 +1436,7 @@ struct SendConfirmationView: View {
             wallet.sendAmountSats ?? app.scannedOnchainInvoice?.amountSatoshis
         }
 
-        guard let paymentAmount, request.acceptsPaymentAmount(paymentAmount) else {
+        guard let paymentAmount, request.acceptsPaymentAmount(paymentAmount, paymentTerms: app.paykitPaymentTerms) else {
             throw PaykitPaymentRequestError.amountMismatch
         }
         guard app.selectedWalletToPayFrom == .lightning else { return }
@@ -1442,7 +1444,7 @@ struct SendConfirmationView: View {
             throw PaykitPaymentRequestError.amountMismatch
         }
         let parsedInvoice = try Bolt11Invoice.fromStr(invoiceStr: invoice.bolt11)
-        guard request.acceptsLightningInvoiceAmount(milliSatoshis: parsedInvoice.amountMilliSatoshis())
+        guard request.acceptsLightningInvoiceAmount(milliSatoshis: parsedInvoice.amountMilliSatoshis(), paymentTerms: app.paykitPaymentTerms)
         else {
             throw PaykitPaymentRequestError.amountMismatch
         }
diff --git a/Bitkit/Views/Wallets/Send/SendContactSelectView.swift b/Bitkit/Views/Wallets/Send/SendContactSelectView.swift
index df2647d3a..3ed4ab90a 100644
--- a/Bitkit/Views/Wallets/Send/SendContactSelectView.swift
+++ b/Bitkit/Views/Wallets/Send/SendContactSelectView.swift
@@ -63,11 +63,12 @@ struct SendContactSelectView: View {
             let result = try await PrivatePaykitService.shared.beginSavedContactPayment(to: contact.publicKey, wallet: wallet)
 
             switch result {
-            case let .opened(paymentRequest, privatePaymentContext):
+            case let .opened(paymentRequest, privatePaymentContext, endpoints):
                 _ = await openContactPayment(
                     paymentRequest: paymentRequest,
                     publicKey: contact.publicKey,
-                    privatePaymentContext: privatePaymentContext
+                    privatePaymentContext: privatePaymentContext,
+                    endpoints: endpoints
                 )
             case .noEndpoint, .notOpened, .privateLinkPending, .waitingForUpdatedPaymentList:
                 if let messageKey = result.contactPaymentFailureMessageKey {
@@ -90,11 +91,13 @@ struct SendContactSelectView: View {
     private func openContactPayment(
         paymentRequest: String,
         publicKey: String,
-        privatePaymentContext: PrivatePaykitPaymentContext?
+        privatePaymentContext: PrivatePaykitPaymentContext?,
+        endpoints: [PublicPaykitService.Endpoint]
     ) async -> Bool {
         let contactPaymentContext = ContactPaymentContext(
             publicKey: publicKey,
-            privatePaymentContext: privatePaymentContext
+            privatePaymentContext: privatePaymentContext,
+            endpoints: endpoints
         )
         guard app.claimContactPaymentContext(contactPaymentContext) else { return false }
 
diff --git a/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift b/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
index 67a419573..194f5141b 100644
--- a/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
+++ b/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
@@ -39,30 +39,12 @@ struct SendEnterManuallyView: View {
             CaptionMText(t("wallet__send_to"))
                 .frame(maxWidth: .infinity, alignment: .leading)
 
-            ZStack(alignment: .topLeading) {
-                if app.manualEntryInput.isEmpty {
-                    TitleText(t("wallet__send_address_placeholder"), textColor: .textSecondary)
-                        .padding(20)
-                }
-
-                TextEditor(text: manualEntryBinding)
-                    .focused($isTextEditorFocused)
-                    .padding(EdgeInsets(top: -10, leading: -5, bottom: -5, trailing: -5))
-                    .padding(20)
-                    .frame(maxHeight: .infinity)
-                    .scrollContentBackground(.hidden)
-                    .font(.custom(Fonts.bold, size: 22))
-                    .foregroundColor(.textPrimary)
-                    .accentColor(.brandAccent)
-                    .submitLabel(.done)
-                    .textInputAutocapitalization(.never)
-                    .autocorrectionDisabled()
-                    .dismissKeyboardOnReturn(text: manualEntryBinding, isFocused: $isTextEditorFocused)
-                    .accessibilityValue(app.manualEntryInput)
-                    .accessibilityIdentifier("RecipientInput")
-            }
-            .background(Color.white06)
-            .cornerRadius(8)
+            PaymentAddressInput(
+                text: manualEntryBinding,
+                isFocused: $isTextEditorFocused,
+                placeholder: t("wallet__send_address_placeholder"),
+                testIdentifier: "RecipientInput"
+            )
 
             Spacer(minLength: 16)
 
diff --git a/Bitkit/Views/Wallets/Send/SendSheet.swift b/Bitkit/Views/Wallets/Send/SendSheet.swift
index d77048145..0eec53eb1 100644
--- a/Bitkit/Views/Wallets/Send/SendSheet.swift
+++ b/Bitkit/Views/Wallets/Send/SendSheet.swift
@@ -52,6 +52,7 @@ enum SendRoute: Hashable {
     case comingSoon
     case manual
     case amount
+    case usdt(recipient: String, amount: String)
     case utxoSelection
     case confirm
     case hardwareSign
@@ -141,6 +142,7 @@ struct SendSheet: View {
     @State private var pinCheckContinuations: [CheckedContinuation<Bool, Never>] = []
     @State private var hwSend: HwSendCoordinator
     @State private var setupTask: Task<Void, Never>?
+    @State private var usdtDetails: String?
 
     init(config: SendSheetItem, isEmbedded: Bool = false) {
         self.config = config
@@ -370,7 +372,7 @@ struct SendSheet: View {
             if PaykitSubscriptionNotificationTargetStore.load()?.matches(request) == true {
                 PaykitSubscriptionNotificationTargetStore.clear()
             }
-            wallet.sendAmountSats = request.amountSats
+            wallet.sendAmountSats = request.amount.asset == .btc ? request.amount.atomic : nil
             incomingPaymentRequest = request
         } else {
             tagManager.clearSelectedTags()
@@ -412,9 +414,10 @@ struct SendSheet: View {
             } catch {
                 Logger.error("Failed to set default fee rate: \(error)")
             }
-            if let request = incomingPaymentRequest {
+            if let request = incomingPaymentRequest, app.contactPaymentContext?.requiresAssetSelection != true {
                 guard isCurrentIncomingRequest(request.id) else { return }
-                guard await selectHardwareFundingSourceIfNeeded(amountSats: request.amountSats, requestId: request.id) else { return }
+                guard let amount = try? request.payment(to: .btc).amount.atomic,
+                      await selectHardwareFundingSourceIfNeeded(amountSats: amount, requestId: request.id) else { return }
                 guard isCurrentIncomingRequest(request.id) else { return }
                 if !shouldShowSyncOverlay {
                     validatePaymentAfterSync()
@@ -793,6 +796,23 @@ struct SendSheet: View {
             SendEnterManuallyView(navigationPath: $navigationPath, hwSend: hwSend)
         case .amount:
             SendAmountView(navigationPath: $navigationPath, hwSend: hwSend)
+        case let .usdt(recipient, amount):
+            UsdtSendView(onDetails: { id in
+                usdtDetails = id
+            }, initialRecipient: recipient, initialAmount: amount, embedded: true,
+            sendPayment: { quote in
+                guard let context = app.contactPaymentContext else { throw PaykitPaymentRequestError.requestUnavailable }
+                let paymentTerms = app.paykitPaymentTerms
+                try await PaykitUsdtPaymentService.shared.prepare(context: context, quote: quote, wallet: wallet.usdtWallet,
+                                                                  amount: app.paykitReviewedAmount, paymentTerms: paymentTerms)
+                guard app.ownsContactPaymentContext(context) else { throw PaykitPaymentRequestError.requestUnavailable }
+                try await prepareIncomingPaymentRequest()
+                guard app.ownsContactPaymentContext(context) else { throw PaykitPaymentRequestError.requestUnavailable }
+                try await PaykitUsdtPaymentService.shared.send(quote, context: context, paymentTerms: paymentTerms, wallet: wallet.usdtWallet) {
+                    if let request = context.incomingPaymentRequest { try await paykitPaymentRequestManager.ensurePaymentAllowed(request) }
+                    guard app.ownsContactPaymentContext(context) else { throw PaykitPaymentRequestError.requestUnavailable }
+                }
+            }, onBack: { navigationPath.removeLast() }, onClose: { sheets.hideSheet() })
         case .utxoSelection:
             SendUtxoSelectionView(navigationPath: $navigationPath)
         case .confirm:
@@ -941,9 +961,13 @@ struct SendSheet: View {
         guard let context,
               let request = context.incomingPaymentRequest
         else { return }
+        // A durable USDT attempt must keep its recovery and payment proof on the same rail.
+        guard app.paykitUsesUsdt || !PaykitUsdtPaymentService.shared.hasBinding(for: request.id) else {
+            throw PaykitPaymentRequestError.operationInProgress
+        }
 
         try await paykitPaymentRequestManager.prepareForPayment(request) {
-            guard let privatePaymentContext = context.privatePaymentContext else { return }
+            guard !app.paykitUsesUsdt, let privatePaymentContext = context.privatePaymentContext else { return }
             try await PrivatePaykitService.shared.consumePrivatePaymentList(
                 publicKey: context.publicKey,
                 context: privatePaymentContext,
@@ -968,6 +992,7 @@ struct SendSheet: View {
         else { throw PaykitPaymentRequestError.requestUnavailable }
         _ = try hwWalletManager.getFundingAccount(walletId: walletId)
 
+        let paymentTerms = app.paykitPaymentTerms
         let endpointIdentifier = PublicPaykitService.onchainMethodId(for: address).rawValue
         guard let privateContext = context?.privatePaymentContext else {
             throw PaykitPaymentRequestError.requestUnavailable
@@ -1077,7 +1102,8 @@ struct SendSheet: View {
             publicKey: context.publicKey,
             privatePaymentContext: context.privatePaymentContext,
             incomingPaymentRequest: retriedRequest,
-            isInitialSubscriptionPayment: context.isInitialSubscriptionPayment
+            isInitialSubscriptionPayment: context.isInitialSubscriptionPayment,
+            endpoints: context.endpoints
         )
     }
 
@@ -1150,7 +1176,6 @@ struct SendSheet: View {
 
         app.resetSendState()
         wallet.resetSendState(speed: settings.defaultTransactionSpeed)
-        wallet.sendAmountSats = request.amountSats
 
         let resolution: PublicPaykitPaymentLaunchResult
         do {
@@ -1160,7 +1185,7 @@ struct SendSheet: View {
             return
         }
 
-        guard case let .opened(paymentTarget, privatePaymentContext) = resolution else {
+        guard case let .opened(paymentTarget, privatePaymentContext, endpoints) = resolution else {
             showEmbeddedInitialPaymentFailure(request, error: PaykitPaymentRequestError.requestUnavailable)
             return
         }
@@ -1170,7 +1195,7 @@ struct SendSheet: View {
             publicKey: request.counterparty,
             privatePaymentContext: privatePaymentContext,
             incomingPaymentRequest: request,
-            isInitialSubscriptionPayment: true
+            isInitialSubscriptionPayment: true, endpoints: endpoints
         )
         guard app.claimContactPaymentContext(context) else {
             app.toast(PaykitPaymentRequestError.operationInProgress)
@@ -1213,7 +1238,7 @@ struct SendSheet: View {
             return
         }
 
-        pendingEmbeddedRetryRoute = app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
+        pendingEmbeddedRetryRoute = context.requiresAssetSelection ? .amount : app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
         hasValidatedAfterSync = false
         guard !shouldShowSyncOverlay else { return }
         validatePaymentAfterSync()
diff --git a/Bitkit/Views/Wallets/Send/SendSuccess.swift b/Bitkit/Views/Wallets/Send/SendSuccess.swift
index 344504d9b..ee37ba2cb 100644
--- a/Bitkit/Views/Wallets/Send/SendSuccess.swift
+++ b/Bitkit/Views/Wallets/Send/SendSuccess.swift
@@ -1,5 +1,4 @@
 import BitkitCore
-import Lottie
 import SwiftUI
 
 struct SendSuccess: View {
@@ -45,18 +44,6 @@ struct SendSuccess: View {
         return nil
     }
 
-    /// Load the confetti animation
-    private var confettiAnimation: LottieAnimation? {
-        let animationName = paymentProofKind == .onchain ? "confetti-orange" : "confetti-purple"
-
-        guard let filepathURL = Bundle.main.url(forResource: animationName, withExtension: "json") else {
-            print("Could not find \(animationName).json in bundle")
-            return nil
-        }
-
-        return LottieAnimation.filepath(filepathURL.path)
-    }
-
     var body: some View {
         Group {
             if isInitialSubscriptionPayment {
@@ -76,14 +63,7 @@ struct SendSuccess: View {
     private var standardSuccess: some View {
         VStack(alignment: .leading, spacing: 0) {
             ZStack {
-                // Background confetti animation
-                if let animation = confettiAnimation {
-                    LottieView(animation: animation)
-                        .playing(loopMode: .loop)
-                        // Scale the animation to fill the sheet
-                        .scaleEffect(1.9)
-                        .frame(maxWidth: .infinity, maxHeight: .infinity)
-                }
+                PaymentCelebration(isOnchain: app.selectedWalletToPayFrom == .onchain, isReceived: false)
 
                 VStack(alignment: .leading, spacing: 0) {
                     SheetHeader(title: t("wallet__send_sent"), showBackButton: false)
diff --git a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
index 13aa79cdb..9cb7dc8a9 100644
--- a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
+++ b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
@@ -1,4 +1,4 @@
-import Lottie
+import BitkitCore
 import SwiftUI
 
 struct ReceivedTxSheetDetails: Codable {
@@ -8,7 +8,8 @@ struct ReceivedTxSheetDetails: Codable {
     }
 
     let type: ReceivedTxType
-    let sats: UInt64
+    var sats: UInt64 = 0
+    var usdtAmount: UInt64? = nil
 }
 
 struct ReceivedTxSheetItem: SheetItem {
@@ -25,42 +26,26 @@ struct ReceivedTx: View {
     /// Keep in state so we don't get a new random text on each render
     @State private var buttonText: String = localizedRandom("common__ok_random")
 
-    /// Load the confetti animation
-    private var confettiAnimation: LottieAnimation? {
-        let isOnchain = config.details.type == .onchain
-        let animationName = isOnchain ? "confetti-orange" : "confetti-purple"
-
-        guard let filepathURL = Bundle.main.url(forResource: animationName, withExtension: "json") else {
-            print("Could not find \(animationName).json in bundle")
-            return nil
-        }
-
-        return LottieAnimation.filepath(filepathURL.path)
-    }
-
     var body: some View {
         let isOnchain = config.details.type == .onchain
-        let title = isOnchain ? t("wallet__payment_received") : t("wallet__instant_payment_received")
+        let title = config.details.usdtAmount != nil ? t("usdt__payment_received")
+            : isOnchain ? t("wallet__payment_received") : t("wallet__instant_payment_received")
 
         Sheet(id: .receivedTx, data: config) {
             ZStack {
-                if let animation = confettiAnimation {
-                    LottieView(animation: animation)
-                        .playing(loopMode: .loop)
-                        // Scale the animation to fill the sheet
-                        .scaleEffect(1.9)
-                        .frame(width: .infinity, height: .infinity)
-                }
-
-                Image("coins-received")
-                    .resizable()
-                    .aspectRatio(contentMode: .fit)
-                    .frame(maxWidth: .infinity, alignment: .center)
-                    .offset(y: 50)
+                PaymentCelebration(
+                    isOnchain: isOnchain, isReceived: true,
+                    confettiColor: config.details.usdtAmount != nil ? .greenAccent : nil
+                )
 
                 VStack(alignment: .leading, spacing: 0) {
                     SheetHeader(title: title)
-                    MoneyStack(sats: Int(config.details.sats), showSymbol: true, testIdPrefix: "ReceivedTransaction")
+                    if let amount = config.details.usdtAmount {
+                        UsdtAmountHeader(amount: usdtFormatAmount(amount: amount), network: "Arbitrum One")
+                            .accessibilityIdentifier("ReceivedTransaction")
+                    } else {
+                        MoneyStack(sats: Int(config.details.sats), showSymbol: true, testIdPrefix: "ReceivedTransaction")
+                    }
                     Spacer()
                     CustomButton(title: buttonText) { sheets.hideSheet() }
                         .accessibilityIdentifier("ReceivedTransactionButton")
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
new file mode 100644
index 000000000..4fe496f6c
--- /dev/null
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -0,0 +1,189 @@
+import BitkitCore
+import SwiftUI
+
+struct UsdtActivityRow: View {
+    let transfer: UsdtTransfer
+    let hideBalance: Bool
+    @EnvironmentObject private var contacts: ContactsManager
+
+    private var contactName: String? {
+        guard let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) else { return nil }
+        return contacts.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }?.displayName ?? PubkyPublicKeyFormat.displayTruncated(key)
+    }
+
+    var body: some View {
+        ActivityRowContainer {
+            ActivityRowContent(
+                title: contactName ?? transfer.title,
+                subtitle: DateFormatterHelpers.getActivityItemDate(transfer.timestamp)
+            ) {
+                UsdtActivityIcon(transfer: transfer)
+            } amount: {
+                VStack(alignment: .trailing, spacing: 2) {
+                    BodyMSBText(
+                        "<accent>\(transfer.isIncoming ? "+" : "−")</accent> "
+                            + (hideBalance ? " • • • • •" : usdtFormatAmount(amount: transfer.activityAmount)),
+                        accentColor: .textSecondary
+                    )
+                    .lineLimit(1).minimumScaleFactor(0.7)
+                    CaptionBText("USDT", textColor: .textSecondary)
+                }
+            }
+        }
+    }
+}
+
+struct UsdtActivityIcon: View {
+    let transfer: UsdtTransfer
+    var size: CGFloat = 40
+
+    var body: some View {
+        CircularIcon(
+            icon: transfer.statusIcon,
+            iconColor: transfer.statusColor,
+            backgroundColor: transfer.statusColor.opacity(0.16),
+            size: size
+        )
+    }
+}
+
+struct UsdtActivityDetail: View {
+    let transferId: String
+    @Environment(UsdtWalletManager.self) private var usdt
+    @EnvironmentObject private var settings: SettingsViewModel
+    @EnvironmentObject private var contacts: ContactsManager
+    @Environment(\.openURL) private var openURL
+    @Environment(\.dismiss) private var dismiss
+    @Environment(\.scenePhase) private var scenePhase
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            NavigationBar(title: transfer?.title ?? t("usdt__activity"), onBack: { dismiss() }).padding(.bottom, 16)
+            if let transfer {
+                ScrollView(showsIndicators: false) {
+                    VStack(alignment: .leading, spacing: 16) {
+                        HStack(alignment: .bottom) {
+                            UsdtAmountHeader(
+                                amount: usdtFormatAmount(amount: transfer.activityAmount), network: transfer.destination.label,
+                                prefix: transfer.isIncoming ? "+ " : "− ", hideBalance: settings.hideBalance
+                            )
+                            UsdtActivityIcon(transfer: transfer, size: 48)
+                        }
+                        .padding(.bottom, 16)
+                        SendSectionView(t("wallet__activity_status")) {
+                            Label {
+                                BodySSBText(transfer.status.label, textColor: transfer.statusColor)
+                            } icon: {
+                                Image(transfer.statusIcon).foregroundColor(transfer.statusColor)
+                            }
+                            .accessibilityIdentifier("UsdtActivityStatus")
+                        }
+                        let time = DateFormatterHelpers.formatActivityDetail(transfer.timestamp)
+                        HStack(spacing: 16) {
+                            SendSectionView(t("wallet__activity_date")) { BodySSBText(time.date) }
+                            SendSectionView(t("wallet__activity_time")) { BodySSBText(time.time) }
+                        }
+                        if let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) {
+                            SendSectionView(t(transfer.isIncoming ? "wallet__send_from" : "wallet__send_to")) {
+                                BodySSBText(contacts.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }?.displayName
+                                    ?? PubkyPublicKeyFormat.displayTruncated(key))
+                            }
+                        }
+                        SendSectionView(t("usdt__destination")) { BodySSBText(transfer.destination.label) }
+                        if !transfer.isIncoming {
+                            SendSectionView(t("usdt__address")) { BodySSBText(transfer.recipient).textSelection(.enabled) }
+                            HStack(alignment: .top, spacing: 16) {
+                                if transfer.status != .failed, transfer.status != .replaced {
+                                    SendSectionView(t(transfer.destination != .arbitrum && transfer.status != .confirmed
+                                            ? "usdt__expected_amount" : "usdt__recipient_gets")) { amountText(transfer.receivedAmount) }
+                                }
+                                SendSectionView(t("wallet__activity_fee")) {
+                                    if let fee = transfer.fee {
+                                        amountText(fee)
+                                    } else { BodySSBText("—") }
+                                }
+                            }
+                        }
+                        if let bridge = transfer.orchestra {
+                            SendSectionView(t("usdt__bridge_provider")) { BodySSBText("Orchestra") }
+                            if let hash = bridge.destinationTx {
+                                SendSectionView(t("usdt__destination_tx")) { BodySText(hash).textSelection(.enabled) }
+                            }
+                            if let amount = bridge.refundAmount, let hash = bridge.refundTx {
+                                SendSectionView(t("usdt__deposit_refunded")) { amountText(amount) }
+                                SendSectionView(t("usdt__refund_tx")) { BodySText(hash).textSelection(.enabled) }
+                            }
+                        }
+                        if let txHash = transfer.txHash {
+                            SendSectionView(t("wallet__activity_tx_id")) { BodySText(txHash).textSelection(.enabled) }
+                            if transfer.destination != .arbitrum, transfer.orchestra == nil {
+                                CustomButton(title: t("usdt__track_bridge"), variant: .secondary, shouldExpand: true) {
+                                    if let url = URL(string: "https://layerzeroscan.com/tx/" + txHash) { openURL(url) }
+                                }
+                            }
+                            if let url = URL(string: "https://arbiscan.io/tx/" + txHash) {
+                                CustomButton(title: t("wallet__activity_explore"), variant: .secondary, shouldExpand: true) { openURL(url) }
+                            }
+                        }
+                    }
+                    .bottomSafeAreaPadding()
+                }
+            }
+        }
+        .padding(.horizontal, 16)
+        .navigationBarHidden(true)
+        .task(id: scenePhase) {
+            guard scenePhase == .active else { return }
+            while !Task.isCancelled {
+                await usdt.refresh()
+                do { try await Task.sleep(for: .seconds(10)) } catch { return }
+            }
+        }
+    }
+
+    private var transfer: UsdtTransfer? {
+        usdt.transfers.first { $0.id == transferId }
+    }
+
+    private func amountText(_ amount: UInt64) -> some View {
+        BodySSBText((settings.hideBalance ? " • • • • •" : usdtFormatAmount(amount: amount)) + " USDT")
+    }
+}
+
+extension UsdtTransfer {
+    var activityAmount: UInt64 {
+        if isIncoming { return amount }
+        if status == .failed || status == .replaced { return fee ?? 0 }
+        let total = amount.addingReportingOverflow(fee ?? 0)
+        return total.overflow ? UInt64.max : total.partialValue
+    }
+
+    var title: String {
+        switch status {
+        case .failed, .replaced: status.label
+        case .pending, .bridging, .bridgeNeedsAttention, .bridgeFailed, .bridgeRefunded: status.label
+        default: t(isIncoming ? "usdt__received" : "usdt__sent")
+        }
+    }
+
+    var groupTitle: String {
+        DateFormatterHelpers.getActivityGroupHeader(for: Date(timeIntervalSince1970: TimeInterval(timestamp)))
+    }
+
+    var statusIcon: String {
+        switch status {
+        case .failed, .replaced, .bridgeFailed: "x-mark"
+        case .pending, .bridging, .bridgeNeedsAttention: "hourglass-simple"
+        case .confirmed: isIncoming ? "arrow-down" : "arrow-up"
+        case .bridgeRefunded: "arrow-down"
+        }
+    }
+
+    var statusColor: Color {
+        switch status {
+        case .failed, .replaced: .redAccent
+        case .bridgeNeedsAttention, .bridgeFailed: .yellowAccent
+        default: .greenAccent
+        }
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
new file mode 100644
index 000000000..adb0c547a
--- /dev/null
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -0,0 +1,258 @@
+import BitkitCore
+import SwiftUI
+
+struct UsdtDepositHistoryView: View {
+    let onBlockingChange: (Bool) -> Void
+    @Environment(\.scenePhase) private var scenePhase
+    @Environment(UsdtWalletManager.self) private var usdt
+    @EnvironmentObject private var settings: SettingsViewModel
+    @State private var deposits: [UsdtDeposit] = []
+    @State private var nextOffset: UInt32?
+    @State private var selected: UsdtDepositDetail?
+    @State private var refundAddress = ""
+    @State private var approved: RefundApproval?
+    @State private var pageOffsets: [String: UInt32] = [:]
+    @State private var confirmRefund = false
+    @State private var pin = false
+    @State private var busy = false
+    @State private var error: String?
+    @State private var message: String?
+
+    private var recoveryActive: Bool {
+        confirmRefund || pin || approved != nil
+    }
+
+    var body: some View {
+        NavigationStack {
+            VStack(alignment: .leading, spacing: 16) {
+                ScrollView {
+                    VStack(alignment: .leading, spacing: 16) {
+                        if let selected { detail(selected) }
+                        else {
+                            BodySText(t("usdt__deposit_status_note"), textColor: .textSecondary)
+                            if deposits.isEmpty { BodySText(t("usdt__deposit_empty"), textColor: .textSecondary) }
+                            ForEach(deposits, id: \.id) { deposit in
+                                Button {
+                                    Task { await loadDetail(deposit.id) }
+                                } label: {
+                                    ActivityRowContainer {
+                                        ActivityRowContent(title: deposit.network.uppercased(), subtitle: deposit.statusText) {
+                                            CircularIcon(
+                                                icon: "arrow-down",
+                                                iconColor: .greenAccent,
+                                                backgroundColor: .greenAccent.opacity(0.16),
+                                                size: 40
+                                            )
+                                        } amount: { BodySSBText(deposit.asset == "USDT" ? amount(deposit.amount) : deposit.asset) }
+                                    }
+                                }.buttonStyle(.plain).disabled(busy)
+                            }
+                            if let nextOffset {
+                                CustomButton(title: t("usdt__deposit_more"), variant: .secondary, isDisabled: busy) { await loadPage(nextOffset) }
+                            }
+                        }
+                        if let error { BodySText(error, textColor: .brandAccent) }
+                        if let message { BodySText(message, textColor: .textSecondary) }
+                    }
+                }
+                .scrollDismissesKeyboard(.immediately)
+                CustomButton(title: t(selected == nil ? "usdt__deposit_refresh" : "usdt__deposit_history"),
+                             variant: .secondary, isDisabled: busy, isLoading: busy)
+                {
+                    selected = nil
+                    message = nil
+                    refundAddress = ""
+                    approved = nil
+                    await loadPage(0)
+                }
+            }
+            .navigationBarHidden(true)
+            .navigationDestination(isPresented: $pin) {
+                SendPinScreen(onCancel: {
+                    pin = false
+                    approved = nil
+                }, onPinVerified: {
+                    pin = false
+                    Task { await refund() }
+                })
+            }
+            .alert(t("usdt__deposit_refund"), isPresented: $confirmRefund) {
+                Button(t("common__cancel"), role: .cancel) {}
+                Button(t("usdt__deposit_refund")) {
+                    if let deposit = selected?.deposit {
+                        approved = RefundApproval(deposit: deposit, offset: pageOffsets[deposit.id] ?? 0, address: refundAddress)
+                        Task { await authorizeRefund() }
+                    }
+                }
+            } message: {
+                Text((selected?.deposit.network.uppercased() ?? "") + "\n" + (selected?.deposit.id ?? "") + "\n" + amount(selected?.deposit.amount) +
+                    "\n" + refundAddress + "\n\n" + t("usdt__deposit_refund_note"))
+            }
+        }
+        .task { await loadPage(0) }
+        .task(id: "\(scenePhase == .active)-\(selected?.deposit.id ?? "")-\(recoveryActive)") {
+            guard scenePhase == .active, !recoveryActive, let id = selected?.deposit.id else { return }
+            while !Task.isCancelled {
+                if let selected, ["completed", "refunded"].contains(selected.order?.status ?? selected.deposit.status) { return }
+                do {
+                    try await Task.sleep(for: .seconds(10))
+                    try Task.checkCancellation()
+                } catch { return }
+                guard !recoveryActive else { return }
+                await loadDetail(id)
+            }
+        }
+        .interactiveDismissDisabled(busy || pin)
+        .onChange(of: busy || pin) { _, blocked in onBlockingChange(blocked) }
+        .onDisappear { onBlockingChange(false) }
+    }
+
+    private func detail(_ detail: UsdtDepositDetail) -> some View {
+        VStack(alignment: .leading, spacing: 16) {
+            if detail.deposit.asset == "USDT" {
+                UsdtAmountHeader(amount: detail.deposit.amount.map { usdtFormatAmount(amount: $0) } ?? "—",
+                                 network: detail.deposit.network.uppercased(), hideBalance: settings.hideBalance)
+            } else {
+                BodySSBText(detail.deposit.asset + " · " + detail.deposit.network.uppercased())
+            }
+            SendSectionView(t("wallet__activity_status")) { BodySSBText(detail.statusText) }
+            BodySText(t("usdt__deposit_status_note"), textColor: .textSecondary)
+            SendSectionView(t("usdt__deposit_reference")) { BodySText(detail.deposit.id).textSelection(.enabled) }
+            SendSectionView(t("wallet__activity_tx_id")) { BodySText(detail.deposit.sourceTx).textSelection(.enabled) }
+            if let code = detail.statusCode { BodySText(code, textColor: .textSecondary).textSelection(.enabled) }
+            if let order = detail.order, order.status != "refunded", let received = order.amountOut {
+                SendSectionView(t("usdt__deposit_batch")) { BodySSBText(amount(received)) }
+                if let sent = order.amountIn, sent >= received {
+                    SendSectionView(t("usdt__deposit_cost")) { BodySSBText(amount(sent - received)) }
+                }
+            }
+            if let tx = detail.order?
+                .destinationTx { SendSectionView(t("wallet__activity_tx_id") + " · Arbitrum One") { BodySText(tx).textSelection(.enabled) } }
+            if let tx = detail.order?.refundTx ?? detail.deposit.refundTx {
+                SendSectionView(t("usdt__deposit_refund")) { BodySText(tx).textSelection(.enabled) }
+            }
+            if detail.deposit.asset != "USDT" || UsdtDepositNetwork.named(detail.deposit.network) == nil {
+                BodySText(t("usdt__deposit_wrong_asset"), textColor: .textSecondary)
+            } else if !["completed", "refunded", "refunding", "refund_requested"].contains(detail.order?.status ?? detail.deposit.status) {
+                BodySText(t("usdt__deposit_refund_note"), textColor: .textSecondary)
+                TextField(t("usdt__deposit_refund_address"), text: $refundAddress, axis: .vertical, testIdentifier: "UsdtRefundAddress")
+                    .textInputAutocapitalization(.never).autocorrectionDisabled().disabled(busy)
+                CustomButton(title: t("usdt__deposit_refund"), variant: .secondary,
+                             isDisabled: busy || refundAddress.isEmpty, isLoading: busy) { if !busy { confirmRefund = true } }
+                    .accessibilityIdentifier("UsdtDepositRefund")
+            }
+        }
+    }
+
+    private func amount(_ value: UInt64?) -> String {
+        (settings.hideBalance ? " • • • • •" : value.map { usdtFormatAmount(amount: $0) } ?? "—") + " USDT"
+    }
+
+    private func loadPage(_ offset: UInt32) async {
+        guard !busy else { return }
+        busy = true
+        error = nil
+        defer { busy = false }
+        do {
+            let page = try await usdt.depositHistory(offset: offset)
+            if offset == 0 {
+                deposits = []
+                pageOffsets = [:]
+            }
+            for deposit in page.deposits {
+                deposits.removeAll { $0.id == deposit.id }
+                deposits.append(deposit)
+                pageOffsets[deposit.id] = offset
+            }
+            nextOffset = page.nextOffset
+        } catch is CancellationError {} catch { self.error = UsdtWalletManager.message(for: error) }
+    }
+
+    private func loadDetail(_ id: String) async {
+        guard !busy else { return }
+        busy = true
+        error = nil
+        defer { busy = false }
+        do {
+            let detail = try await usdt.depositDetail(id: id, offset: pageOffsets[id] ?? 0)
+            if selected?.deposit.id != id {
+                refundAddress = ""
+                approved = nil
+                message = nil
+            }
+            selected = detail
+        } catch is CancellationError {} catch { self.error = UsdtWalletManager.message(for: error) }
+    }
+
+    private func authorizeRefund() async {
+        guard !busy else { return }
+        defer { if !pin { approved = nil } }
+        if settings.requirePinForPayments && settings.pinEnabled {
+            guard settings.useBiometrics && BiometricAuth.isAvailable else {
+                pin = true
+                return
+            }
+            busy = true
+            let result = await BiometricAuth.authenticate()
+            busy = false
+            switch result {
+            case .success: await refund()
+            case .cancelled: break
+            case let .failed(message): error = message
+            }
+        } else { await refund() }
+    }
+
+    private func refund() async {
+        guard !busy, let selected, let approved, selected.deposit.id == approved.deposit.id else { return }
+        busy = true
+        error = nil
+        defer {
+            busy = false
+            self.approved = nil
+        }
+        do {
+            try await usdt.refundDeposit(approved.deposit, offset: approved.offset, address: approved.address)
+            var acknowledged = selected
+            acknowledged.deposit.status = "refund_requested"
+            acknowledged.deposit.code = nil
+            acknowledged.order?.status = "refund_requested"
+            acknowledged.order?.code = nil
+            self.selected = acknowledged
+            message = t("usdt__deposit_refund_requested")
+        } catch { self.error = UsdtWalletManager.message(for: error) }
+    }
+}
+
+private struct RefundApproval {
+    let deposit: UsdtDeposit
+    let offset: UInt32
+    let address: String
+}
+
+extension UsdtDeposit {
+    var statusText: String {
+        code == nil ? depositStatusText(status) : t("usdt__deposit_needs_attention")
+    }
+}
+
+extension UsdtDepositDetail {
+    var statusCode: String? {
+        if let order { return order.code }
+        return deposit.code
+    }
+
+    var statusText: String {
+        statusCode == nil ? depositStatusText(order?.status ?? deposit.status) : t("usdt__deposit_needs_attention")
+    }
+}
+
+private func depositStatusText(_ status: String) -> String {
+    switch status {
+    case "completed": t("usdt__confirmed")
+    case "refunded": t("usdt__deposit_refunded")
+    case "refunding", "refund_requested": t("usdt__deposit_refunding")
+    case "pending", "processing": t("usdt__pending")
+    default: t("usdt__deposit_needs_attention")
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
new file mode 100644
index 000000000..893f19e36
--- /dev/null
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -0,0 +1,167 @@
+import BitkitCore
+import SwiftUI
+
+struct UsdtReceiveView: View {
+    @Environment(UsdtWalletManager.self) private var usdt
+    @EnvironmentObject private var sheets: SheetViewModel
+    @Environment(\.dismiss) private var dismiss
+    @Environment(\.scenePhase) private var scenePhase
+    @State private var networks: [UsdtDepositNetwork] = []
+    @State private var network: UsdtDepositNetwork?
+    @State private var history = false
+    @State private var historyBlocking = false
+    @State private var unavailable = false
+
+    var body: some View {
+        VStack(spacing: 0) {
+            SheetHeader(title: t(history ? "usdt__deposit_history" : "usdt__receive_title"), showBackButton: true,
+                        onBack: { if history { history = false } else { dismiss() } })
+                .disabled(historyBlocking)
+            if history {
+                UsdtDepositHistoryView(onBlockingChange: { historyBlocking = $0 })
+            } else {
+                HStack {
+                    Menu {
+                        Button("Arbitrum One") { network = nil }
+                        ForEach(networks, id: \.self) { item in Button(item.label) { network = item } }
+                    } label: {
+                        NumberPadActionButton(text: network?.label ?? "Arbitrum One", color: .greenAccent, variant: .secondary) {}
+                    }
+                    .accessibilityIdentifier("UsdtReceiveNetwork")
+                    Spacer()
+                    if usdt.depositsConfigured {
+                        Button { history = true } label: { BodySSBText(t("usdt__activity"), textColor: .greenAccent) }
+                            .accessibilityIdentifier("UsdtDepositHistory")
+                    }
+                }.padding(.bottom, 16)
+                if let network { UsdtDepositReceiveView(network: network).id(network) }
+                else {
+                    if unavailable { BodySText(t("usdt__deposit_unavailable"), textColor: .textSecondary).padding(.bottom, 12) }
+                    UsdtReceiveAddressContent(
+                        address: usdt.address,
+                        uri: usdt.receiveUri,
+                        warning: t("usdt__receive_warning"),
+                        error: usdt.errorMessage
+                    )
+                }
+            }
+        }
+        .padding(.horizontal, 16)
+        .onReceive(usdt.receivedTxPublisher) { transfer in
+            guard !historyBlocking, sheets.activeSheetConfiguration?.id == .receive else { return }
+            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: transfer.amount))
+        }
+        .task(id: scenePhase) {
+            guard scenePhase == .active else { return }
+            while !Task.isCancelled {
+                await usdt.refresh(includeHistory: true)
+                try? await Task.sleep(for: .seconds(10))
+            }
+        }
+        .task {
+            do { networks = try await usdt.depositNetworks() }
+            catch is CancellationError {} catch { unavailable = true }
+        }
+    }
+}
+
+struct UsdtReceiveAddressContent<Details: View>: View {
+    let address: String
+    let uri: String
+    let warning: String
+    var error: String?
+    @ViewBuilder var details: () -> Details
+    @State private var showDetails = false
+
+    var body: some View {
+        ScrollView(showsIndicators: false) {
+            VStack(alignment: .leading, spacing: 16) {
+                if !uri.isEmpty {
+                    if showDetails {
+                        CopyAddressCard(addresses: [CopyAddressPair(title: t("usdt__receive_title"), address: address, type: .onchain)],
+                                        navigationPath: .constant([]), editRoute: nil, accentColor: .greenAccent)
+                    } else {
+                        QrArea(uri: uri, imageAsset: nil, accentColor: .greenAccent, navigationPath: .constant([]),
+                               copyValue: address, editRoute: nil)
+                    }
+                    BodySText(address, textColor: .textSecondary).lineLimit(1).truncationMode(.middle).textSelection(.enabled)
+                        .accessibilityIdentifier("UsdtReceiveAddress")
+                } else if let error { BodySText(error, textColor: .brandAccent) }
+                else { ProgressView() }
+                details()
+                BodySText(warning, textColor: .textSecondary)
+            }
+        }
+        CustomButton(title: t(showDetails ? "wallet__receive_show_qr" : "common__show_details"),
+                     variant: showDetails ? .primary : .tertiary,
+                     icon: showDetails ? Image("qr").resizable().frame(width: 16, height: 16) : nil, shouldExpand: true)
+        {
+            showDetails.toggle()
+        }.accessibilityIdentifier("UsdtReceiveDetails")
+    }
+}
+
+extension UsdtReceiveAddressContent where Details == EmptyView {
+    init(address: String, uri: String, warning: String, error: String? = nil) {
+        self.address = address; self.uri = uri; self.warning = warning; self.error = error; details = { EmptyView() }
+    }
+}
+
+private struct UsdtDepositReceiveView: View {
+    let network: UsdtDepositNetwork
+    @Environment(UsdtWalletManager.self) private var usdt
+    @State private var amount = ""
+    @State private var deposit: UsdtDepositAddress?
+    @State private var busy = false
+    @State private var error: String?
+
+    var body: some View {
+        if let deposit {
+            UsdtReceiveAddressContent(address: deposit.address, uri: deposit.uri, warning: t("usdt__deposit_notice")) {
+                SendSectionView(t("usdt__deposit_estimate")) { BodySSBText(usdtFormatAmount(amount: deposit.estimatedReceived) + " USDT") }
+                SendSectionView(t("usdt__deposit_cost")) {
+                    BodySSBText(deposit.amount >= deposit
+                        .estimatedReceived ? usdtFormatAmount(amount: deposit.amount - deposit.estimatedReceived) + " USDT" : "—")
+                }
+                BodySText(t("usdt__deposit_estimate_note"), textColor: .textSecondary)
+                SendSectionView(t("usdt__deposit_limits")) {
+                    BodySSBText((deposit.minUsdCents?.usdCents ?? "—") + " – " + (deposit.maxUsdCents?.usdCents ?? "—"))
+                }
+                BodySText(t("usdt__deposit_limits_note"), textColor: .textSecondary)
+                CustomButton(title: t("usdt__deposit_refresh"), variant: .secondary, shouldExpand: true) { self.deposit = nil }
+            }
+        } else {
+            VStack(alignment: .leading, spacing: 0) {
+                CaptionMText(t("usdt__deposit_amount")).padding(.bottom, 12)
+                NumberPadAmountText(value: amount.isEmpty ? "0" : amount, symbol: "₮")
+                Spacer(minLength: 16)
+                BodySText(error ?? t("usdt__deposit_fee_note"), textColor: error == nil ? .textSecondary : .brandAccent)
+                    .padding(.bottom, 16)
+                Divider()
+                NumberPad(type: .decimal, isDisabled: busy, onDeleteLongPress: { amount = "" }) { key in
+                    amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
+                }
+                CustomButton(title: t("usdt__deposit_create"), isDisabled: busy || amount.isEmpty, isLoading: busy) {
+                    busy = true; error = nil
+                    defer { busy = false }
+                    do { deposit = try await usdt.prepareDeposit(network: network, amount: amount) }
+                    catch { self.error = UsdtWalletManager.message(for: error) }
+                }.accessibilityIdentifier("UsdtDepositCreate")
+            }
+            .onChange(of: amount) { error = nil }
+        }
+    }
+}
+
+extension UsdtDepositNetwork {
+    var label: String {
+        switch self {
+        case .ethereum: "Ethereum"
+        case .solana: "Solana"
+        case .polygon: "Polygon"
+        case .bsc: "BNB Smart Chain"
+        case .base: "Base"
+        case .tron: "Tron"
+        }
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
new file mode 100644
index 000000000..6fabe892b
--- /dev/null
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -0,0 +1,449 @@
+import BitkitCore
+import PhotosUI
+import SwiftUI
+
+struct UsdtSendView: View {
+    var onDetails: (String) -> Void
+    var initialRecipient = ""
+    var initialAmount = ""
+    var embedded = false
+    var sendPayment: ((UsdtQuote) async throws -> Void)?
+    var onBack: (() -> Void)?
+    var onClose: (() -> Void)?
+    @Environment(UsdtWalletManager.self) private var usdt
+    @EnvironmentObject private var currency: CurrencyViewModel
+    @EnvironmentObject private var settings: SettingsViewModel
+    @Environment(\.dismiss) private var dismiss
+    @Environment(\.scenePhase) private var scenePhase
+    @State private var recipient = ""
+    @State private var amount = ""
+    @State private var destination: UsdtDestination = .arbitrum
+    @State private var destinations = Env.usdtDestinations
+    @State private var quote: UsdtQuote?
+    @State private var editingRecipient = false
+    @State private var editingAmount = false
+    @State private var busy = false
+    @State private var error: String?
+    @State private var pin = false
+    @State private var submitted = false
+    @State private var showDetails = false
+    @State private var warning: String?
+    @State private var confirmedWarnings: Set<String> = []
+    @State private var swipeProgress: CGFloat = 0
+    @FocusState private var recipientFocused: Bool
+
+    init(
+        onDetails: @escaping (String) -> Void,
+        initialRecipient: String = "",
+        initialAmount: String = "",
+        embedded: Bool = false,
+        sendPayment: ((UsdtQuote) async throws -> Void)? = nil,
+        onBack: (() -> Void)? = nil,
+        onClose: (() -> Void)? = nil
+    ) {
+        self.onDetails = onDetails
+        self.initialRecipient = initialRecipient
+        self.initialAmount = initialAmount
+        self.embedded = embedded
+        self.sendPayment = sendPayment
+        self.onBack = onBack
+        self.onClose = onClose
+        _recipient = State(initialValue: initialRecipient)
+        _amount = State(initialValue: initialAmount)
+        _editingAmount = State(initialValue: !initialRecipient.isEmpty)
+    }
+
+    private var submittedStatus: UsdtTransferStatus? {
+        usdt.transfers.first { $0.id == quote?.id }?.status
+    }
+
+    private var submissionFailed: Bool {
+        submittedStatus == .failed || submittedStatus == .replaced
+    }
+
+    private var bridgeNeedsAttention: Bool {
+        submittedStatus == .bridgeNeedsAttention || submittedStatus == .bridgeFailed
+    }
+
+    private var title: String {
+        if submitted, !busy {
+            if submittedStatus == .confirmed { return t("usdt__payment_sent") }
+            if submittedStatus == .bridgeRefunded { return t("usdt__deposit_refunded") }
+            if bridgeNeedsAttention { return t("usdt__bridge_attention") }
+            return t(submissionFailed ? "wallet__send_error_tx_failed" : "usdt__submitted")
+        }
+        if quote != nil { return t("wallet__send_review") }
+        return t(editingAmount ? "usdt__amount" : "usdt__send_title")
+    }
+
+    var body: some View {
+        Group {
+            if embedded { content }
+            else { NavigationStack { content } }
+        }
+        .task {
+            if !embedded {
+                do { destinations = try await usdt.sendDestinations() }
+                catch { Logger.warn("Could not load USDT bridge destinations", context: "UsdtSendView") }
+            }
+            guard !initialRecipient.isEmpty, quote == nil else { return }
+            busy = true
+            defer { busy = false }
+            do { quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination) }
+            catch { self.error = UsdtWalletManager.message(for: error) }
+        }
+    }
+
+    private var content: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            SheetHeader(title: title, showBackButton: !submitted, onBack: goBack).disabled(busy)
+            if submitted, !busy { submittedContent }
+            else if let quote { confirmation(quote) }
+            else if editingAmount { amountContent }
+            else if editingRecipient { manualContent }
+            else { recipientContent }
+        }
+        .padding(.horizontal, 16)
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .background {
+            if submitted, !busy, submittedStatus == .confirmed {
+                PaymentCelebration(isOnchain: true, isReceived: false, confettiColor: .greenAccent)
+            }
+        }
+        .sheetBackground()
+        .navigationBarHidden(true)
+        .navigationDestination(isPresented: $pin) {
+            SendPinScreen(onCancel: { pin = false }, onPinVerified: {
+                pin = false
+                Task { await send() }
+            })
+        }
+        .task(id: "\(scenePhase == .active)-\(submitted)") {
+            guard scenePhase == .active, submitted else { return }
+            if busy, let quote {
+                if quote.destination == .arbitrum { await usdt.waitForTransfer(quote.id) }
+                busy = false
+            }
+            while !Task.isCancelled, [.pending, .bridging, .bridgeNeedsAttention].contains(submittedStatus) {
+                await usdt.refresh()
+                do { try await Task.sleep(for: .seconds(10)) } catch { return }
+            }
+            await PaykitUsdtPaymentService.shared.reconcile(wallet: usdt)
+        }
+        .onAppear { usdt.isSendPresented = true }
+        .onDisappear { usdt.isSendPresented = false }
+        .interactiveDismissDisabled(busy || pin)
+        .alert(t("common__are_you_sure"), isPresented: Binding(
+            get: { warning != nil },
+            set: { if !$0 { warning = nil } }
+        ), presenting: warning) { warning in
+            Button(t("common__cancel"), role: .cancel) { self.warning = nil }
+            Button(t("wallet__send_yes")) {
+                confirmedWarnings.insert(warning)
+                self.warning = nil
+                Task { await confirmPayment() }
+            }
+        } message: { warning in
+            Text(t(warning))
+        }
+    }
+
+    private var networkSelector: some View {
+        SendSectionView(t("usdt__destination")) {
+            if !embedded, destinations.count > 1 {
+                Menu {
+                    ForEach(destinations, id: \.self) { item in
+                        Button(item.label) {
+                            guard destination != item else { return }
+                            destination = item
+                            recipient = ""
+                            amount = ""
+                            quote = nil
+                            error = nil
+                        }
+                    }
+                } label: {
+                    NumberPadActionButton(text: destination.label, color: .greenAccent, variant: .secondary) {}
+                }
+                .accessibilityIdentifier("UsdtNetwork")
+            } else {
+                BodySSBText(destination.label)
+                    .frame(minHeight: 28)
+                    .accessibilityIdentifier("UsdtNetwork")
+            }
+        }
+    }
+
+    private var recipientContent: some View {
+        VStack(spacing: 8) {
+            networkSelector.padding(.bottom, 8)
+            Scanner(onScan: { payload in if let value = payload.string { useRecipient(value) } }, onImageSelection: readImage)
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+            RectangleButton(
+                icon: "clipboard", iconColor: .greenAccent, title: t("common__paste"), testID: "UsdtPaste"
+            ) {
+                if let value = UIPasteboard.general.string, !value.isEmpty { useRecipient(value) }
+                else { error = t("wallet__send_clipboard_empty_text") }
+            }
+            RectangleButton(
+                icon: "pencil", iconColor: .greenAccent, title: t("wallet__recipient_manual"), testID: "UsdtManual"
+            ) { editingRecipient = true }
+            if let error { BodySText(error, textColor: .brandAccent) }
+            BodySText(t("usdt__network_warning"), textColor: .textSecondary).padding(.top, 8)
+        }
+    }
+
+    private var manualContent: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            networkSelector.padding(.bottom, 8)
+            CaptionMText(t("wallet__send_to"))
+            PaymentAddressInput(
+                text: $recipient, isFocused: $recipientFocused,
+                placeholder: t("usdt__address"), testIdentifier: "UsdtRecipient"
+            )
+            if let error {
+                BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError")
+            }
+            Spacer(minLength: 16)
+            CustomButton(title: t("common__continue"), isDisabled: recipient.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty) {
+                useRecipient(recipient)
+            }
+            .buttonBottomPadding(isFocused: recipientFocused)
+            .accessibilityIdentifier("UsdtRecipientContinue")
+        }
+        .task { recipientFocused = true }
+    }
+
+    private var amountContent: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            CaptionMText("USDT · " + destination.label).padding(.bottom, 8)
+            NumberPadAmountText(value: amount.isEmpty ? "0" : amount, symbol: "₮")
+                .accessibilityIdentifier("UsdtAmount")
+            Spacer(minLength: 16)
+            if let error {
+                BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError").padding(.bottom, 16)
+            }
+            HStack(alignment: .bottom) {
+                VStack(alignment: .leading, spacing: 4) {
+                    CaptionMText(t("usdt__balance"))
+                    BodySSBText((settings.hideBalance ? " • • • • •" : usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—") + " USDT")
+                }
+                Spacer()
+                NumberPadActionButton(text: "USDT", color: .greenAccent, variant: .secondary, disabled: true) {}
+            }
+            .padding(.bottom, 12)
+            CustomDivider()
+            NumberPad(type: .decimal, isDisabled: busy || embedded, onDeleteLongPress: { amount = "" }, onPress: enterAmount)
+            CustomButton(title: t("common__continue"), isDisabled: busy || amount.isEmpty, isLoading: busy) {
+                guard !busy, quote == nil else { return }
+                busy = true
+                error = nil
+                defer { busy = false }
+                do {
+                    quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination)
+                    showDetails = false
+                    confirmedWarnings = []
+                } catch is CancellationError {
+                } catch {
+                    self.error = UsdtWalletManager.message(for: error)
+                    Logger.warn("Failed to quote USDT: \(UsdtWalletManager.message(for: error))", context: "UsdtSendView")
+                }
+            }
+            .accessibilityIdentifier("UsdtReview")
+        }
+    }
+
+    private func confirmation(_ quote: UsdtQuote) -> some View {
+        VStack(alignment: .leading, spacing: 0) {
+            ScrollView(showsIndicators: false) {
+                VStack(alignment: .leading, spacing: 0) {
+                    UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), network: quote.destination.label)
+                        .contentShape(Rectangle()).onTapGesture { if !busy { goBack() } }
+                        .padding(.bottom, 32)
+                    if showDetails {
+                        VStack(alignment: .leading, spacing: 16) {
+                            HStack(alignment: .top, spacing: 16) {
+                                SendSectionView(t("wallet__send_from")) {
+                                    NumberPadActionButton(text: "USDT", color: .greenAccent, variant: .secondary, disabled: true) {}
+                                }
+                                SendSectionView(t("usdt__destination")) { BodySSBText(quote.destination.label).frame(height: 28) }
+                            }
+                            SendSectionView(t("wallet__send_to")) { BodySSBText(quote.recipient).textSelection(.enabled) }
+                            if let provider = quote.bridgeProvider {
+                                SendSectionView(t("usdt__bridge_provider")) { BodySSBText(provider == .orchestra ? "Orchestra" : "USDT0") }
+                            }
+                        }
+                    } else {
+                        PaymentReviewIllustration(swipeProgress: swipeProgress, maximumHeight: 220)
+                    }
+                }
+            }
+            if quote.destination != .arbitrum {
+                SendSectionView(t(quote.bridgeProvider == .orchestra ? "usdt__expected_amount" : "usdt__recipient_gets")) {
+                    BodySSBText(usdtFormatAmount(amount: quote.receivedAmount) + " USDT")
+                }.padding(.top, 16)
+                if quote.bridgeProvider == .orchestra {
+                    SendSectionView(t("usdt__bridge_deducted_fee")) {
+                        BodySSBText(usdtFormatAmount(amount: quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
+                    }.padding(.top, 16)
+                }
+            }
+            SendSectionView(t("usdt__maximum_fee")) {
+                BodySSBText(usdtFormatAmount(amount: quote.maximumFee) + " USDT")
+            }
+            .padding(.top, 16)
+            if quote.destination != .arbitrum {
+                SendSectionView(t("usdt__maximum_total")) { BodySSBText(usdtFormatAmount(amount: quote.amount + quote.maximumFee) + " USDT") }
+                    .padding(.top, 16)
+            }
+            BodySText(t(quote.bridgeProvider == .orchestra ? "usdt__bridge_estimate_note" : "usdt__fee_note"), textColor: .textSecondary).padding(
+                .top,
+                12
+            )
+            if let error { BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError") }
+            CustomButton(
+                title: t(showDetails ? "common__hide_details" : "common__show_details"), size: .small,
+                icon: Image(showDetails ? "eye-slash" : "coins").foregroundColor(.greenAccent), background: Color(hex: 0x151515)
+            ) { showDetails.toggle() }
+                .frame(maxWidth: .infinity).padding(.vertical, 24)
+                .accessibilityIdentifier("UsdtReviewDetails")
+            SwipeButton(
+                title: t("wallet__send_swipe"), accentColor: .greenAccent, isDisabled: busy, isLoading: busy, swipeProgress: $swipeProgress
+            ) {
+                await confirmPayment()
+                if !submitted { throw CancellationError() }
+            }
+            .accessibilityElement(children: .contain)
+            .accessibilityIdentifier("UsdtConfirm")
+        }
+    }
+
+    private var submittedContent: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            if let quote {
+                UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), network: quote.destination.label).padding(.bottom, 32)
+            }
+            if submittedStatus == .bridgeRefunded {
+                BodyMText(t("usdt__bridge_refunded_description"), textColor: .textSecondary)
+            } else if submittedStatus != .confirmed {
+                BodyMText(t(bridgeNeedsAttention ? "usdt__bridge_attention" : submissionFailed ? "usdt__send_failed_description"
+                              : quote?.destination == .arbitrum ? "usdt__submitted_description" : "usdt__bridge_submitted_description"),
+                textColor: .textSecondary)
+            }
+            Spacer(minLength: 16)
+            if submittedStatus == .confirmed {
+                Image("check").resizable().aspectRatio(contentMode: .fit)
+                    .frame(width: 256, height: 256).padding()
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                    .accessibilityIdentifier("UsdtSendSuccess")
+            } else if !submissionFailed, !bridgeNeedsAttention, submittedStatus != .bridgeRefunded {
+                HourglassLoadingView()
+            }
+            Spacer(minLength: 16)
+            HStack(spacing: 16) {
+                CustomButton(title: t("wallet__send_details"), variant: .secondary, isDisabled: quote == nil, shouldExpand: true) {
+                    if let quote { onDetails(quote.id) }
+                }
+                CustomButton(title: t("common__close"), shouldExpand: true) {
+                    if let onClose { onClose() } else { dismiss() }
+                }
+            }
+        }
+    }
+
+    private func useRecipient(_ value: String) {
+        guard !editingAmount, quote == nil, !submitted else { return }
+        do {
+            let request: UsdtPaymentRequest = if value.contains(":") { try usdtParsePaymentRequest(value: value) }
+            else { try UsdtPaymentRequest(recipient: usdtValidateRecipient(value: value, destination: destination), amount: nil, chainId: nil) }
+            guard request.chainId == nil || destination == .arbitrum else { throw UsdtError.WrongNetwork }
+            recipient = request.recipient
+            amount = request.amount.map { usdtFormatAmount(amount: $0) } ?? ""
+        } catch { self.error = UsdtWalletManager.message(for: error); return }
+        recipientFocused = false
+        editingAmount = true
+        error = nil
+    }
+
+    private func readImage(_ item: PhotosPickerItem?) async {
+        guard let item else { return }
+        do {
+            let payload = try await QRCodeImageDecoder.decode(item)
+            guard let value = payload.string else { throw QRCodeImageDecoderError.noQRCode }
+            useRecipient(value)
+        } catch is CancellationError {
+        } catch QRCodeImageDecoderError.invalidImage {
+            error = t("other__qr_error_load_image")
+        } catch {
+            self.error = t("other__qr_error_process_image")
+        }
+    }
+
+    private func goBack() {
+        guard !busy else { return }
+        if let onBack { onBack(); return }
+        if quote != nil { quote = nil }
+        else if editingAmount { editingAmount = false; editingRecipient = true }
+        else if editingRecipient { editingRecipient = false }
+        else { dismiss() }
+        error = nil
+    }
+
+    private func enterAmount(_ key: String) {
+        guard !busy else { return }
+        amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
+    }
+
+    private func confirmPayment() async {
+        guard let quote, !busy, !submitted else { return }
+        var warnings: [String] = []
+        if let balance = usdt.balance, quote.amount > balance / 2 { warnings.append("wallet__send_dialog2") }
+        if settings.warnWhenSendingOver100, quote.amount > 100_000_000 { warnings.append("wallet__send_dialog1") }
+        if quote.maximumFee > 10_000_000 { warnings.append("wallet__send_dialog4") }
+        if quote.maximumFee > quote.amount / 2 { warnings.append("wallet__send_dialog3") }
+        if let next = warnings.first(where: { !confirmedWarnings.contains($0) }) {
+            warning = next
+            return
+        }
+        await authenticateAndSend()
+    }
+
+    private func authenticateAndSend() async {
+        guard !busy else { return }
+        if settings.requirePinForPayments && settings.pinEnabled {
+            guard settings.useBiometrics && BiometricAuth.isAvailable else {
+                pin = true
+                return
+            }
+            busy = true
+            let result = await BiometricAuth.authenticate()
+            busy = false
+            switch result {
+            case .success: await send()
+            case .cancelled: break
+            case let .failed(message): error = message
+            }
+        } else {
+            await send()
+        }
+    }
+
+    private func send() async {
+        guard let quote, !busy else { return }
+        let paymentActivity = PaykitPaymentActivity.shared.begin()
+        defer { PaykitPaymentActivity.shared.end(paymentActivity) }
+        busy = true
+        error = nil
+        defer { if !submitted { busy = false } }
+        do {
+            if let sendPayment { try await sendPayment(quote) }
+            else { try await usdt.send(quote) }
+            submitted = true
+            Task { await PaykitUsdtPaymentService.shared.reconcile(wallet: usdt) }
+        } catch is CancellationError {} catch {
+            self.error = UsdtWalletManager.message(for: error)
+            self.quote = nil
+            Logger.warn("Failed to send USDT: \(UsdtWalletManager.message(for: error))", context: "UsdtSendView")
+        }
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
new file mode 100644
index 000000000..0c4b27adc
--- /dev/null
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -0,0 +1,136 @@
+import BitkitCore
+import SwiftUI
+
+struct UsdtWalletScreen: View {
+    @Environment(UsdtWalletManager.self) private var usdt
+    @EnvironmentObject private var settings: SettingsViewModel
+    @EnvironmentObject private var sheets: SheetViewModel
+    @State private var showSend = false
+    @State private var selectedTransferId: String?
+
+    var body: some View {
+        ZStack(alignment: .top) {
+            ScrollView(showsIndicators: false) {
+                VStack(alignment: .leading, spacing: 32) {
+                    UsdtAmountHeader(
+                        amount: usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—",
+                        network: usdt.networkName, hideBalance: settings.hideBalance
+                    )
+                    .balanceVisibilityToggle()
+                    .accessibilityIdentifier("UsdtBalance")
+                    HStack(spacing: 16) {
+                        CustomButton(
+                            title: t("usdt__receive"), variant: .secondary,
+                            icon: Image("arrow-down").foregroundColor(.greenAccent), shouldExpand: true
+                        ) { sheets.showSheet(.receive, data: ReceiveConfig(view: .usdt)) }
+                            .accessibilityIdentifier("UsdtReceive")
+                        CustomButton(
+                            title: t("usdt__send"),
+                            icon: Image("arrow-up").foregroundColor(.greenAccent), shouldExpand: true
+                        ) { showSend = true }
+                            .accessibilityIdentifier("UsdtSend")
+                    }
+                    if let error = usdt.errorMessage { BodySText(error, textColor: .brandAccent) }
+                    activityList
+                }
+            }
+            .contentMargins(.top, ScreenLayout.topPaddingWithoutSafeArea)
+            .contentMargins(.bottom, ScreenLayout.bottomPaddingWithSafeArea)
+            .refreshable { await usdt.refresh(includeHistory: true) }
+            NavigationBar(title: "USDT")
+        }
+        .padding(.horizontal, 16)
+        .navigationBarHidden(true)
+        .onReceive(usdt.receivedTxPublisher) { tx in
+            guard !showSend, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
+            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount))
+        }
+        .sheet(isPresented: $showSend) {
+            Sheet(id: .send, data: SendSheetItem()) {
+                UsdtSendView { id in
+                    showSend = false
+                    selectedTransferId = id
+                }
+            }
+        }
+        .navigationDestination(isPresented: Binding(
+            get: { selectedTransferId != nil },
+            set: { if !$0 { selectedTransferId = nil } }
+        )) {
+            if let id = selectedTransferId { UsdtActivityDetail(transferId: id) }
+        }
+    }
+
+    private var activityList: some View {
+        LazyVStack(alignment: .leading, spacing: 16) {
+            if usdt.transfers.isEmpty {
+                CaptionMText(t("usdt__activity"))
+                RectangleButton(icon: "heartbeat", iconColor: .yellowAccent, title: t("usdt__empty"), testID: "UsdtEmptyActivity") {
+                    sheets.showSheet(.receive, data: ReceiveConfig(view: .usdt))
+                }
+            }
+            ForEach(Array(usdt.transfers.enumerated()), id: \.element.id) { index, transfer in
+                let header = transfer.groupTitle
+                if index == 0 || usdt.transfers[index - 1].groupTitle != header {
+                    CaptionMText(header).frame(height: 34, alignment: .bottom)
+                }
+                Button { selectedTransferId = transfer.id } label: {
+                    UsdtActivityRow(transfer: transfer, hideBalance: settings.hideBalance)
+                }
+                .buttonStyle(.plain)
+                .accessibilityIdentifier("UsdtActivity-\(index)")
+            }
+            if !usdt.historyComplete { BodySText(t("usdt__history_sync"), textColor: .textSecondary) }
+        }
+    }
+}
+
+struct UsdtAmountHeader: View {
+    let amount: String
+    let network: String
+    var prefix = ""
+    var hideBalance = false
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            CaptionMText("USDT · " + network, textColor: .textSecondary)
+            DisplayText(
+                "<accent>\(prefix)₮</accent> " + (hideBalance ? " • • • • •" : amount),
+                accentColor: .textSecondary, accentFont: Fonts.extraBold
+            )
+            .lineLimit(1).minimumScaleFactor(0.5)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+}
+
+@MainActor
+extension UsdtDestination {
+    var label: String {
+        switch self {
+        case .stable: "Stable"
+        case .ethereum: "Ethereum"
+        case .arbitrum: "Arbitrum One"
+        case .polygon: "Polygon"
+        case .plasma: "Plasma"
+        case .base: "Base"
+        case .bsc: "BNB Smart Chain"
+        case .solana: "Solana"
+        case .tron: "Tron"
+        }
+    }
+}
+
+extension UsdtTransferStatus {
+    var label: String {
+        switch self {
+        case .pending: t("usdt__pending")
+        case .confirmed: t("usdt__confirmed")
+        case .failed: t("usdt__failed")
+        case .bridging: t("usdt__bridging")
+        case .bridgeNeedsAttention, .bridgeFailed: t("usdt__bridge_attention")
+        case .replaced: t("usdt__replaced")
+        case .bridgeRefunded: t("usdt__deposit_refunded")
+        }
+    }
+}
diff --git a/BitkitTests/PaykitAmountTests.swift b/BitkitTests/PaykitAmountTests.swift
new file mode 100644
index 000000000..59df345c1
--- /dev/null
+++ b/BitkitTests/PaykitAmountTests.swift
@@ -0,0 +1,47 @@
+@testable import Bitkit
+import Foundation
+import XCTest
+
+final class PaykitAmountTests: XCTestCase {
+    private let now = Date(timeIntervalSince1970: 1_800_000_000)
+    private var rate: PaykitExchangeRate {
+        PaykitExchangeRate(price: "100000", timestamp: now)
+    }
+
+    func testConversionPreservesValueAndRoundsPaymentUnitsUpward() throws {
+        let cases: [(PaykitAsset, String, PaykitAsset, String)] = [
+            (.usd, "5", .usdt, "5"),
+            (.usdt, "5.000001", .usd, "5.01"),
+            (.btc, "0.00000001", .usdt, "0.001"),
+            (.usd, "5", .btc, "0.00005"),
+            (.usdt, "0.000001", .btc, "0.00000001"),
+        ]
+        for (source, value, target, expected) in cases {
+            XCTAssertEqual(try PaykitAmount(asset: source, value: value).converted(to: target, rate: rate, at: now).value, expected)
+        }
+    }
+
+    func testStaleMissingAndFutureRatesBlockOnlyBitcoinConversions() throws {
+        let amount = try PaykitAmount(asset: .usd, value: "5")
+        let invalidRates: [PaykitExchangeRate?] = [nil,
+                                                   PaykitExchangeRate(price: "100000", timestamp: now.addingTimeInterval(-601)),
+                                                   PaykitExchangeRate(price: "100000", timestamp: now.addingTimeInterval(1)),
+                                                   PaykitExchangeRate(price: "0", timestamp: now), PaykitExchangeRate(price: "NaN", timestamp: now)]
+        for invalid in invalidRates {
+            XCTAssertThrowsError(try amount.converted(to: .btc, rate: invalid, at: now))
+            XCTAssertEqual(try amount.converted(to: .usdt, rate: invalid, at: now).value, "5")
+        }
+        XCTAssertEqual(
+            try amount.converted(to: .btc, rate: PaykitExchangeRate(price: "100000", timestamp: now.addingTimeInterval(-600)), at: now).value,
+            "0.00005"
+        )
+    }
+
+    func testParsingEnforcesPositiveExactDecimalsAndAtomicBounds() throws {
+        for value in ["", "0", "-1", "+1", "1e2", "1,2", ".5", "5.", "0.0000001", "18446744073710"] {
+            XCTAssertThrowsError(try PaykitAmount(asset: .usdt, value: value))
+        }
+        XCTAssertEqual(try PaykitAmount(asset: .usdt, value: "01.23000000").value, "1.23")
+        XCTAssertEqual(try PaykitAmount(asset: .usdt, value: "18446744073709.551615").atomic, UInt64.max)
+    }
+}
diff --git a/BitkitTests/PaykitPaymentProofServiceTests.swift b/BitkitTests/PaykitPaymentProofServiceTests.swift
index 00b4e727b..2120918b5 100644
--- a/BitkitTests/PaykitPaymentProofServiceTests.swift
+++ b/BitkitTests/PaykitPaymentProofServiceTests.swift
@@ -1120,7 +1120,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             store: store
         )
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
 
         let protectedRequestIds = try await service.protectedRequestIdsForSubscriptionCancellation(
             identity: identity,
@@ -1178,7 +1178,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let txid = String(repeating: "ab", count: 32)
 
         try await service.prepare(request: request, paymentAppId: "paykit-server", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
         let inFlightRequestIds = await service.inFlightRequestIds(identity: identity)
         XCTAssertEqual(inFlightRequestIds, [request.id])
         try await recordAcceptedAttempt(service: service, request: request, txid: String(repeating: "ab", count: 32))
@@ -1268,7 +1268,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let service = paymentProofService(sdk: PaymentProofSdkMock(identity: identity, records: [record]), store: store)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
         await service.cancelPreparation(request)
 
         let storedProofs = await store.snapshot()
@@ -1305,7 +1305,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let service = paymentProofService(sdk: sdk, store: store)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
         await service.reconcile()
 
         let submissionCount = await sdk.submissionCount()
@@ -1891,7 +1891,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             paymentIdentifier: nil,
             proofData: nil,
             onchainAddress: onchainAddress,
-            onchainAmountSats: request.amountSats,
+            onchainAmountSats: request.amount.atomic,
             onchainWalletId: "trezor:android",
             onchainMatchingTransactionIdsBeforeAttempt: []
         )
@@ -1945,7 +1945,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             paymentIdentifier: nil,
             proofData: nil,
             onchainAddress: onchainAddress,
-            onchainAmountSats: request.amountSats,
+            onchainAmountSats: request.amount.atomic,
             onchainWalletId: "trezor:android",
             onchainMatchingTransactionIdsBeforeAttempt: []
         )
@@ -2120,7 +2120,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             paymentIdentifier: txid,
             proofData: txid,
             onchainAddress: onchainAddress,
-            onchainAmountSats: request.amountSats,
+            onchainAmountSats: request.amount.atomic,
             onchainWalletId: "trezor:android",
             onchainMatchingTransactionIdsBeforeAttempt: []
         )
@@ -2246,7 +2246,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             paymentIdentifier: nil,
             proofData: nil,
             onchainAddress: onchainAddress,
-            onchainAmountSats: onchainRequest.amountSats,
+            onchainAmountSats: onchainRequest.amount.atomic,
             onchainMatchingTransactionIdsBeforeAttempt: []
         )
         let lightningProof = PendingPaykitPaymentProof(
@@ -2387,7 +2387,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let service = paymentProofService(sdk: PaymentProofSdkMock(identity: identity, records: [record]), store: store)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
         await service.failOnchainPayment(request)
 
         let storedProofs = await store.snapshot()
@@ -2402,7 +2402,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let sdk = PaymentProofSdkMock(identity: identity, records: [record])
         let service = paymentProofService(sdk: sdk, store: store)
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
         await sdk.setIdentityAvailable(false)
 
         await service.failOnchainPayment(request)
@@ -2580,7 +2580,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let service = paymentProofService(sdk: sdk, store: store)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
         await store.failNextSave()
         try await recordAcceptedAttempt(service: service, request: request, txid: String(repeating: "ab", count: 32))
         await service.completeOnchainPayment(
@@ -2606,7 +2606,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let txid = String(repeating: "ab", count: 32)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
         await store.failNextSave()
         try await recordAcceptedAttempt(service: service, request: request, txid: String(repeating: "ab", count: 32))
         await service.completeOnchainPayment(request, txid: txid, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint)
@@ -2627,7 +2627,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let txid = String(repeating: "ab", count: 32)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
         await store.failNextLoad()
         try await recordAcceptedAttempt(service: service, request: request, txid: String(repeating: "ab", count: 32))
         await service.completeOnchainPayment(request, txid: txid, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint)
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index 57085dfce..85a24466c 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -642,7 +642,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                     return endpoints
                 }
             )
-            guard case let .opened(target, context) = result else { return XCTFail("Expected the bound invoice") }
+            guard case let .opened(target, context, _) = result else { return XCTFail("Expected the bound invoice") }
             XCTAssertEqual(target, address)
             let paymentContext = try XCTUnwrap(context)
             XCTAssertNil(paymentContext.paymentListVersion)
@@ -741,7 +741,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             )
             XCTAssertEqual(usageChecks, testCase.opens ? 0 : 1)
             if testCase.opens {
-                guard case let .opened(target, context) = result else { return XCTFail("Expected the recurring fixed address") }
+                guard case let .opened(target, context, _) = result else { return XCTFail("Expected the recurring fixed address") }
                 XCTAssertEqual(target, address)
                 XCTAssertNil(try XCTUnwrap(context).paymentListVersion)
             } else {
@@ -1301,7 +1301,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertTrue(manager.subscriptions.isEmpty)
         let sections = subscriptionSections(subscriptions: manager.subscriptions, now: now)
         XCTAssertTrue(sections.active.isEmpty && sections.created.isEmpty && sections.expired.isEmpty)
-        XCTAssertEqual(subscriptionMonthlyCostSats(subscriptions: manager.subscriptions, now: now), 0)
+        XCTAssertEqual(subscriptionMonthlyCosts(subscriptions: manager.subscriptions, now: now).first?.atomic, 0)
     }
 
     func testBlockingAnAlreadyPresentedAcceptedRequestPreventsPayment() async throws {
@@ -1426,8 +1426,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let request = try XCTUnwrap(manager.pendingRequests.first)
         XCTAssertEqual(manager.pendingRequests.count, 1)
         XCTAssertEqual(request.paymentRequestId, record.paymentRequestId)
-        XCTAssertEqual(request.amountValue, "0.00100000000")
-        XCTAssertEqual(request.amountSats, 100_000)
+        XCTAssertEqual(request.amountValue, "0.001")
+        XCTAssertEqual(request.amount.atomic, 100_000)
         XCTAssertEqual(
             request.acceptedPaymentEndpointIdentifiers,
             [PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue, currentOnchain.rawValue]
@@ -1805,7 +1805,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             paymentRequestRecord(id: "malformed-expiry", expiresAt: "not-a-timestamp"),
             paymentRequestRecord(id: "wrong-role", role: .payee),
             paymentRequestRecord(id: "recurring", recurrence: recurrence),
-            paymentRequestRecord(id: "wrong-asset", asset: "usd"),
+            paymentRequestRecord(id: "wrong-asset", asset: "eth"),
             paymentRequestRecord(id: "sub-satoshi", amount: "0.000000001"),
             paymentRequestRecord(id: "zero", amount: "0"),
             paymentRequestRecord(id: "unsupported-endpoint", endpoints: ["btc-unsupported-method"]),
@@ -1842,7 +1842,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
         await manager.refresh()
 
-        XCTAssertEqual(manager.pendingRequests.map(\.paymentRequestId), ["incoming"])
+        XCTAssertEqual(manager.pendingRequests.map(\.paymentRequestId), ["incoming", "deadline-proposed"])
         XCTAssertEqual(
             Set(manager.historyRequests.map(\.paymentRequestId)),
             Set([
@@ -2182,14 +2182,12 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         await manager.refreshEligibleTargets(savedPublicKeys: [publicKey])
 
         let subscription = try await manager.proposeSubscription(
-            PaykitSubscriptionDraft(
-                amountSats: 100_000,
-                name: " Monthly support ",
-                description: " Thank you ",
-                frequency: .month,
-                expiresAt: expiresAt,
-                iconData: nil
-            ),
+            PaykitSubscriptionDraft(amount: PaykitAmount(asset: .btc, atomic: 100_000),
+                                    name: " Monthly support ",
+                                    description: " Thank you ",
+                                    frequency: .month,
+                                    expiresAt: expiresAt,
+                                    iconData: nil),
             to: XCTUnwrap(manager.eligibleTargets.first)
         )
 
@@ -2197,6 +2195,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let proposed = try XCTUnwrap(snapshot.proposedRequests.first)
         XCTAssertEqual(proposed.amount, "0.001")
         XCTAssertEqual(proposed.asset, PaykitIssuerInterop.bitcoinAsset)
+        XCTAssertFalse(proposed.endpointIdentifiers.contains(PublicPaykitService.MethodId.usdtArbitrum.rawValue))
+        XCTAssertNil(subscription.pricing.conversion)
         XCTAssertEqual(proposed.expiresAt, timestamp(expiresAt))
         XCTAssertEqual(proposed.recurrence?.every, 1)
         XCTAssertEqual(proposed.recurrence?.unit, "month")
@@ -2213,6 +2213,48 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertEqual(manager.subscriptions, [subscription])
     }
 
+    func testDollarSubscriptionRequiresUsdtReceivingAndFixesParityForFuturePayments() async throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let publicKey = "pubky\(String(repeating: "y", count: 52))"
+        let key = PublicPaykitService.usdtPaymentOptionEnabledKey
+        let original = UserDefaults.standard.object(forKey: key)
+        defer { UserDefaults.standard.set(original, forKey: key) }
+        for enabled in [false, true] {
+            UserDefaults.standard.set(enabled, forKey: key)
+            let sdk = PaymentRequestSdkMock(records: [])
+            await sdk.configureRecipients(
+                peers: [linkedPeer(counterparty: publicKey, state: .linked)],
+                requestCapabilitiesByPublicKey: [publicKey: true]
+            )
+            try await sdk.setProposalResult(paymentRequestRecord(role: .payee))
+            let service = PaykitPaymentRequestService(sdk: sdk, now: { now }, isPrivatePaymentPublishingEnabled: { true },
+                                                      canReceiveLightning: { true }, marketRate: { nil })
+            do {
+                let subscription = try await service.proposeSubscription(
+                    PaykitSubscriptionDraft(amount: PaykitAmount(asset: .usd, atomic: 500), name: "Monthly support",
+                                            description: "", frequency: .month, expiresAt: now.addingTimeInterval(60), iconData: nil),
+                    to: PaykitPaymentRequestTarget(publicKey: publicKey),
+                    savedPublicKeys: [publicKey], expectedIdentity: "pubky\(String(repeating: "z", count: 52))", validateBeforeProposing: {}
+                )
+                XCTAssertTrue(enabled && Env.isUsdtEnabled)
+                XCTAssertEqual(subscription.acceptedPaymentEndpointIdentifiers, [PublicPaykitService.MethodId.usdtArbitrum.rawValue])
+                XCTAssertEqual(subscription.pricing.conversion, .fixed(rates: [ConversionRate(asset: "usdt", value: "1")]))
+                let later = now.addingTimeInterval(40 * 86400)
+                let period = try XCTUnwrap(subscription.recurrence.periods(through: later, acceptedAt: PaykitPreciseInstant(date: now)).last)
+                let payment = try subscription.pricing.payment(requested: subscription.amount, asset: .usdt, period: period, at: later)
+                XCTAssertEqual(payment.amount.value, "5")
+                XCTAssertNil(payment.quoteId)
+                XCTAssertTrue(payment.isValid(at: later))
+                XCTAssertTrue(subscription.pricing.quotes.isEmpty)
+            } catch {
+                XCTAssertFalse(enabled && Env.isUsdtEnabled)
+                XCTAssertEqual(error as? PaykitPaymentRequestError, .requestUnavailable)
+                let snapshot = await sdk.snapshot()
+                XCTAssertTrue(snapshot.proposedRequests.isEmpty)
+            }
+        }
+    }
+
     func testCreatedSubscriptionSurvivesContactChangesButNotSessionChanges() async throws {
         let publicKey = "pubky\(String(repeating: "y", count: 52))"
         let otherKey = "pubky\(String(repeating: "a", count: 52))"
@@ -2231,10 +2273,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             await sdk.pauseNextProcess()
             let proposal = Task {
                 try await manager.proposeSubscription(
-                    PaykitSubscriptionDraft(
-                        amountSats: 1000, name: "Support", description: "", frequency: .month,
-                        expiresAt: now.addingTimeInterval(60), iconData: nil
-                    ),
+                    PaykitSubscriptionDraft(amount: PaykitAmount(asset: .btc, atomic: 1000), name: "Support", description: "", frequency: .month,
+                                            expiresAt: now.addingTimeInterval(60), iconData: nil),
                     to: target
                 )
             }
@@ -2282,10 +2322,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             await sdk.pauseNextUpload()
             let proposal = Task {
                 try await manager.proposeSubscription(
-                    PaykitSubscriptionDraft(
-                        amountSats: 1000, name: "Support", description: "", frequency: .month,
-                        expiresAt: now.addingTimeInterval(60), iconData: iconData
-                    ),
+                    PaykitSubscriptionDraft(amount: PaykitAmount(asset: .btc, atomic: 1000), name: "Support", description: "", frequency: .month,
+                                            expiresAt: now.addingTimeInterval(60), iconData: iconData),
                     to: target
                 )
             }
@@ -2334,14 +2372,12 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         for iconData in [nil, Data([0, 1, 2])] as [Data?] {
             do {
                 _ = try await manager.proposeSubscription(
-                    PaykitSubscriptionDraft(
-                        amountSats: 1000,
-                        name: "Support",
-                        description: String(repeating: "💜", count: 256),
-                        frequency: .month,
-                        expiresAt: now.addingTimeInterval(60),
-                        iconData: iconData
-                    ),
+                    PaykitSubscriptionDraft(amount: PaykitAmount(asset: .btc, atomic: 1000),
+                                            name: "Support",
+                                            description: String(repeating: "💜", count: 256),
+                                            frequency: .month,
+                                            expiresAt: now.addingTimeInterval(60),
+                                            iconData: iconData),
                     to: target
                 )
                 XCTFail("Oversized proposals must be rejected before external writes")
@@ -2510,7 +2546,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         await manager.refreshEligibleTargets(savedPublicKeys: [publicKey])
         let target = try XCTUnwrap(manager.eligibleTargets.first)
         var draft = PaykitSubscriptionDraft(
-            amountSats: 2000,
+            amount: PaykitAmount(asset: .btc, atomic: 2000),
             name: "Tee Club",
             description: "",
             frequency: .month,
@@ -2968,7 +3004,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         }
     }
 
-    func testDeadlineSubscriptionsKeepPaidPeriodsAndCancellationWithoutOfferingPayments() async throws {
+    func testDeadlineSubscriptionsPreserveHistoryAndEnforceEachPaymentDeadline() async throws {
         let now = try XCTUnwrap(ISO8601DateFormatter().date(from: "2027-02-15T08:00:00Z"))
         let recurrence = PaymentRequestRecurrence(
             every: 1, unit: "month", startsAt: "2027-01-01T08:00:00Z", anchor: "2027-01-01T08:00:00Z", endsAt: nil
@@ -2992,12 +3028,13 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
         await manager.refresh()
 
-        XCTAssertTrue(manager.pendingRequests.isEmpty)
+        XCTAssertEqual(manager.pendingRequests.count, 1)
+        XCTAssertFalse(try XCTUnwrap(manager.pendingRequests.first).payment(to: .btc, at: now).isValid(at: now))
         XCTAssertEqual(manager.subscriptions.count, 2)
         for subscription in manager.subscriptions {
             XCTAssertEqual(subscription.paidPeriods.count, 1)
             XCTAssertTrue(subscription.canCancel(at: now))
-            XCTAssertNil(subscription.paymentDueOnAcceptance(at: now))
+            if subscription.isPayer { XCTAssertNotNil(subscription.paymentDueOnAcceptance(at: now)) }
         }
         let paid = try XCTUnwrap(manager.historyRequests.first)
         XCTAssertEqual(manager.historyRequests.count, 1)
@@ -3010,7 +3047,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             pendingRequestIds: [], payerIdentity: "payer", notificationsEnabled: true, now: now
         )
         let pendingNotifications = await center.pendingIdentifiers
-        XCTAssertTrue(pendingNotifications.isEmpty)
+        XCTAssertFalse(pendingNotifications.isEmpty)
     }
 
     func testInFlightSubscriptionPaymentIsNotOfferedOrMarkedPaid() async throws {
@@ -3066,7 +3103,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertEqual(manager.subscriptions.count, 1)
     }
 
-    func testSubscriptionCancellationDoesNotUseStaleIdentityAfterClear() async throws {
+    func testSubscriptionCancellationBlocksPaymentAuthorizationAndDoesNotUseStaleIdentityAfterClear() async throws {
         let now = try XCTUnwrap(ISO8601DateFormatter().date(from: "2027-01-15T08:00:00Z"))
         let recurrence = PaymentRequestRecurrence(
             every: 1,
@@ -3093,8 +3130,17 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         await manager.refresh()
         let subscription = try XCTUnwrap(manager.subscriptions.first)
 
+        let request = try XCTUnwrap(manager.pendingRequests.first)
+        try await manager.prepareForPayment(request)
+        XCTAssertTrue(manager.isApprovedForPayment(request))
         let cancellation = Task { try await manager.cancel(subscription) }
         try await waitUntil { await gate.isWaiting }
+        do {
+            try await manager.ensurePaymentAllowed(request)
+            XCTFail("A cancellation already in progress must prevent payment submission")
+        } catch {
+            XCTAssertEqual(error as? PaykitPaymentRequestError, .requestUnavailable)
+        }
         manager.clear()
         manager.activate(identity: "pubky\(String(repeating: "a", count: 52))")
         await gate.resume()
@@ -3213,12 +3259,12 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         var sections = subscriptionSections(subscriptions: [canceled], now: now)
         XCTAssertEqual(sections.active.map(\.id), [canceled.id])
         XCTAssertTrue(sections.expired.isEmpty)
-        XCTAssertEqual(subscriptionMonthlyCostSats(subscriptions: [canceled], now: now), 1200)
+        XCTAssertEqual(subscriptionMonthlyCosts(subscriptions: [canceled], now: now).first?.atomic, 1200)
 
         sections = subscriptionSections(subscriptions: [canceled], now: paidThrough)
         XCTAssertTrue(sections.active.isEmpty)
         XCTAssertEqual(sections.expired.map(\.id), [canceled.id])
-        XCTAssertEqual(subscriptionMonthlyCostSats(subscriptions: [canceled], now: paidThrough), 0)
+        XCTAssertEqual(subscriptionMonthlyCosts(subscriptions: [canceled], now: paidThrough).first?.atomic, 0)
     }
 
     func testCanceledSubscriptionEndsAtItsLastPaidPeriodWhateverItsFixedEndDate() throws {
@@ -3239,7 +3285,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         )
         XCTAssertTrue(subscriptionSections(subscriptions: [canceled], now: paidThrough).active.isEmpty)
         XCTAssertEqual(subscriptionSections(subscriptions: [canceled], now: paidThrough).expired.map(\.id), [canceled.id])
-        XCTAssertEqual(subscriptionMonthlyCostSats(subscriptions: [canceled], now: paidThrough), 0)
+        XCTAssertEqual(subscriptionMonthlyCosts(subscriptions: [canceled], now: paidThrough).first?.atomic, 0)
     }
 
     func testCanceledSubscriptionCreatedByTheUserStaysCreatedUntilPaidThroughThenExpires() throws {
@@ -3256,7 +3302,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertEqual(canceled.rowSubtitle(at: now), expiresDate)
         XCTAssertEqual(canceled.timingTitle(at: now), t("subscriptions__expires"))
         XCTAssertEqual(subscriptionNextTransitionDate(subscriptions: [canceled], now: now), paidThrough)
-        XCTAssertEqual(subscriptionMonthlyCostSats(subscriptions: [canceled], now: now), 0)
+        XCTAssertEqual(subscriptionMonthlyCosts(subscriptions: [canceled], now: now).first?.atomic, 0)
         XCTAssertFalse(canceled.canCancel(at: now))
 
         sections = subscriptionSections(subscriptions: [canceled], now: paidThrough)
@@ -3394,7 +3440,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             )))
 
             XCTAssertEqual(
-                subscriptionMonthlyCostSats(subscriptions: [subscription], now: now),
+                try Int(clamping: XCTUnwrap(subscriptionMonthlyCosts(subscriptions: [subscription], now: now).first?.atomic)),
                 testCase.expectedSats,
                 "Unexpected monthly cost for every \(testCase.every) \(testCase.unit)"
             )
@@ -3414,7 +3460,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 )
             )))
         }
-        XCTAssertEqual(subscriptionMonthlyCostSats(subscriptions: lowCostYearlySubscriptions, now: now), 3)
+        XCTAssertEqual(try Int(clamping: XCTUnwrap(subscriptionMonthlyCosts(subscriptions: lowCostYearlySubscriptions, now: now).first?.atomic)), 3)
     }
 
     func testMonthlySubscriptionCostIncludesPaidActiveSubscriptionsOnly() throws {
@@ -3452,7 +3498,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         )))
 
         XCTAssertEqual(
-            subscriptionMonthlyCostSats(subscriptions: [paidActive, canceled, proposed], now: now),
+            try Int(clamping: XCTUnwrap(subscriptionMonthlyCosts(subscriptions: [paidActive, canceled, proposed], now: now).first?.atomic)),
             1200
         )
     }
@@ -3718,15 +3764,10 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let deadlineSubscription = try XCTUnwrap(manager.subscriptions.first { $0.paymentRequestId == "deadline" })
         let subscription = try XCTUnwrap(manager.subscriptions.first { $0.paymentRequestId == "unsupported" })
         XCTAssertFalse(subscription.isProposalActionable(at: expiration))
-        XCTAssertFalse(deadlineSubscription.isProposalActionable(at: expiration))
-        XCTAssertNil(deadlineSubscription.paymentDueOnAcceptance(at: expiration))
+        XCTAssertTrue(deadlineSubscription.isProposalActionable(at: expiration))
+        XCTAssertNotNil(deadlineSubscription.paymentDueOnAcceptance(at: expiration))
         XCTAssertEqual(manager.subscriptionProposalForPresentation()?.id, deadlineSubscription.id)
-        do {
-            _ = try await manager.accept(deadlineSubscription)
-            XCTFail("Unsupported payment terms must not be accepted")
-        } catch {
-            XCTAssertEqual(error as? PaykitPaymentRequestError, .requestUnavailable)
-        }
+        _ = try await manager.accept(deadlineSubscription)
         XCTAssertEqual(
             manager.subscriptions.first { $0.paymentRequestId == "ended" }?.lifecycleState,
             .proposalExpired
@@ -3756,7 +3797,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         await manager.refresh()
 
         XCTAssertEqual(manager.pendingRequests.map(\.paymentRequestId), ["one-sat", "millisatoshi-safe-max"])
-        XCTAssertEqual(manager.pendingRequests.map(\.amountSats), [1, UInt64.max / 1000])
+        XCTAssertEqual(manager.pendingRequests.map(\.amount.atomic), [1, UInt64.max / 1000])
     }
 
     func testPaymentAndLightningInvoiceAmountsMustMatchRequest() throws {
@@ -3808,7 +3849,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         )
 
         try app.handleLnurlPayInvoice(data)
-        XCTAssertEqual(checkedAmount, request.amountSats)
+        XCTAssertEqual(checkedAmount, request.amount.atomic)
         XCTAssertTrue(app.didRejectScannedPayment)
         XCTAssertNil(app.lnurlPayData)
 
@@ -5426,7 +5467,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 try await privateService.consumePrivatePaymentList(publicKey: counterparty, context: privateContext, attemptId: context.id)
             }
             if testCase.started {
-                try await proofService.markOnchainPaymentStarted(request, address: "bcrt1qhardwarecleanup")
+                try await proofService.markOnchainPaymentStarted(request, address: "bcrt1qhardwarecleanup", amountSats: request.amount.atomic)
             }
             let preparedProofs = try await proofStore.load()
             XCTAssertEqual(preparedProofs.count, 1)
@@ -5899,7 +5940,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             XCTAssertFalse(preparation.complete(route: .confirm, manager: manager, session: otherProfile.currentSession, app: app, sheets: sheets))
             app.scannedOnchainInvoice = OnChainInvoice(
                 address: "bcrt1qrequest",
-                amountSatoshis: request.amountSats,
+                amountSatoshis: request.amount.atomic,
                 label: nil,
                 message: nil,
                 params: nil
@@ -7136,7 +7177,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         await manager.refreshEligibleTargets(savedPublicKeys: [savedKey])
         let target = await manager.refreshEligibleTarget(publicKey: savedKey)
         _ = try await manager.propose(
-            PaykitPaymentRequestDraft(amountSats: 1, note: "Coffee", expiresAt: expiresAt),
+            PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "Coffee", expiresAt: expiresAt),
             to: XCTUnwrap(target)
         )
 
@@ -7544,7 +7585,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         await sdk.pauseNextProposal()
         let proposal = Task {
             try await manager.propose(
-                PaykitPaymentRequestDraft(amountSats: 1, note: "Coffee", expiresAt: expiresAt),
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "Coffee", expiresAt: expiresAt),
                 to: target
             )
         }
@@ -7553,7 +7594,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         await sdk.resumeProposal()
         let request = try await proposal.value
 
-        XCTAssertEqual(request.amountSats, 1)
+        XCTAssertEqual(request.amount.atomic, 1)
         XCTAssertEqual(request.note, "Coffee")
         let snapshot = await sdk.snapshot()
         XCTAssertEqual(snapshot.proposedRequests.count, 1)
@@ -7607,7 +7648,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             )])
             await sdk.pauseNextProcess(for: unrelatedKey)
             let service = PaykitPaymentRequestService(
-                sdk: sdk, now: { now }, isPrivatePaymentPublishingEnabled: { true }, logWarning: { _ in }
+                sdk: sdk, now: { now }, isPrivatePaymentPublishingEnabled: { true },
+                marketRate: { PaykitExchangeRate(price: "100000", timestamp: now) }, logWarning: { _ in }
             )
 
             let completed = expectation(description: "Selected proposal completes without unrelated delivery")
@@ -7615,7 +7657,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 let status: PaykitPaymentRequest.DeliveryStatus? = if isSubscription {
                     try await service.proposeSubscription(
                         PaykitSubscriptionDraft(
-                            amountSats: 1000, name: "Support", description: "", frequency: .month,
+                            amount: PaykitAmount(asset: .btc, atomic: 1000), name: "Support", description: "", frequency: .month,
                             expiresAt: expiresAt, iconData: nil
                         ),
                         to: target, savedPublicKeys: savedPublicKeys, expectedIdentity: expectedIdentity,
@@ -7623,7 +7665,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                     ).deliveryStatus
                 } else {
                     try await service.propose(
-                        PaykitPaymentRequestDraft(amountSats: 1000, note: "Support", expiresAt: expiresAt),
+                        PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1000), note: "Support", expiresAt: expiresAt),
                         to: target, savedPublicKeys: savedPublicKeys, expectedIdentity: expectedIdentity
                     ).deliveryStatus
                 }
@@ -7692,14 +7734,15 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 if processFails { await sdk.failNextProcess() }
                 await sdk.pauseNextProcess()
                 let service = PaykitPaymentRequestService(
-                    sdk: sdk, now: { now }, isPrivatePaymentPublishingEnabled: { true }, logWarning: { _ in }
+                    sdk: sdk, now: { now }, isPrivatePaymentPublishingEnabled: { true },
+                    marketRate: { PaykitExchangeRate(price: "100000", timestamp: now) }, logWarning: { _ in }
                 )
                 let target = PaykitPaymentRequestTarget(publicKey: publicKey)
                 let proposal = Task {
                     if isSubscription {
                         return try await service.proposeSubscription(
                             PaykitSubscriptionDraft(
-                                amountSats: 1000, name: "Support", description: "", frequency: .month,
+                                amount: PaykitAmount(asset: .btc, atomic: 1000), name: "Support", description: "", frequency: .month,
                                 expiresAt: expiresAt, iconData: nil
                             ),
                             to: target, savedPublicKeys: [publicKey], expectedIdentity: expectedIdentity,
@@ -7707,7 +7750,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                         ).deliveryStatus
                     }
                     return try await service.propose(
-                        PaykitPaymentRequestDraft(amountSats: 1000, note: "Support", expiresAt: expiresAt),
+                        PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1000), note: "Support", expiresAt: expiresAt),
                         to: target, savedPublicKeys: [publicKey], expectedIdentity: expectedIdentity
                     ).deliveryStatus
                 }
@@ -7741,7 +7784,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             await manager.refreshEligibleTargets(savedPublicKeys: [publicKey])
 
             let request = try await manager.propose(
-                PaykitPaymentRequestDraft(amountSats: 1, note: "", expiresAt: expiresAt),
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "", expiresAt: expiresAt),
                 to: XCTUnwrap(manager.eligibleTargets.first)
             )
 
@@ -7770,7 +7813,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let target = try XCTUnwrap(manager.eligibleTargets.first)
         let proposal = Task {
             try await manager.propose(
-                PaykitPaymentRequestDraft(amountSats: 1, note: "", expiresAt: expiresAt), to: target
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "", expiresAt: expiresAt), to: target
             )
         }
         try await waitUntil { await sdk.processIsPaused() }
@@ -7815,7 +7858,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 if isSubscription {
                     _ = try await service.proposeSubscription(
                         PaykitSubscriptionDraft(
-                            amountSats: 1000, name: "Support", description: "", frequency: .month,
+                            amount: PaykitAmount(asset: .btc, atomic: 1000), name: "Support", description: "", frequency: .month,
                             expiresAt: expiresAt, iconData: nil
                         ),
                         to: target, savedPublicKeys: [unrelatedKey], expectedIdentity: expectedIdentity,
@@ -7823,7 +7866,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                     )
                 } else {
                     _ = try await service.propose(
-                        PaykitPaymentRequestDraft(amountSats: 1000, note: "Support", expiresAt: expiresAt),
+                        PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1000), note: "Support", expiresAt: expiresAt),
                         to: target, savedPublicKeys: [unrelatedKey], expectedIdentity: expectedIdentity
                     )
                 }
@@ -7865,7 +7908,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             await manager.refreshEligibleTargets(savedPublicKeys: [publicKey])
 
             let request = try await manager.propose(
-                PaykitPaymentRequestDraft(amountSats: 1, note: "", expiresAt: expiresAt),
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "", expiresAt: expiresAt),
                 to: XCTUnwrap(manager.eligibleTargets.first)
             )
 
@@ -7901,7 +7944,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
         do {
             _ = try await manager.propose(
-                PaykitPaymentRequestDraft(amountSats: 1, note: "", expiresAt: expiresAt),
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "", expiresAt: expiresAt),
                 to: target
             )
             XCTFail("Expected the stale target to be rejected")
@@ -7926,7 +7969,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
         do {
             _ = try await manager.propose(
-                PaykitPaymentRequestDraft(amountSats: 1, note: "", expiresAt: now),
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "", expiresAt: now),
                 to: target
             )
             XCTFail("Expected the expired draft to be rejected")
@@ -7958,7 +8001,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
         let task = Task {
             try await manager.propose(
-                PaykitPaymentRequestDraft(amountSats: 1, note: "", expiresAt: expiresAt),
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "", expiresAt: expiresAt),
                 to: target
             )
         }
@@ -7993,7 +8036,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
         let proposal = Task {
             try await manager.propose(
-                PaykitPaymentRequestDraft(amountSats: 1, note: "", expiresAt: expiresAt),
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "", expiresAt: expiresAt),
                 to: target
             )
         }
@@ -8046,7 +8089,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let target = try XCTUnwrap(manager.eligibleTargets.first)
 
         let request = try await manager.propose(
-            PaykitPaymentRequestDraft(amountSats: 1, note: "", expiresAt: expiresAt),
+            PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .btc, atomic: 1), note: "", expiresAt: expiresAt),
             to: target
         )
 
@@ -8156,7 +8199,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         protectedRequestIdsForSubscriptionCancellation: Set<PaykitPaymentRequest.ID> = [],
         presentationStore: PaymentRequestPresentationMemoryStore = PaymentRequestPresentationMemoryStore(),
         acceptanceStore: PaymentRequestPresentationMemoryStore? = nil,
-        acceptedRecords: [PaymentRequestRecord] = []
+        acceptedRecords: [PaymentRequestRecord] = [],
+        canReceiveLightning: Bool = true
     ) -> PaykitPaymentRequestManager {
         let now: @Sendable () -> Date = { clock.now() }
         let acceptanceStore = acceptanceStore ?? PaymentRequestPresentationMemoryStore(ids: Set(acceptedRecords.map {
@@ -8171,6 +8215,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 now: now,
                 subscriptionNow: subscriptionNow,
                 isPrivatePaymentPublishingEnabled: { isPrivatePaymentPublishingEnabled },
+                canReceiveLightning: { canReceiveLightning },
+                marketRate: { PaykitExchangeRate(price: "100000", timestamp: now()) },
                 logWarning: { _ in }
             ),
             presentationStore: presentationStore,
@@ -8191,6 +8237,147 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         return manager
     }
 
+    func testProposalDefaultsToAvailableMethodsAndHonorsRestrictions() async throws {
+        let publicKey = "pubky\(String(repeating: "y", count: 52))"
+        let onchain = PublicPaykitService.MethodId.onchainMethodId(network: Env.network, scriptType: .p2wpkh).rawValue
+        let lightning = PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue
+        let expiresAt = Date(timeIntervalSince1970: 1_900_000_000)
+        for (canReceiveLightning, restriction) in [(false, nil), (true, nil), (true, [onchain])] as [(Bool, [String]?)] {
+            let sdk = PaymentRequestSdkMock(records: [])
+            await sdk.configureRecipients(
+                peers: [linkedPeer(counterparty: publicKey, state: .linked)],
+                requestCapabilitiesByPublicKey: [publicKey: true]
+            )
+            try await sdk.setProposalResult(paymentRequestRecord(role: .payee, expiresAt: timestamp(expiresAt)))
+            let manager = paymentRequestManager(sdk: sdk, canReceiveLightning: canReceiveLightning)
+            await manager.refreshEligibleTargets(savedPublicKeys: [publicKey])
+            _ = try await manager.propose(
+                PaykitPaymentRequestDraft(amount: PaykitAmount(asset: .usd, atomic: 5),
+                                          acceptedPaymentEndpointIdentifiers: restriction, note: "", expiresAt: expiresAt),
+                to: XCTUnwrap(manager.eligibleTargets.first)
+            )
+            let snapshot = await sdk.snapshot()
+            let accepted = try XCTUnwrap(snapshot.proposedRequests.first?.endpointIdentifiers)
+            if let restriction {
+                XCTAssertEqual(accepted, restriction)
+            } else {
+                XCTAssertTrue(accepted.contains(onchain))
+                XCTAssertEqual(accepted.contains(lightning), canReceiveLightning)
+                XCTAssertEqual(accepted.contains(PublicPaykitService.MethodId.usdtArbitrum.rawValue), Env.isUsdtEnabled)
+            }
+        }
+    }
+
+    func testUsdtReferenceAgreesForBothParticipantsAndBindsTheRequest() throws {
+        let payer = "pubky1rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg"
+        let payee = "pubky3rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg"
+        let endpoint = PublicPaykitService.MethodId.usdtArbitrum.rawValue
+        let incomingRecord = try paymentRequestRecord(
+            id: "550e8400-e29b-41d4-a716-446655440000",
+            counterparty: payee,
+            amount: "0.05",
+            asset: "usd",
+            endpoints: [endpoint]
+        )
+        let outgoingRecord = try paymentRequestRecord(
+            id: "550e8400-e29b-41d4-a716-446655440000",
+            counterparty: payer,
+            role: .payee,
+            amount: "0.05",
+            asset: "usd",
+            endpoints: [endpoint]
+        )
+        let incoming = try XCTUnwrap(PaykitPaymentRequest(historyRecord: incomingRecord, now: Date()))
+        let outgoing = try XCTUnwrap(PaykitPaymentRequest(historyRecord: outgoingRecord, now: Date()))
+        let reference = try PaykitUsdtPaymentService.binding(request: incoming, identity: payer, paymentAppId: "bitkit", quoteId: nil, period: nil)
+        XCTAssertEqual(
+            reference,
+            try PaykitUsdtPaymentService.binding(request: outgoing, identity: payee, paymentAppId: "bitkit", quoteId: nil, period: nil)
+        )
+        XCTAssertTrue(reference.paymentReference == "invoice-123")
+        let period = BillingPeriod(startsAt: "2027-01-01T08:00:00.000Z", endsAt: "2027-02-01T08:00:00.000Z")
+        let recurring = try PaykitUsdtPaymentService.binding(
+            request: outgoing,
+            identity: payee,
+            paymentAppId: "bitkit",
+            quoteId: "quote",
+            period: period
+        )
+        XCTAssertEqual(recurring.periodStartsAt, period.startsAt)
+        XCTAssertEqual(recurring.periodEndsAt, period.endsAt)
+        XCTAssertEqual(recurring.conversionQuoteId, "quote")
+        var changed = incomingRecord
+        changed.paymentRequestId = UUID().uuidString
+        XCTAssertNotEqual(reference, try PaykitUsdtPaymentService.binding(
+            request: XCTUnwrap(PaykitPaymentRequest(historyRecord: changed, now: Date())), identity: payer, paymentAppId: "bitkit", quoteId: nil,
+            period: nil
+        ))
+    }
+
+    func testPaymentApprovalRequiresTheApprovedAmountAndUnexpiredTerms() throws {
+        var record = try paymentRequestRecord(amount: "5", asset: "usd", paymentDeadline: .at(timestamp: "2027-01-15T08:10:00Z"))
+        record.terms?.conversion = .fixed(rates: [ConversionRate(asset: "btc", value: "0.00001"), ConversionRate(asset: "usdt", value: "1")])
+        let now = try XCTUnwrap(PaykitPaymentRequest.parseDate("2027-01-15T08:00:00Z"))
+        let request = try XCTUnwrap(PaykitPaymentRequest(historyRecord: record, now: now))
+        let approved = try request.payment(to: .btc, at: now)
+        XCTAssertTrue(request.acceptsPaymentAmount(5000, paymentTerms: approved, at: now))
+        XCTAssertFalse(request.acceptsPaymentAmount(5001, paymentTerms: approved, at: now))
+        XCTAssertFalse(request.acceptsPaymentAmount(5000, paymentTerms: approved, at: now.addingTimeInterval(601)))
+        let usdt = try request.payment(to: .usdt, at: now)
+        XCTAssertTrue(request.acceptsPayment(usdt.amount, paymentTerms: usdt, at: now))
+        XCTAssertFalse(request.acceptsPayment(usdt.amount, paymentTerms: nil, at: now))
+        XCTAssertFalse(request.acceptsPayment(usdt.amount, paymentTerms: usdt, at: now.addingTimeInterval(601)))
+        XCTAssertFalse(request.acceptsPayment(PaykitAmount(asset: .usdt, atomic: usdt.amount.atomic + 1), paymentTerms: usdt, at: now))
+        record.terms?.conversion = .fixed(rates: [ConversionRate(asset: "btc", value: "0.00002")])
+        let changed = try XCTUnwrap(PaykitPaymentRequest(historyRecord: record, now: now))
+        XCTAssertFalse(changed.acceptsPaymentAmount(10000, paymentTerms: approved, at: now))
+    }
+
+    func testReceivedUsdtProofsRequireSatisfiedReceiptsForPaidThroughAndStatus() throws {
+        let period = BillingPeriod(startsAt: "2027-01-01T08:00:00Z", endsAt: "2027-02-01T08:00:00Z")
+        let proof = try paymentProofRecord(endpoint: PublicPaykitService.MethodId.usdtArbitrum.rawValue, kind: .usdt, billingPeriod: period)
+        let record = try paymentRequestRecord(state: .canceled, role: .payee, amount: "5", asset: "usd",
+                                              recurrence: PaymentRequestRecurrence(every: 1, unit: "month", startsAt: period.startsAt,
+                                                                                   anchor: period.startsAt, endsAt: nil),
+                                              endpoints: [PublicPaykitService.MethodId.usdtArbitrum.rawValue],
+                                              paymentProofs: [proof])
+        let subscription = try XCTUnwrap(PaykitSubscription(record: record))
+        let request = try XCTUnwrap(subscription.receivedPaymentRequests().first)
+        XCTAssertEqual(subscription.payments.count, 1)
+        XCTAssertTrue(subscription.paidPeriods.isEmpty)
+        XCTAssertNil(subscription.canceledPaidThrough)
+        XCTAssertEqual(PaymentRequestDisplay.status(for: request, isActionable: false, receipt: nil), t("wallet__payment_request_status_pending"))
+        let satisfied = try subscription.withVerifiedUsdtPayments([request.id: [XCTUnwrap(request.paymentProofEventId)]])
+        XCTAssertEqual(satisfied.paidPeriods, try [XCTUnwrap(PaykitBillingPeriod(sdkPeriod: period))])
+        XCTAssertEqual(satisfied.canceledPaidThrough, PaykitPaymentRequest.parseDate(period.endsAt))
+        XCTAssertTrue(satisfied.withVerifiedUsdtPayments([:]).paidPeriods.isEmpty)
+        XCTAssertTrue(subscription.withVerifiedUsdtPayments([request.id: ["superseded-proof"]]).paidPeriods.isEmpty)
+        let otherRequestId = PaykitPaymentRequest.ID(paymentRequestId: "other-request", counterparty: request.counterparty)
+        XCTAssertTrue(subscription.withVerifiedUsdtPayments([otherRequestId: [proof.eventId]]).paidPeriods.isEmpty)
+        let priorReceipt = PaykitUsdtPaymentService.Receipt(wallet: "wallet", identity: "identity", requestId: request.id,
+                                                            paymentId: "payment", proofEventId: "superseded-proof", verified: true,
+                                                            transferId: "transfer", amount: PaykitAmount(asset: .usdt, atomic: 5_000_000),
+                                                            receivedAt: Date(), underpaid: false, afterExpiry: false)
+        XCTAssertEqual(PaymentRequestDisplay.status(for: request, isActionable: false, receipt: priorReceipt),
+                       t("wallet__payment_request_status_pending"))
+    }
+
+    func testUsdtEndpointRequiresThePinnedNetworkTokenAndDirectAddress() throws {
+        let address = "0x1111111111111111111111111111111111111111"
+        let endpoint = try PaykitUsdt.endpoint(address: address)
+        XCTAssertEqual(PaykitUsdt.address(from: endpoint.rawPayload), address)
+        let invalidPayloads = [
+            endpoint.rawPayload.replacingOccurrences(of: "42161", with: "1"),
+            endpoint.rawPayload.replacingOccurrences(of: PaykitUsdt.token, with: address),
+            endpoint.rawPayload.replacingOccurrences(of: "\"42161\"", with: "42161"),
+            endpoint.rawPayload.replacingOccurrences(of: address, with: "0x" + String(repeating: "0", count: 40)),
+            endpoint.rawPayload.replacingOccurrences(of: address, with: PaykitUsdt.paymentURI(address: address)),
+        ]
+        for invalid in invalidPayloads {
+            XCTAssertNil(PaykitUsdt.address(from: invalid))
+        }
+    }
+
     private func weeklySubscription(
         id: String = "550e8400-e29b-41d4-a716-446655440000",
         unit: String = "week",
diff --git a/BitkitTests/PaykitPaymentStateBackupTests.swift b/BitkitTests/PaykitPaymentStateBackupTests.swift
index 5edc13514..f608a3722 100644
--- a/BitkitTests/PaykitPaymentStateBackupTests.swift
+++ b/BitkitTests/PaykitPaymentStateBackupTests.swift
@@ -1,4 +1,5 @@
 @testable import Bitkit
+import BitkitCore
 import Combine
 import CryptoKit
 import Paykit
@@ -105,6 +106,71 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         try Keychain.delete(key: .paykitPendingBackupRestore)
         try Keychain.delete(key: .onchainSendAttempts)
         try Keychain.delete(key: .paykitAcceptedPaymentRequests)
+        try Keychain.delete(key: .paykitUsdtPayments)
+    }
+
+    func testWalletEnvelopePreservesCoreRecoveryData() throws {
+        let fixture = #"{"version":1,"createdAt":1,"transfers":[],"usdtWallet":"{\"identity\":\"42161:wallet\",\"transfers\":[]}"}"#
+        let decoded = try JSONDecoder().decode(WalletBackupV1.self, from: Data(fixture.utf8))
+        XCTAssertEqual(decoded.usdtWallet, #"{"identity":"42161:wallet","transfers":[]}"#)
+        let encoded = try JSONEncoder().encode(decoded)
+        XCTAssertEqual(try JSONDecoder().decode(WalletBackupV1.self, from: encoded).usdtWallet, decoded.usdtWallet)
+        let withoutUsdt = #"{"version":1,"createdAt":1,"transfers":[]}"#
+        XCTAssertNil(try JSONDecoder().decode(WalletBackupV1.self, from: Data(withoutUsdt.utf8)).usdtWallet)
+    }
+
+    @MainActor
+    func testRestoredUsdtAttemptsProtectPendingPaymentsAndOnlySatisfiedReceiptsCount() throws {
+        let counterparty = "pubky" + String(repeating: "y", count: 52)
+        let ids = (0 ..< 4).map { PaykitPaymentRequest.ID(paymentRequestId: "request-\($0)", counterparty: counterparty) }
+        let proof = PaykitUsdtPaymentService.Proof(UsdtPaymentProof(chainId: "42161", transactionHash: "transaction",
+                                                                    receiptLogIndex: "0", signature: "signature"))
+        let attempts = ids.enumerated().map { index, id in
+            PaykitUsdtPaymentService.Attempt(quoteId: "quote-\(index)", wallet: "wallet", identity: identity, contact: counterparty,
+                                             requestId: id, binding: nil, billingPeriod: nil, proof: index == 2 ? proof : nil,
+                                             proofQueued: false, paymentStarted: index == 1)
+        }
+        let receipts = ids.enumerated().map { index, id in
+            PaykitUsdtPaymentService.Receipt(wallet: "wallet", identity: identity, requestId: id, paymentId: "payment-\(index)",
+                                             proofEventId: "proof-\(index)", verified: index != 1, transferId: "transfer-\(index)",
+                                             amount: PaykitAmount(asset: .usdt, atomic: 5_000_000), receivedAt: Date(),
+                                             underpaid: index == 2, afterExpiry: index == 3)
+        }
+        let service = PaykitUsdtPaymentService()
+        try service.restoreBackup(PaykitUsdtStateBackup(attempts: attempts.map(PaykitUsdtStateBackup.Attempt.init),
+                                                        receipts: receipts.map(PaykitUsdtStateBackup.Receipt.init)))
+        let protection = try service.paymentProtection(identity: identity)
+        XCTAssertEqual(protection.inFlight, [ids[1], ids[2]])
+        XCTAssertEqual(protection.completed, [ids[2]: .usdt])
+        XCTAssertEqual(receipts.filter(\.satisfied).map(\.requestId), [ids[0]])
+        XCTAssertTrue(try service.satisfiedProofs(identity: identity).isEmpty, "Restored receipts require the active wallet before use")
+        XCTAssertTrue(try service.paymentProtection(identity: counterparty).inFlight.isEmpty)
+        XCTAssertTrue(try service.satisfiedProofs(identity: counterparty).isEmpty)
+    }
+
+    func testWalletBackupWritesWaitForEarlierUploadAndRecoverAfterFailure() async throws {
+        let writer = WalletBackupWriter()
+        let entered = expectation(description: "upload started")
+        let gate = AsyncStream<Void>.makeStream()
+        let events = BackupWriteEvents()
+        let first = Task {
+            try await writer.write {
+                entered.fulfill()
+                for await _ in gate.stream {
+                    break
+                }
+                await events.append(1)
+                throw PaykitPaymentStateBackupTestError.restoreFailed
+            }
+        }
+        await fulfillment(of: [entered], timeout: 2)
+        let second = Task { try await writer.write { await events.append(2) } }
+        gate.continuation.yield(())
+        gate.continuation.finish()
+        do { try await first.value; XCTFail("Upload should fail") } catch {}
+        try await second.value
+        let recorded = await events.values
+        XCTAssertEqual(recorded, [1, 2])
     }
 
     func testSharedBackupBindingUsesActualVssDerivationAndNetworkNames() throws {
@@ -521,6 +587,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
             paymentStarted: true,
             paymentIdentifier: "transaction-id",
             proofData: "transaction-id",
+            conversionQuoteId: "quote",
             onchainAddress: "test-address",
             onchainAmountSats: 1000,
             onchainWalletId: "trezor:android",
@@ -545,6 +612,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         try PaykitSubscriptionStateStore().restoreBackup(decoded.subscriptions)
         try await PaykitPaymentProofService.shared.restoreBackup(decoded.pendingProofs)
         try Keychain.delete(key: .paykitAcceptedPaymentRequests)
+        try Keychain.delete(key: .paykitUsdtPayments)
         try acceptanceStore.restoreBackup(XCTUnwrap(decoded.acceptedOneTimeRequests))
         XCTAssertEqual(try acceptanceStore.load(identity: identity), [acceptedId])
 
@@ -555,6 +623,93 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         XCTAssertEqual(restoredBackup.first?.onchainWalletId, "trezor:android")
     }
 
+    func testUsdtBackupPreservesSharedWireFormat() throws {
+        let fixture = """
+        {
+          "attempts": [
+            {
+              "quoteId": "operation",
+              "wallet": "wallet",
+              "identity": "alice",
+              "contact": "bob",
+              "requestId": {
+                "paymentRequestId": "request",
+                "counterparty": "bob",
+                "billingPeriodStartsAt": "2026-10-01T00:00:00.125Z"
+              },
+              "binding": {
+                "payer": "alice",
+                "payee": "bob",
+                "paymentAppId": "bitkit",
+                "paymentRequestId": "request",
+                "paymentReference": "invoice",
+                "paymentEndpointIdentifier": "usdt-arbitrum-address",
+                "periodStartsAt": "2026-10-01T00:00:00.125Z",
+                "periodEndsAt": "2026-11-01T00:00:00.125Z",
+                "conversionQuoteId": "quote"
+              },
+              "billingPeriod": {
+                "startsAt": "2026-10-01T00:00:00.125Z",
+                "endsAt": "2026-11-01T00:00:00.125Z"
+              },
+              "proof": null,
+              "proofQueued": false,
+              "paymentStarted": true
+            }
+          ],
+          "receipts": [
+            {
+              "wallet": "wallet",
+              "identity": "alice",
+              "requestId": {
+                "paymentRequestId": "request",
+                "counterparty": "bob",
+                "billingPeriodStartsAt": "2026-10-01T00:00:00.125Z"
+              },
+              "paymentId": "42161:transaction:2",
+              "proofEventId": "proof",
+              "verified": true,
+              "transferId": "transfer",
+              "amountAtomic": 50000,
+              "receivedAtMillis": 1790812801000,
+              "underpaid": false,
+              "afterExpiry": false
+            }
+          ]
+        }
+        """
+        let backup = try JSONDecoder().decode(PaykitUsdtStateBackup.self, from: Data(fixture.utf8))
+        let attempt = try XCTUnwrap(backup.attempts.first).restored()
+        let receipt = try XCTUnwrap(backup.receipts.first).restored()
+        XCTAssertTrue(attempt.paymentStarted)
+        XCTAssertEqual(attempt.binding?.paymentAppId, "bitkit")
+        XCTAssertEqual(attempt.binding?.conversionQuoteId, "quote")
+        XCTAssertEqual(attempt.billingPeriod?.sdkValue.startsAt, "2026-10-01T00:00:00.125Z")
+        XCTAssertEqual(receipt.amount.atomic, 50000)
+        XCTAssertEqual(receipt.requestId, attempt.requestId)
+        let encoded = try JSONEncoder().encode(PaykitUsdtStateBackup(attempts: [.init(attempt)], receipts: [.init(receipt)]))
+        let restored = try JSONDecoder().decode(PaykitUsdtStateBackup.self, from: encoded)
+        XCTAssertEqual(try restored.attempts.first?.restored(), attempt)
+        XCTAssertEqual(try restored.receipts.first?.restored(), receipt)
+    }
+
+    @MainActor
+    func testUsdtRestorePreservesStartedPaymentsWhenSnapshotsOverlap() throws {
+        let service = PaykitUsdtPaymentService()
+        let started = PaykitUsdtPaymentService.Attempt(quoteId: "operation", wallet: "wallet", identity: "alice", contact: "bob",
+                                                       requestId: nil, binding: nil, billingPeriod: nil, proofQueued: true,
+                                                       paymentStarted: true)
+        var unstarted = started
+        unstarted.paymentStarted = false
+        let older = PaykitUsdtStateBackup(attempts: [.init(unstarted)], receipts: [])
+        try service.restoreBackup(older)
+        try service.restoreBackup(PaykitUsdtStateBackup(attempts: [.init(started)], receipts: []))
+        try service.restoreBackup(older)
+        let restored = try XCTUnwrap(service.backupSnapshot().attempts.first).restored()
+        XCTAssertTrue(restored.paymentStarted)
+        XCTAssertFalse(restored.proofQueued)
+    }
+
     func testUnreadablePaymentStateIsPreserved() async throws {
         let data = Data("not-json".utf8)
         try Keychain.upsert(key: .paykitSubscriptionState, data: data)
@@ -565,7 +720,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         do {
             _ = try await PaykitPaymentProofStore().load()
             XCTFail("Unreadable proof state must fail")
-        } catch is DecodingError {}
+        } catch is Swift.DecodingError {}
         XCTAssertEqual(try Keychain.load(key: .paykitSubscriptionState), data)
         XCTAssertEqual(try Keychain.load(key: .paykitPendingPaymentProofs), data)
     }
@@ -802,3 +957,10 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         XCTAssertTrue(String(decoding: migratedData, as: UTF8.self).contains("2026-09-24T10:00:00Z"))
     }
 }
+
+private actor BackupWriteEvents {
+    private(set) var values: [Int] = []
+    func append(_ value: Int) {
+        values.append(value)
+    }
+}
diff --git a/BitkitTests/PaykitRequestPricingTests.swift b/BitkitTests/PaykitRequestPricingTests.swift
new file mode 100644
index 000000000..0d05b1f35
--- /dev/null
+++ b/BitkitTests/PaykitRequestPricingTests.swift
@@ -0,0 +1,107 @@
+@testable import Bitkit
+import BitkitCore
+import Foundation
+import Paykit
+import XCTest
+
+final class PaykitRequestPricingTests: XCTestCase {
+    private let now = Date(timeIntervalSince1970: 1_800_000_000)
+
+    func testFixedRatesDetermineExactAmountsWithoutMarketRates() throws {
+        let pricing = PaykitRequestPricing(conversion: .fixed(rates: [
+            ConversionRate(asset: "btc", value: "0.000012345"), ConversionRate(asset: "usdt", value: "1"),
+        ]))
+        let requested = try PaykitAmount(asset: .usd, value: "0.05")
+        XCTAssertEqual(try pricing.payment(requested: requested, asset: .btc, period: nil, at: now).amount.atomic, 62)
+        XCTAssertEqual(try pricing.payment(requested: requested, asset: .usdt, period: nil, at: now).amount.atomic, 50000)
+        XCTAssertEqual(try pricing.payment(requested: requested, asset: .usd, period: nil, at: now).amount, requested)
+        XCTAssertThrowsError(try pricing.payment(requested: requested, asset: .usdt, period: nil, at: now, quoteId: "unknown"))
+    }
+
+    func testSubscriptionsKeepOnePaymentCurrencyAcrossBillingPeriods() throws {
+        let bitcoin = PublicPaykitService.MethodId.onchainMethodId(network: Env.network, scriptType: .p2wpkh).rawValue
+        let lightning = PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue
+        let usdt = PublicPaykitService.MethodId.usdtArbitrum.rawValue
+        let available = [bitcoin, lightning, usdt]
+        for (asset, endpoints, paidAsset) in [(PaykitAsset.btc, [bitcoin, lightning], PaykitAsset.btc), (.usd, [usdt], .usdt)] {
+            let selected = PaykitRequestPricing.subscriptionEndpoints(requested: asset, available: available)
+            XCTAssertEqual(selected, endpoints)
+            XCTAssertTrue(PaykitRequestPricing.subscriptionEndpoints(requested: asset, available: available.filter { !endpoints.contains($0) })
+                .isEmpty)
+            let rates = try PaykitRequestPricing.rates(requested: asset, endpoints: selected, market: nil, at: now)
+            let pricing = PaykitRequestPricing(conversion: rates.isEmpty ? nil : .fixed(rates: rates))
+            let requested = try PaykitAmount(asset: asset, value: "5")
+            let nextPeriod = PaykitBillingPeriod(startsAt: now.addingTimeInterval(31 * 86400), endsAt: now.addingTimeInterval(62 * 86400))
+            let payment = try pricing.payment(requested: requested, asset: paidAsset, period: nextPeriod, at: nextPeriod.startsAt)
+            XCTAssertEqual(payment.amount.value, "5")
+            XCTAssertNil(payment.quoteId)
+            XCTAssertNil(payment.expiresAt)
+            XCTAssertTrue(payment.isValid(at: nextPeriod.endsAt))
+        }
+        XCTAssertTrue(PaykitRequestPricing.subscriptionEndpoints(requested: .usdt, available: available).isEmpty)
+    }
+
+    func testMissingTermsOrRateNeverImplicitlyEnableConversion() throws {
+        let requested = try PaykitAmount(asset: .usd, value: "5")
+        for pricing in [PaykitRequestPricing(), PaykitRequestPricing(conversion: .fixed(rates: [ConversionRate(asset: "btc", value: "0.00001")]))] {
+            XCTAssertThrowsError(try pricing.payment(requested: requested, asset: .usdt, period: nil, at: now))
+            XCTAssertEqual(try pricing.payment(requested: requested, asset: .usd, period: nil, at: now).amount, requested)
+        }
+    }
+
+    func testQuotedArithmeticRejectsOverflowAndRoundsOnlyOnce() throws {
+        let requested = try PaykitAmount(asset: .btc, value: "0.00000001")
+        XCTAssertEqual(try requested.quoted(to: .usdt, multiplier: "123456.789012345678").atomic, 1235)
+        XCTAssertThrowsError(try PaykitAmount(asset: .usdt, atomic: .max).quoted(to: .usdt, multiplier: "2"))
+        for rate in ["0", "-1", "NaN", "1e2", "0.123456789012345678901234567890123456789"] {
+            XCTAssertThrowsError(try requested.quoted(to: .usdt, multiplier: rate))
+        }
+    }
+
+    func testRatesAreRequiredOnlyWhenIssuingBitcoinConversions() throws {
+        let usd = PublicPaykitService.MethodId.usdtArbitrum.rawValue
+        XCTAssertEqual(try PaykitRequestPricing.rates(requested: .usd, endpoints: [usd], market: nil, at: now),
+                       [ConversionRate(asset: "usdt", value: "1")])
+        XCTAssertThrowsError(try PaykitRequestPricing.rates(requested: .btc, endpoints: [usd], market: nil, at: now))
+        let stale = PaykitExchangeRate(price: "100000", timestamp: now.addingTimeInterval(-601))
+        XCTAssertThrowsError(try PaykitRequestPricing.rates(requested: .btc, endpoints: [usd], market: stale, at: now))
+    }
+
+    @MainActor
+    func testProofEnvelopeFitsBeforeSending() throws {
+        let binding = UsdtPaymentProofBinding(payer: String(repeating: "y", count: 52), payee: String(repeating: "y", count: 52),
+                                              paymentAppId: "bitkit",
+                                              paymentRequestId: UUID().uuidString.lowercased(),
+                                              paymentReference: "invoice", paymentEndpointIdentifier: "usdt-arbitrum-address",
+                                              periodStartsAt: "2027-01-01T00:00:00Z",
+                                              periodEndsAt: "2027-02-01T00:00:00Z", conversionQuoteId: UUID().uuidString.lowercased())
+        XCTAssertNoThrow(try PaykitUsdtPaymentService.validateProofSize(binding: binding))
+        var oversized = binding
+        oversized.paymentReference = String(repeating: "é", count: 256)
+        XCTAssertThrowsError(try PaykitUsdtPaymentService.validateProofSize(binding: oversized))
+    }
+
+    func testRecurringPaymentsKeepTheirChosenQuoteAndInclusiveDeadline() throws {
+        let period = PaykitBillingPeriod(startsAt: now, endsAt: now.addingTimeInterval(86400))
+        let first = PaymentConversionQuoteRecord(eventId: "first", billingPeriod: period.sdkValue,
+                                                 rates: [ConversionRate(asset: "usdt", value: "100000")], validFrom: period.sdkValue.startsAt,
+                                                 expiresAt: ISO8601DateFormatter().string(from: now.addingTimeInterval(60)), outboundStatus: nil)
+        var later = first
+        later.eventId = "later"
+        later.rates = [ConversionRate(asset: "usdt", value: "110000")]
+        let pricing = PaykitRequestPricing(conversion: .perPeriod, deadline: .periodStart(seconds: 30), quotes: [first, later])
+        let requested = try PaykitAmount(asset: .btc, value: "0.00001")
+        let selected = try pricing.payment(requested: requested, asset: .usdt, period: period, at: now)
+        XCTAssertEqual(selected.amount.value, "1.1")
+        XCTAssertEqual(selected.quoteId, "later")
+        let pinned = try pricing.payment(requested: requested, asset: .usdt, period: period, at: now, quoteId: "first")
+        XCTAssertEqual(pinned.amount.value, "1")
+        XCTAssertTrue(pinned.isValid(at: now.addingTimeInterval(30)))
+        XCTAssertFalse(pinned.isValid(at: now.addingTimeInterval(31)))
+        XCTAssertFalse(pinned.isValid(at: now.addingTimeInterval(-1)))
+        XCTAssertEqual(try pricing.payment(requested: requested, asset: .usdt, period: period,
+                                           at: now.addingTimeInterval(600), quoteId: "first"), pinned)
+        XCTAssertThrowsError(try pricing.payment(requested: requested, asset: .usdt, period: period, at: now, quoteId: "missing"))
+        XCTAssertThrowsError(try pricing.payment(requested: requested, asset: .usdt, period: nil, at: now))
+    }
+}
diff --git a/BitkitTests/PaykitSubscriptionProposalTests.swift b/BitkitTests/PaykitSubscriptionProposalTests.swift
index da942ad21..5773d9e85 100644
--- a/BitkitTests/PaykitSubscriptionProposalTests.swift
+++ b/BitkitTests/PaykitSubscriptionProposalTests.swift
@@ -46,18 +46,22 @@ final class PaykitSubscriptionProposalTests: XCTestCase {
         XCTAssertEqual(try PaykitSubscriptionProposal.encodedSize(request), base + 2)
     }
 
-    func testUnsupportedSubscriptionFieldsAreNotSilentlyExcludedFromSize() throws {
+    func testSubscriptionSizeIncludesConversionAndDeadlineAndRejectsUnmodeledEndpoints() throws {
         var boundEndpoints = try terms(description: "")
         boundEndpoints.paymentEndpoints = ["btc-regtest-p2wpkh": #"{"address":"bcrt1qexample"}"#]
+        XCTAssertThrowsError(try PaykitSubscriptionProposal.validate(boundEndpoints)) { error in
+            XCTAssertEqual(error as? PaykitPaymentRequestError, .requestUnavailable)
+        }
         var conversion = try terms(description: "")
         conversion.conversion = .perPeriod
         var deadline = try terms(description: "")
         deadline.paymentDeadline = .periodStart(seconds: 3600)
-        for request in [boundEndpoints, conversion, deadline] {
-            XCTAssertThrowsError(try PaykitSubscriptionProposal.validate(request)) { error in
-                XCTAssertEqual(error as? PaykitPaymentRequestError, .requestUnavailable)
-            }
-        }
+        let base = try PaykitSubscriptionProposal.encodedSize(terms(description: ""))
+        XCTAssertEqual(try PaykitSubscriptionProposal.encodedSize(conversion), base + #","conversion":{"type":"per_period"}"#.utf8.count)
+        XCTAssertEqual(
+            try PaykitSubscriptionProposal.encodedSize(deadline),
+            base + #","payment_deadline":{"type":"period_start","seconds":3600}"#.utf8.count
+        )
     }
 
     func testSizeCountsUTF8AndJSONEscapingRatherThanCharacters() throws {
diff --git a/BitkitTests/PubkyAuthApprovalSheetTests.swift b/BitkitTests/PubkyAuthApprovalSheetTests.swift
index 60da9a049..4279e7009 100644
--- a/BitkitTests/PubkyAuthApprovalSheetTests.swift
+++ b/BitkitTests/PubkyAuthApprovalSheetTests.swift
@@ -46,6 +46,58 @@ final class PubkyAuthApprovalSheetTests: XCTestCase {
         XCTAssertEqual(PubkyAuthApprovalSheet.initialState(for: request), .authorize)
     }
 
+    @MainActor
+    func testReceivingDetailsShareExactlyTheRequestedAssets() async throws {
+        let endpoint = try PaykitUsdt.endpoint(address: "0x1111111111111111111111111111111111111111")
+        for claim in [PubkyAuthClaim.usdtAddressV1, .paymentDetailsV1] {
+            let defaults = try XCTUnwrap(UserDefaults(suiteName: "EarnSharing.\(UUID().uuidString)"))
+            let manager = Bitkit.WatchOnlyAccountManager(defaults: defaults, node: ApprovalFakeWatchOnlyAccountNode())
+            let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: claim.rawValue)
+            let request = try PubkyAuthRequest.parse(url: url)
+            XCTAssertEqual(PubkyAuthApprovalSheet.initialState(for: request), .watchOnlyConsent)
+            var shared: [String: Any]?
+            try await PubkyService.approveAuthRequest(
+                request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret", accountManager: manager,
+                approvedUsdtAddress: endpoint.value, usdtEndpoint: { endpoint },
+                ordinaryApproval: { _, _, _, _ in XCTFail("A receiving-details request requires a companion claim") },
+                companionApproval: { _, _, type, payload, _ in
+                    XCTAssertEqual(type, claim)
+                    shared = try JSONSerialization.jsonObject(with: XCTUnwrap(payload)) as? [String: Any]
+                }
+            )
+            let details = try XCTUnwrap(shared)
+            let usdt = try XCTUnwrap(details["usdt-arbitrum-address"] as? [String: String])
+            XCTAssertEqual(usdt, ["value": endpoint.value, "chain_id": PaykitUsdt.chainId, "token": PaykitUsdt.token])
+            XCTAssertEqual(Set(details.keys), claim.sharesBitcoin ? ["bitcoin_account", "usdt-arbitrum-address"] : ["usdt-arbitrum-address"])
+            XCTAssertEqual(manager.accounts.count, claim.sharesBitcoin ? 1 : 0)
+            if claim.sharesBitcoin {
+                let bitcoin = try XCTUnwrap(details["bitcoin_account"] as? [String: Any])
+                XCTAssertEqual(bitcoin["xpub"] as? String, manager.accounts.first?.xpub)
+                XCTAssertEqual(bitcoin["account_index"] as? UInt32, manager.accounts.first?.accountIndex)
+                XCTAssertEqual(manager.accounts.first?.setupState, .active)
+            }
+        }
+    }
+
+    @MainActor
+    func testReceivingDetailsRequireTheReviewedAddress() async throws {
+        let endpoint = try PaykitUsdt.endpoint(address: "0x1111111111111111111111111111111111111111")
+        let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: "usdt-address-v1")
+        let request = try PubkyAuthRequest.parse(url: url)
+        for approvedAddress in [nil, "0x2222222222222222222222222222222222222222"] as [String?] {
+            do {
+                try await PubkyService.approveAuthRequest(
+                    request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret",
+                    approvedUsdtAddress: approvedAddress, usdtEndpoint: { endpoint },
+                    companionApproval: { _, _, _, _, _ in XCTFail("Unapproved details must not be sent") }
+                )
+                XCTFail("Expected approval to require the reviewed address")
+            } catch {
+                XCTAssertEqual(error as? PubkyAuthRequestError, .invalidPaymentDetails)
+            }
+        }
+    }
+
     func testAuthDisplayPublicKeyOmitsPubkyPrefix() {
         XCTAssertEqual(pubkyAuthDisplayPublicKey("pubky3rsd123456789w5xg"), "3rsd...w5xg")
         XCTAssertEqual(pubkyAuthDisplayPublicKey("3rsd123456789w5xg"), "3rsd...w5xg")
diff --git a/BitkitTests/ReceiveSheetSessionTests.swift b/BitkitTests/ReceiveSheetSessionTests.swift
index b7f61c8fe..757ee16e3 100644
--- a/BitkitTests/ReceiveSheetSessionTests.swift
+++ b/BitkitTests/ReceiveSheetSessionTests.swift
@@ -19,10 +19,15 @@ final class ReceiveSheetSessionTests: XCTestCase {
         XCTAssertNotEqual(firstID, secondID)
     }
 
-    func testPaykitRoutesDoNotRequireInvoiceRefresh() {
-        let draft = PaykitPaymentRequestDraft(amountSats: 1000, note: "Lunch", expiresAt: Date(timeIntervalSince1970: 86400))
+    func testPaykitAndUsdtRoutesDoNotRequireInvoiceRefresh() {
+        let draft = PaykitPaymentRequestDraft(
+            amount: PaykitAmount(asset: .btc, atomic: 1000),
+            note: "Lunch",
+            expiresAt: Date(timeIntervalSince1970: 86400)
+        )
         let target = PaykitPaymentRequestTarget(publicKey: "pubkycontact")
         let routes: [ReceiveRoute] = [
+            .usdt,
             .requestOrPay(publicKey: target.publicKey),
             .paymentRequestRecipient(draft),
             .paymentRequestAmount(draft, target),
diff --git a/BitkitTests/ShopPaymentRequestTests.swift b/BitkitTests/ShopPaymentRequestTests.swift
index d53d1a0fe..6f1f99eb1 100644
--- a/BitkitTests/ShopPaymentRequestTests.swift
+++ b/BitkitTests/ShopPaymentRequestTests.swift
@@ -166,6 +166,46 @@ final class ShopPaymentRequestTests: XCTestCase {
         }
     }
 
+    func testContactFundingPreferenceRespectsAvailableAssets() throws {
+        let usdt = try PaykitUsdt.endpoint(address: "0x4cdDcC65AF3Aa77803d1A99A030eb17751AC7780")
+        let bitcoin = PublicPaykitService.Endpoint(
+            methodId: .regtestOnchainP2wpkh,
+            value: "bcrt1qexample",
+            min: nil,
+            max: nil,
+            rawPayload: "bcrt1qexample"
+        )
+        let usdtOnly = ContactPaymentContext(publicKey: "contact", endpoints: [usdt])
+        let both = ContactPaymentContext(publicKey: "contact", endpoints: [bitcoin, usdt])
+        let btcOnly = ContactPaymentContext(publicKey: "contact", endpoints: [bitcoin])
+        XCTAssertTrue(usdtOnly.prefersUsdt(onchainBalanceSats: 100_000))
+        XCTAssertFalse(both.prefersUsdt(onchainBalanceSats: 100_000))
+        XCTAssertTrue(both.prefersUsdt(onchainBalanceSats: 0))
+        XCTAssertFalse(btcOnly.prefersUsdt(onchainBalanceSats: 0))
+    }
+
+    func testUsdtContactPaymentCanBePreparedAndCleared() async throws {
+        let app = AppViewModel()
+        let endpoint = try PaykitUsdt.endpoint(address: "0x4cdDcC65AF3Aa77803d1A99A030eb17751AC7780")
+        let context = ContactPaymentContext(publicKey: "contact", endpoints: [endpoint])
+        XCTAssertFalse(app.hasSendPaymentTarget)
+        XCTAssertTrue(app.claimContactPaymentContext(context))
+
+        try await app.handleScannedData(endpoint.paymentRequest, claimedContactPaymentContext: context)
+
+        XCTAssertTrue(app.hasSendPaymentTarget)
+        XCTAssertTrue(app.paykitUsesUsdt)
+        XCTAssertTrue(app.ownsContactPaymentContext(context))
+        XCTAssertNil(app.scannedOnchainInvoice)
+        XCTAssertNil(app.scannedLightningInvoice)
+
+        app.resetSendState()
+
+        XCTAssertFalse(app.hasSendPaymentTarget)
+        XCTAssertFalse(app.paykitUsesUsdt)
+        XCTAssertNil(app.contactPaymentContext)
+    }
+
     private var lightningInvoice: LightningInvoice {
         LightningInvoice(
             bolt11: "test-invoice",
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
new file mode 100644
index 000000000..9fbbce9c6
--- /dev/null
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -0,0 +1,88 @@
+@testable import Bitkit
+import BitkitCore
+import XCTest
+
+@MainActor
+final class UsdtWalletManagerTests: XCTestCase {
+    func testOnlyNewConfirmedReceiptsCelebrateAfterInitialSync() {
+        let old = transfer("old")
+        let incoming = transfer("new")
+        let pending = transfer("pending", status: .pending)
+        let failed = transfer("failed", status: .failed)
+        let outgoing = transfer("sent", incoming: false)
+        let empty = transfer("zero", amount: 0)
+        XCTAssertTrue(UsdtWalletManager.newIncomingTransfers(previous: nil, current: [old]).isEmpty)
+        let current = [old, incoming, pending, failed, outgoing, empty]
+        XCTAssertEqual(UsdtWalletManager.newIncomingTransfers(previous: [old], current: current), [incoming])
+        XCTAssertTrue(UsdtWalletManager.newIncomingTransfers(previous: current, current: current).isEmpty)
+        let confirmed = transfer("pending")
+        XCTAssertEqual(UsdtWalletManager.newIncomingTransfers(previous: current, current: current + [confirmed]), [confirmed])
+    }
+
+    func testLinkedOrderStatusAndErrorSupersedeDepositStateTogether() {
+        let deposit = UsdtDeposit(id: "deposit", network: "solana", asset: "USDT", amount: 100, sourceTx: "tx", status: "held",
+                                  code: "standing_route_unavailable", refundTx: nil)
+        let cases: [(String?, String?, String)] = [
+            ("completed", nil, "usdt__confirmed"),
+            (nil, deposit.code, "usdt__deposit_needs_attention"),
+            ("unknown", nil, "usdt__deposit_needs_attention"),
+            ("pending", nil, "usdt__pending"),
+            ("processing", nil, "usdt__pending"),
+            ("refunded", nil, "usdt__deposit_refunded"),
+            ("failed", "order_error", "usdt__deposit_needs_attention"),
+        ]
+        for (status, code, key) in cases {
+            let order = status.map { UsdtDepositOrder(status: $0, amountIn: 100, amountOut: 90, destinationTx: nil, refundTx: nil, code: code) }
+            let detail = UsdtDepositDetail(deposit: deposit, order: order)
+            XCTAssertEqual(detail.statusText, t(key))
+            XCTAssertEqual(detail.statusCode, code)
+        }
+    }
+
+    private func transfer(_ id: String, incoming: Bool = true, status: UsdtTransferStatus = .confirmed, amount: UInt64 = 1_000_000) -> UsdtTransfer {
+        UsdtTransfer(
+            id: id,
+            txHash: status == .pending ? nil : id,
+            userOperationHash: nil,
+            bridgeGuid: nil,
+            orchestra: nil,
+            recipient: "recipient",
+            destination: .arbitrum,
+            amount: amount,
+            receivedAmount: amount,
+            fee: nil,
+            isIncoming: incoming,
+            status: status,
+            timestamp: 1
+        )
+    }
+
+    func testWipeRemovesUsdtPersistenceAndStopsSession() async throws {
+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: directory) }
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let usdtFiles = ["usdt-wipe-test.sqlite", "usdt-wipe-test.sqlite-wal", "usdt-wipe-test.sqlite-shm"]
+            .map { directory.appendingPathComponent($0) }
+        let unrelated = directory.appendingPathComponent("unrelated-wipe-test.txt")
+        defer { try? FileManager.default.removeItem(at: unrelated) }
+        for file in usdtFiles + [unrelated] {
+            try Data("private payment data".utf8).write(to: file)
+        }
+
+        let manager = UsdtWalletManager(storageDirectory: directory)
+        async let first: Void = manager.wipe()
+        async let second: Void = manager.wipe()
+        _ = try await (first, second)
+        for file in usdtFiles {
+            XCTAssertFalse(FileManager.default.fileExists(atPath: file.path))
+        }
+        XCTAssertTrue(FileManager.default.fileExists(atPath: unrelated.path))
+        XCTAssertTrue(manager.address.isEmpty)
+        XCTAssertTrue(manager.transfers.isEmpty)
+        XCTAssertNil(manager.balance)
+        do {
+            _ = try await manager.quote(recipient: "0x1111111111111111111111111111111111111111", amount: "1", destination: .arbitrum)
+            XCTFail("A wiped session must not reopen its wallet")
+        } catch is CancellationError {}
+    }
+}
diff --git a/BitkitUITests/UsdtWalletUITests.swift b/BitkitUITests/UsdtWalletUITests.swift
new file mode 100644
index 000000000..90a386e2e
--- /dev/null
+++ b/BitkitUITests/UsdtWalletUITests.swift
@@ -0,0 +1,163 @@
+import XCTest
+
+final class UsdtWalletUITests: XCTestCase {
+    @MainActor
+    func testPaymentUsesUsdtOnLocalArbitrumFork() async throws {
+        let client: String
+        do {
+            client = try await forkCall("web3_clientVersion", []) as? String ?? ""
+        } catch {
+            throw XCTSkip("Requires the local Arbitrum fork fixture in bitkit-core/tests/usdt-fork")
+        }
+        guard client.lowercased().contains("anvil") else { throw XCTSkip("Requires Anvil") }
+        continueAfterFailure = false
+        let app = XCUIApplication()
+        app.launchEnvironment["USDT_RPC_URL"] = "http://127.0.0.1:18545"
+        app.launchEnvironment["USDT_BUNDLER_URL"] = "http://127.0.0.1:18546"
+        app.launch()
+        if app.buttons["Continue"].waitForExistence(timeout: 3) { app.buttons["Continue"].tap() }
+        if app.buttons["SkipIntro"].waitForExistence(timeout: 3) {
+            app.buttons["SkipIntro"].tap()
+            XCTAssertTrue(app.buttons["NewWallet"].waitForExistence(timeout: 5))
+            app.buttons["NewWallet"].tap()
+        }
+        XCTAssertTrue(app.buttons["UsdtWallet"].waitForExistence(timeout: 90))
+        capture(app, "USDT home")
+        app.buttons["UsdtWallet"].tap()
+        XCTAssertTrue(app.buttons["UsdtReceive"].waitForExistence(timeout: 5))
+        app.buttons["UsdtReceive"].tap()
+        let addressElement = app.staticTexts["UsdtReceiveAddress"]
+        XCTAssertTrue(addressElement.waitForExistence(timeout: 30))
+        capture(app, "USDT receive")
+        app.buttons["UsdtReceiveDetails"].tap()
+        capture(app, "USDT receive details")
+        let address = addressElement.label
+        _ = try await forkCall("test_fundWallet", [address])
+        let back = app.buttons.matching(identifier: "NavigationBack")
+        try XCTUnwrap(back.allElementsBoundByIndex.first(where: \.isHittable)).tap()
+        let fundedBalance = app.staticTexts.matching(identifier: "UsdtBalance")
+            .matching(NSPredicate(format: "label CONTAINS %@", "1000")).firstMatch
+        XCTAssertTrue(fundedBalance.waitForExistence(timeout: 60))
+        app.buttons["UsdtSend"].tap()
+        XCTAssertTrue(app.buttons["UsdtManual"].waitForExistence(timeout: 5))
+        capture(app, "USDT send options")
+        app.buttons["UsdtManual"].tap()
+        app.textViews["UsdtRecipient"].tap()
+        app.textViews["UsdtRecipient"].typeText("0x1111111111111111111111111111111111111111")
+        capture(app, "USDT recipient")
+        app.buttons["UsdtRecipientContinue"].tap()
+        XCTAssertTrue(app.buttons["N1"].waitForExistence(timeout: 5))
+        app.buttons["N1"].tap()
+        capture(app, "USDT amount")
+        app.buttons["UsdtReview"].tap()
+        let confirm = app.otherElements["UsdtConfirm"]
+        XCTAssertTrue(confirm.waitForExistence(timeout: 40), app.debugDescription)
+        capture(app, "USDT review")
+        app.buttons["UsdtReviewDetails"].tap()
+        XCTAssertTrue(app.staticTexts["0x1111111111111111111111111111111111111111"].exists)
+        capture(app, "USDT review details")
+        let start = confirm.coordinate(withNormalizedOffset: CGVector(dx: 0.1, dy: 0.5))
+        let end = confirm.coordinate(withNormalizedOffset: CGVector(dx: 0.95, dy: 0.5))
+        start.press(forDuration: 0.1, thenDragTo: end)
+        let warning = app.alerts["Are You Sure?"]
+        let feeWarning = warning.staticTexts[
+            "The transaction fee appears to be over 50% of the amount you are sending. Do you want to continue?"
+        ]
+        XCTAssertTrue(warning.waitForExistence(timeout: 5))
+        XCTAssertTrue(feeWarning.exists)
+        capture(app, "USDT fee warning")
+        warning.buttons["Cancel"].tap()
+        XCTAssertTrue(warning.waitForNonExistence(timeout: 5))
+        XCTAssertFalse(app.images["UsdtSendSuccess"].exists)
+        start.press(forDuration: 0.1, thenDragTo: end)
+        XCTAssertTrue(warning.waitForExistence(timeout: 5))
+        XCTAssertTrue(feeWarning.exists)
+        warning.buttons["Yes, Send"].tap()
+        XCTAssertTrue(app.images["UsdtSendSuccess"].waitForExistence(timeout: 40), app.debugDescription)
+        capture(app, "USDT sent")
+        app.buttons["Details"].tap()
+        XCTAssertTrue(app.staticTexts["Confirmed"].waitForExistence(timeout: 30), app.debugDescription)
+        capture(app, "USDT activity")
+        let nativeBalance = try await forkCall("eth_getBalance", [address, "latest"]) as? String
+        XCTAssertEqual(nativeBalance, "0x0")
+        app.terminate()
+        app.launchEnvironment["USDT_RPC_URL"] = "http://127.0.0.1:18549"
+        app.launch()
+        XCTAssertTrue(app.buttons["UsdtWallet"].waitForExistence(timeout: 30))
+        app.buttons["UsdtWallet"].tap()
+        XCTAssertTrue(app.buttons["UsdtActivity-0"].waitForExistence(timeout: 10))
+        capture(app, "USDT saved activity offline after restart")
+    }
+
+    @MainActor
+    private func capture(_ app: XCUIApplication, _ name: String) {
+        let attachment = XCTAttachment(screenshot: app.screenshot())
+        attachment.name = name
+        attachment.lifetime = .keepAlways
+        add(attachment)
+    }
+
+    private func forkCall(_ method: String, _ params: [Any]) async throws -> Any {
+        var request = URLRequest(url: URL(string: "http://127.0.0.1:18546")!)
+        request.timeoutInterval = 5
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = try JSONSerialization.data(withJSONObject: ["jsonrpc": "2.0", "id": 1, "method": method, "params": params])
+        let (data, _) = try await URLSession.shared.data(for: request)
+        let response = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any])
+        return try XCTUnwrap(response["result"])
+    }
+
+    @MainActor
+    func testReceiveAndInvalidPaymentStaySeparateFromBitcoin() throws {
+        continueAfterFailure = false
+        let app = XCUIApplication()
+        app.launchEnvironment["USDT_RPC_URL"] = "http://127.0.0.1:18545"
+        app.launchEnvironment["USDT_BUNDLER_URL"] = "http://127.0.0.1:18546"
+        app.launch()
+        if app.buttons["Continue"].waitForExistence(timeout: 3) {
+            app.buttons["Continue"].tap()
+        }
+        if app.buttons["SkipIntro"].waitForExistence(timeout: 3) {
+            app.buttons["SkipIntro"].tap()
+            XCTAssertTrue(app.buttons["NewWallet"].waitForExistence(timeout: 5))
+            app.buttons["NewWallet"].tap()
+        }
+        XCTAssertTrue(app.buttons["UsdtWallet"].waitForExistence(timeout: 90), app.debugDescription)
+        app.buttons["UsdtWallet"].tap()
+        XCTAssertTrue(app.buttons["UsdtReceive"].waitForExistence(timeout: 5))
+        app.buttons["UsdtReceive"].tap()
+        XCTAssertTrue(app.staticTexts["UsdtReceiveAddress"].waitForExistence(timeout: 30), app.debugDescription)
+        XCTAssertTrue(app.staticTexts["UsdtReceiveAddress"].label.hasPrefix("0x"))
+        XCTAssertTrue(app.staticTexts.containing(NSPredicate(format: "label CONTAINS %@", "Arbitrum One only")).firstMatch.exists)
+        let back = app.buttons.matching(identifier: "NavigationBack")
+        try XCTUnwrap(back.allElementsBoundByIndex.first(where: \.isHittable)).tap()
+        app.buttons["UsdtSend"].tap()
+        XCTAssertTrue(app.buttons["UsdtManual"].waitForExistence(timeout: 5))
+        app.buttons["UsdtManual"].tap()
+        let recipient = app.textViews["UsdtRecipient"]
+        XCTAssertTrue(recipient.waitForExistence(timeout: 5))
+        recipient.tap()
+        recipient.typeText("bc1qnotanethereumaddress")
+        app.buttons["UsdtRecipientContinue"].tap()
+        XCTAssertTrue(app.staticTexts["UsdtError"].waitForExistence(timeout: 5))
+        XCTAssertFalse(app.buttons["N1"].exists)
+        recipient.tap()
+        recipient.typeText(String(repeating: XCUIKeyboardKey.delete.rawValue, count: "bc1qnotanethereumaddress".count))
+        recipient
+            .typeText(
+                "ethereum:0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9@42161/transfer?address=0x0000000000000000000000000000000000000001&uint256=1.23e6"
+            )
+        app.buttons["UsdtRecipientContinue"].tap()
+        XCTAssertTrue(app.buttons["N1"].waitForExistence(timeout: 5))
+        XCTAssertTrue(app.staticTexts["1.23"].exists)
+        for digit in 4 ... 8 {
+            app.buttons["N\(digit)"].tap()
+        }
+        XCTAssertTrue(app.staticTexts["1.234567"].exists)
+        XCTAssertFalse(app.otherElements["UsdtConfirm"].exists)
+        let screenshot = XCTAttachment(screenshot: app.screenshot())
+        screenshot.lifetime = .keepAlways
+        add(screenshot)
+    }
+}
diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
new file mode 100644
index 000000000..d6e896ce5
--- /dev/null
+++ b/Docs/USDT-QA.md
@@ -0,0 +1,70 @@
+# USDT manual integration checks
+
+The journey environment does not provide funded Arbitrum or cross-network accounts, controlled USDT provider/RPC/bundler responses, encrypted VSS outages, or a subscription billing clock. Run these checks separately with the named capability and record the build, configuration, actual transaction evidence, and whether evidence came from a fixture or a live service. Wallet resets and transfers require the owner’s authorization.
+
+The repository has a local Arbitrum fork payment fixture at `bitkit-core/tests/usdt-fork`, exercised by `UsdtWalletUITests.testPaymentUsesUsdtOnLocalArbitrumFork`. It does not provide the VSS outage, cross-platform restore, bridge-provider, or billing-clock controls below.
+
+## usdt bridge quotes
+
+A funded Arbitrum wallet uses the real gateway with USDT0 and Orchestra enabled. This journey obtains quotes only; do not swipe to pay or create any funded order.
+
+- [ ] Open USDT from the home balance, then Send. Verify UsdtNetwork offers Arbitrum and the enabled provider destinations.
+- [ ] Choose Base, open manual entry and enter an owned EVM address. Enter an affordable USDT amount and continue to review.
+- [ ] Verify the review displays Base, the selected Orchestra provider in details, estimated destination receipt, included bridge cost, maximum source fee and maximum total debit. All amounts use USDT.
+- [ ] Close without paying. Start a send to Polygon and obtain a quote to an owned address. Verify the selected provider is shown and the same amount and fee fields remain clear.
+- [ ] Close without paying. Select Solana and verify an EVM address is rejected, then select Tron and verify an EVM address is rejected.
+- [ ] Close Send and verify the home balance has not changed and no outgoing payment was created.
+
+## usdt outbound bridge
+
+USDT is configured against the real gateway; both app and service enable Polygon through USDT_BRIDGE_NETWORKS, and USDT_BRIDGES_URL enables Orchestra destinations. Use a funded wallet and an owned destination address. Mainnet transfers require authorization. Preserve wallet data, keep authentication out of recordings, and record actual transaction hashes and fees.
+
+- [ ] Open the home screen and verify the USDT balance, then open USDT and Send.
+- [ ] Choose Polygon in UsdtNetwork and open manual address entry. Verify an invalid address and an Arbitrum-specific payment URI cannot advance.
+- [ ] Select Arbitrum and accept an Arbitrum payment URI. Go back from amount entry and change to Polygon. Verify the previous recipient and amount are cleared and must be entered again.
+- [ ] Enter the owned destination address and a small USDT amount. Verify the review shows Polygon, the full recipient, selected provider, estimated received amount, included Orchestra routing cost where applicable, additional maximum source fee and maximum total debit in USDT.
+- [ ] Authorize one payment. Verify it appears in activity as awaiting cross-network delivery rather than claiming delivery from source-chain execution alone.
+- [ ] Restart the app and verify the same transfer continues tracking without sending a second payment.
+- [ ] Verify destination delivery independently from its transaction receipt, token, recipient, amount and balance. Confirm activity details update and the Arbitrum wallet retains zero ETH.
+- [ ] Return home and verify the updated USDT balance. Verify Paykit payment choices remain Arbitrum-only.
+
+## usdt cross-network receive
+
+Requires a wallet with USDT enabled and a matching backend with Orchestra credentials and accepted source networks enabled. Address and estimate checks do not move funds. Run settlement steps only with separately authorized funds; fixtures must be identified as such.
+
+- [ ] Open the USDT wallet and Receive. Verify direct Arbitrum One receiving is available.
+- [ ] Open the network selector. Verify only configured supported sources are offered: Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain.
+- [ ] Select each enabled source network, enter an amount within its live limits, and get its deposit address. Verify the selected network, reusable address, estimated received amount and deduction are shown. Verify the QR and Copy action use the same address.
+- [ ] Return to Arbitrum One and verify its original wallet address remains unchanged.
+- [ ] Open cross-network deposit activity. Verify empty history and Load more work without showing a failure.
+- [ ] Enter an amount below the route minimum and verify the limit error appears without a deposit address.
+- [ ] Edit the amount. Verify the old limit error clears immediately, one short fee hint is shown above the keypad divider, and the keypad and button remain fully visible. Get an address with an amount within the route limits.
+- [ ] With a separately authorized source deposit, verify pending progress becomes completed only after destination delivery, and that the green receive celebration, normal USDT activity and main-screen balance independently show the Arbitrum receipt. Record the complete flow.
+- [ ] Reopen the app and verify the reusable address and deposit history are recovered. Inspect source and destination transaction IDs in the details.
+- [ ] For a provider-held deposit, verify refund-address entry, explicit review and payment authentication. Do not submit a live refund without authorization. Unknown assets require support. For a completed refund, verify the refund transaction is shown and no delivery is claimed.
+
+## usdt payment recovery
+
+Use disposable wallets and a controlled RPC, bundler and encrypted VSS test environment. The funding and backup-outage controls require the test harness; never erase a funded demo wallet. Verify the same steps on iOS and Android, including restoring the opposite platform's wallet envelope.
+
+- [ ] Create a USDT Paykit request and open its payment review.
+- [ ] Make the test VSS endpoint unavailable, then approve the payment.
+- [ ] Verify the backup error is visible, the payment remains pending, and the mock bundler received no submission.
+- [ ] Restore VSS availability and refresh the wallet. Verify submission uses the original approved payment and that its encrypted backup includes the pending operation and request association.
+- [ ] Restore that backup into a disposable wallet on the other platform using the same test seed.
+- [ ] Refresh the restored wallet. Verify it reconciles or retries the same signed operation and does not create a second payment.
+- [ ] Mine the test operation and refresh. Verify a single activity entry, the original request attribution, and successful proof delivery.
+- [ ] Repeat restore with an unavailable local storage dependency. Verify restore remains incomplete and no replacement wallet backup is uploaded.
+
+## Paykit settlement, later installments and evidence
+
+Requires funded Arbitrum accounts, controlled billing time, and controlled receipt evidence, none of which is listed in Capabilities.
+
+- [ ] Open the home screen and verify the USDT balance is visible and a funded USDT wallet does not show empty-wallet onboarding.
+- [ ] Continue to review and verify recipient, amount and additional USDT fee before authorizing payment.
+- [ ] Complete payment with the receiver viewing Subscriptions and verify success, green receive celebration, activity details and the actual received amount on both wallets.
+- [ ] Restart both apps and verify the same payment history and request attribution, with no second payment.
+- [ ] Create a BTC request accepting Bitcoin and USDT. Switch the payer between Savings, Spending when enabled, and USDT; verify the requested value is preserved and the quoted amount and fee appear before approval.
+- [ ] Using a controlled billing clock, advance to the next installment with the requester offline. Verify its USD amount still maps exactly to USDT, the fee remains additional, and earlier paid periods remain unchanged.
+- [ ] Using controlled payment evidence, verify underpayment and payment after expiry show actual received funds and the corresponding status, without reporting the transfer as failed.
+- [ ] Pay a contact directly without a request and verify the normal asset selector, send review and activity attribution still work. Verify selecting USDT does not request camera access for an already resolved recipient.
diff --git a/Docs/USDT.md b/Docs/USDT.md
new file mode 100644
index 000000000..0d17c00c7
--- /dev/null
+++ b/Docs/USDT.md
@@ -0,0 +1,45 @@
+# USDT configuration
+
+USDT uses Arbitrum One regardless of the Bitcoin network setting. `USDT_RPC_URL` and `USDT_BUNDLER_URL` must point to the controlled service's credential-free HTTPS chain and bundler routes. Info.plist/build settings provide release configuration; local runs can supply process environment overrides. Missing endpoints hide the wallet entry.
+
+Optional `USDT_DEPOSITS_URL` enables wallet-signed Orchestra deposits. Provider keys remain on the service. Source support covers Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain, subject to explicit service enablement and live route availability. Each source requires funded acceptance before release. Users approve a source-network refund address when requesting an eligible refund; unconverted Tron refunds require provider support. History and addresses recover under the same provider partner account. Linked order amounts are batch totals. Outbound USDT0 destinations are enabled with `USDT_BRIDGE_NETWORKS`, a comma-separated subset of `ethereum,polygon,plasma,stable`, matching the service configuration. Empty configuration offers Arbitrum only. Paykit always uses direct Arbitrum payments.
+
+`scripts/build-usdt-local.sh` accepts a core checkout followed by xcodebuild arguments and selects the local package through `BITKIT_CORE_LOCAL`. Bindings and native libraries must come from the same core build.
+
+`UsdtWalletManager` owns credentials, native payment authorization and lifecycle. Refresh work runs while the scene is active, with faster refresh during receive/pending flows and rate-limit backoff. Transaction IDs and explorer links appear when a transaction hash is available; Arbiscan links are built by the app. Failed/replaced payment details do not claim recipient delivery. Wallet wipe closes core handles before deleting wallet-specific USDT files.
+
+Protocol and recovery behavior belong to bitkit-core's USDT module documentation; provider deployment belongs to the service documentation.
+
+History catch-up is deferred while the USDT send sheet is open. Balance and pending-payment recovery continue; a history scan already in progress is allowed to finish. Unknown deposit-provider statuses require attention instead of appearing as ordinary pending deposits. Cross-network payment details label the recipient amount as expected until delivery is confirmed.
+
+## Paykit
+
+Paykit uses the released rc63 SDK and a direct Arbitrum USDT0 endpoint (`usdt-arbitrum-address`). Existing public/private sharing settings control publication. The payload binds the address, chain 42161 and pinned token; bridge routes are excluded from Paykit choices.
+
+Bitkit creates BTC or USD requests and also reads USDT-denominated requests from other wallets. The accepted methods are immutable request terms. Every accepted cross-asset currency has an explicit requester-supplied rate; the denominating asset needs no conversion. USD/USDT is exactly 1:1. Bitcoin rates come from the existing BTC/USD source when issuing terms, not when verifying received funds. External requests without rates allow only same-asset payment. A listed method without its required rate cannot be used.
+
+Required amounts are rounded upward once to Bitkit's payment precision (satoshis for Bitcoin and six decimal places for USDT). Fees are additional. Approval pins the amount, quote identifier and validity interval; changes requiring new approval return through review. Receipt validation uses those terms with no percentage tolerance or later market repricing.
+
+One-time requests use the selected expiry as both the acceptance limit and actual payment deadline. Bitkit-created subscriptions accept only enabled Bitcoin methods (Savings/Spending) for BTC amounts, or USDT for USD amounts. USD subscriptions include a fixed 1:1 USDT rate for every installment; BTC subscriptions need no conversion. No recurring quote publisher or requester availability is needed to price later installments. External per-period quotes and absolute or period-relative deadlines are still honored, and existing subscription terms and proof history are not rewritten. Each installment requires payer approval; accepting a subscription does not authorize automatic payments.
+
+Before sending USDT, the app durably associates the request and billing period with the core payment ID and immutable proof binding. After successful execution, core signs the released `erc20-transfer-eip712` proof over both participants, the receiving payment app, request reference, endpoint, billing period and selected quote. The full proof envelope is size-checked before sending. Retries and restarts deliver the same proof without another transfer; a replacement payment is allowed only for an unstarted attempt without a core operation or a definitively failed/replaced operation. Wallet backups retain these associations, started-payment markers, received-payment identities and selected conversion quotes; missing execution history after restore never authorizes a replacement payment.
+
+Receipts require successful canonical execution, the correct chain/token/recipient and the transfer sender's signature. A payment is identified by verified chain, transaction and original receipt-log position and can satisfy at most one request/period. Real funds are displayed as received, underpaid or after expiry, with their actual amount. Overpayment is accepted; underpayment and late payment do not start a dispute, refund or top-up workflow. Unavailable evidence remains pending; a previously verified receipt is rechecked without discarding its attribution. Bitcoin retains its existing settlement behavior.
+
+## Encrypted recovery backups
+
+The wallet backup includes core's portable USDT recovery snapshot alongside Paykit request bindings, pending proofs and received-payment identities. It contains signed operations and stable activity IDs, but no private keys or seed. The existing VSS client encrypts and authenticates the complete envelope. History cursors and unsigned quotes are rebuilt locally.
+
+Core waits for the app to acknowledge a VSS upload before first submission or automatic rebroadcast. If backup is unavailable, the signed payment stays pending locally and no submission is attempted; recovery retries the same operation once backup is available, or reconciles its expiry against the chain. Wallet uploads are serialized so an older background snapshot cannot replace a payment's acknowledged backup.
+
+Restore merges records for the derived account without overwriting newer local outcomes. Signed operations imported into an empty database are reconciled against chain evidence before retry; already discovered transactions retain their restored application IDs. A failed restore retains the downloaded envelope and blocks replacement backups. Bitcoin-only backups remain readable. Seed-only recovery restores account control and chain history, but cannot reconstruct a never-mined signed operation or its Paykit attribution. Missing evidence never authorizes a second payment.
+
+## Outbound provider selection
+
+Configure `USDT_BRIDGES_URL` with the gateway's credential-free `/v1/usdt/bridges` route to enable Orchestra. The network selector combines the gateway's enabled Orchestra destinations with the app's `USDT_BRIDGE_NETWORKS` USDT0 destinations. Direct Arbitrum and Paykit remain unchanged. Core chooses the best usable estimated receipt per maximum total source debit, including the source paymaster fee; a tie prefers USDT0.
+
+Orchestra routing costs are deducted from the entered USDT principal. Review shows estimated destination receipt, included route cost, additional maximum source fee and maximum total debit. Fees remain in USDT, including when the provider uses intermediate assets. The chosen quote is frozen before signing. Funding and delivery are separate: activity retains the original recipient and network through pending delivery, provider attention and a verified Arbitrum refund. A timeout, restart or provider failure never starts a payment through another provider. Encrypted backup includes the funding plan and tracking ticket; seed-only history cannot reconstruct them.
+
+## Validation
+
+UI journeys cover unfunded wallet navigation, immutable request review and receiving-detail consent. [Manual integration checks](USDT-QA.md) cover funded settlement, provider behavior, restore faults and billing-clock changes that the journey environment does not supply.
diff --git a/Docs/earn-receiving-details.md b/Docs/earn-receiving-details.md
new file mode 100644
index 000000000..9e6030983
--- /dev/null
+++ b/Docs/earn-receiving-details.md
@@ -0,0 +1,39 @@
+# Earn receiving-details claims
+
+Bitkit lets an Earn service request a Bitcoin watch-only account, the existing USDT address on Arbitrum One, or both through the existing Pubky Auth approval flow. This contract covers address sharing, not USDT invoicing, payment verification or purchase delivery.
+
+## Request and approval
+
+Use exactly one `x-bitkit-claim` query parameter:
+
+| Claim | Shared details |
+| --- | --- |
+| `watch-only-account-v1` | A separate native-SegWit Bitcoin account, using the existing 84-byte payload |
+| `usdt-address-v1` | The existing USDT Arbitrum receiving endpoint |
+| `payment-details-v1` | Both that endpoint and a separate Bitcoin account |
+
+All three require exactly `/pub/paykit/:rw`. Unknown or repeated claim parameters and mismatched capabilities are rejected. Changing the claim changes the request identity and companion channel.
+
+The user first sees the existing Earn introduction, then the authorization review showing the requested assets. The USDT address is expandable and copyable. Approval is unavailable until the address can be read, and Bitkit re-reads it before sending to ensure it is the address reviewed. Canceling before authorization shares nothing and allocates no Bitcoin account.
+
+USDT sharing creates no account, changes no public-sharing preference and gives no permission to spend. The receiver can observe the account's public balance and transaction history. Different services receive the same USDT address. Bitcoin sharing retains its separate account allocation and tracked retry/recovery lifecycle.
+
+## Payload
+
+For `usdt-address-v1`, the unsigned payload is a UTF-8 JSON object with exactly the `usdt-arbitrum-address` key. Its endpoint contains string fields `value` (the EVM address), `chain_id` (`42161`) and `token` (`0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9`).
+
+For `payment-details-v1`, the unsigned JSON additionally contains `bitcoin_account`, with `account_index` (an unsigned integer), `address_type` (`nativeSegwit`) and `xpub` (Base58Check text). Wallet-local names and identifiers are not shared. The xpub's version identifies its Bitcoin network; the server must check it against its configured network.
+
+JSON key order is not significant. Verify the signature over the received bytes before decoding; do not reconstruct or reserialize the object for verification. The existing `watch-only-account-v1` binary format is unchanged.
+
+## Signed delivery
+
+Use Paykit's companion-claim approval API with the exact selected claim name. The signature input is UTF-8 `x-bitkit-claim|<claim>|`, followed by SHA256 of the decoded 32-byte auth request secret, followed by the unsigned payload bytes. Paykit appends the 64-byte Ed25519 signature and encrypts the signed payload using the existing XSalsa20-Poly1305 envelope.
+
+The companion channel is base64url-no-pad of BLAKE3 over UTF-8 `<claim>|` followed by the decoded request secret. The normal AuthToken channel is unchanged. Claim delivery precedes normal auth approval. The signature is verified against the creator's authenticated Pubky public key. It binds the receiving details to that identity and request, not to ownership of an EVM private key.
+
+## Server integration
+
+Paykit Server's current implementation accepts only `watch-only-account-v1`. Supporting the new claim names requires using the requested claim name for channel derivation and signature verification, parsing the appropriate payload after verification, validating the pinned endpoint and optional Bitcoin account, and durably storing the selected receiving details before acknowledging setup. Existing Bitcoin setup and stored credentials must remain readable; neither USDT-only sharing nor combined sharing authorizes deleting them.
+
+The server must not treat a shared USDT address as an enabled USDT checkout method. USDT invoice creation and payment verification are separate work. A server should issue these new claim requests only when it can accept and store them. Bitkit should not advertise a completed production Earn integration until that server behavior is available and tested together.
diff --git a/changelog.d/next/usdt.added.md b/changelog.d/next/usdt.added.md
new file mode 100644
index 000000000..eb1ecfe46
--- /dev/null
+++ b/changelog.d/next/usdt.added.md
@@ -0,0 +1 @@
+Send and receive USDT with fees paid in USDT, Paykit contact payments and requests, subscriptions, cross-network deposits, Earn address sharing, and encrypted payment recovery backups.
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
new file mode 100644
index 000000000..b93cef431
--- /dev/null
+++ b/journeys/paykit-quoted-usdt.xml
@@ -0,0 +1,11 @@
+<journey name="paykit quoted usdt requests">
+  <description>Two linked Bitkit wallets with Paykit and USDT enabled, sharing enabled by their owners, and a fresh BTC/USD rate. No funded account is required: stop at Amount and do not authorize a payment. Funded settlement, later installments and controlled evidence checks are manual tests in Docs/USDT-QA.md.</description>
+  <actions>
+    <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available.</action>
+    <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
+    <action>On the payer, open the request. Verify Amount shows exactly 1 USDT, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing.</action>
+    <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
+    <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its amount, recurrence and payment method; close before subscribing.</action>
+    <action>Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing.</action>
+  </actions>
+</journey>
diff --git a/journeys/pubky-auth/share-receiving-details.xml b/journeys/pubky-auth/share-receiving-details.xml
new file mode 100644
index 000000000..8d3d06717
--- /dev/null
+++ b/journeys/pubky-auth/share-receiving-details.xml
@@ -0,0 +1,13 @@
+<journey name="review Earn receiving details">
+  <description>Use an onboarded wallet with a Pubky identity and configured USDT. Use a local test auth request; cancel before Authorize so no receiving details or session are exported.</description>
+  <actions>
+    <action>Open the existing watch-only setup fixture with x-bitkit-claim=usdt-address-v1</action>
+    <action>Verify the Earn USDT introduction, then tap Approve</action>
+    <action>Verify only USDT Arbitrum details, the existing address and balance/history disclosure are shown</action>
+    <action>Expand the address and copy it; verify it matches the wallet receive address</action>
+    <action>Cancel and verify no Bitcoin account was created</action>
+    <action>Repeat with x-bitkit-claim=payment-details-v1; verify Bitcoin and USDT appear together, then cancel</action>
+    <action>Repeat with x-bitkit-claim=watch-only-account-v1; verify only Bitcoin is requested, then cancel</action>
+    <action>With USDT unavailable, verify USDT authorization is disabled and Retry reloads the address</action>
+  </actions>
+</journey>
diff --git a/journeys/subscriptions/create-and-propose.xml b/journeys/subscriptions/create-and-propose.xml
index 0d5b6961c..25d89c4a3 100644
--- a/journeys/subscriptions/create-and-propose.xml
+++ b/journeys/subscriptions/create-and-propose.xml
@@ -18,7 +18,7 @@
     <action>Tap Create (id "SubscriptionCreate")</action>
     <action>Verify the create sheet (id "CreateSubscription") appears with Choose Recipient disabled</action>
     <action>Tap the amount pencil (id "SubscriptionEditAmount"), enter "5000" on the keypad, and tap Continue (id "PaymentRequestAmountContinue")</action>
-    <action>Verify the amount reads 5,000 sats</action>
+    <action>Verify the amount reads 5,000 sats and the accepted methods show only enabled Savings or Spending options, with no USDT</action>
     <action>Type "Journey Sub" into the subscription name field (id "SubscriptionName")</action>
     <action>Enter 600 ASCII letters in the description field (id "SubscriptionDescription")</action>
     <action>Verify the frequency selector has "Monthly" selected (id "Tab-month")</action>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
new file mode 100644
index 000000000..da33097fb
--- /dev/null
+++ b/journeys/usdt-wallet-navigation.xml
@@ -0,0 +1,10 @@
+<journey name="usdt wallet navigation">
+  <description>Use an onboarded wallet in an E2E build with USDT RPC and bundler URLs configured. No chain funding or live provider is required. A network error may be visible when services are offline; no payment is submitted.</description>
+  <actions>
+    <action>Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet.</action>
+    <action>Open Receive. Verify the address starts with 0x and the network is Arbitrum One. Open details and verify Copy and the QR show the same address.</action>
+    <action>Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing.</action>
+    <action>Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote.</action>
+    <action>Return Home and open Bitcoin Receive. Verify the Bitcoin address, network and amount controls remain separate from USDT.</action>
+  </actions>
+</journey>
diff --git a/scripts/build-usdt-local.sh b/scripts/build-usdt-local.sh
new file mode 100755
index 000000000..559cdeb53
--- /dev/null
+++ b/scripts/build-usdt-local.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+set -euo pipefail
+core_dir="$(cd "${1:?Usage: build-usdt-local.sh CORE_DIRECTORY [xcodebuild arguments]}" && pwd)"
+shift
+for argument in "$@"; do
+    if [[ "$argument" == "Release" || "$argument" == "archive" ]]; then
+        echo "Local core overrides are only for development builds" >&2
+        exit 1
+    fi
+done
+repo_dir="$(cd "$(dirname "$0")/.." && pwd)"
+local_dir="$repo_dir/build/usdt-local"
+mkdir -p "$local_dir/BitkitUsdt.xcworkspace"
+ln -sfn "$core_dir" "$local_dir/bitkit-core"
+python3 - "$local_dir" "$repo_dir" <<'PY'
+from pathlib import Path
+import json
+from xml.sax.saxutils import quoteattr
+import sys
+local, repo = map(Path, sys.argv[1:])
+resolved = local/'BitkitUsdt.xcworkspace/xcshareddata/swiftpm'
+resolved.mkdir(parents=True, exist_ok=True)
+lock = json.loads((repo/'Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved').read_text())
+lock['pins'] = [pin for pin in lock['pins'] if pin['identity'] != 'bitkit-core']
+(resolved/'Package.resolved').write_text(json.dumps(lock, indent=2) + '\n')
+(local/'BitkitUsdt.xcworkspace/contents.xcworkspacedata').write_text(
+    '<?xml version="1.0" encoding="UTF-8"?><Workspace version="1.0">'
+    + '<FileRef location=' + quoteattr('absolute:'+str(repo/'Bitkit.xcodeproj')) + '/>'
+    + '<FileRef location=' + quoteattr('absolute:'+str(local/'bitkit-core')) + '/></Workspace>')
+PY
+BITKIT_CORE_LOCAL=1 xcodebuild -workspace "$local_dir/BitkitUsdt.xcworkspace" -scheme Bitkit "$@"

From 18a5c4af1fd12f64e1a58a8c094e85dfa769c4f0 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 6 Oct 2026 22:39:58 -0500
Subject: [PATCH 02/62] fix: preserve payment recovery and final authorization

---
 .../TrezorPublicKeyResponse+StoredKey.swift   |  20 +++
 Bitkit/Managers/TrezorManager.swift           |   3 +-
 Bitkit/Managers/UsdtWalletManager.swift       |   3 +-
 Bitkit/Services/BackupService.swift           |   1 +
 .../Services/PaykitUsdtPaymentService.swift   |  27 ++--
 .../PrivatePaykitService+Backup.swift         |   3 +-
 Bitkit/Services/PubkyService.swift            |   8 +-
 .../ViewModels/Trezor/TrezorViewModel.swift   |  35 ++++-
 Bitkit/Views/Trezor/TrezorPublicKeyView.swift |   4 +-
 .../PaykitPaymentRequestServiceTests.swift    |  10 +-
 BitkitTests/PaykitSdkOperationLockTests.swift |   6 +-
 BitkitTests/TrezorStoredAccountKeyTests.swift | 135 ++++++++++++++++++
 BitkitTests/TrezorViewModelWatcherTests.swift |  36 +++++
 Docs/USDT.md                                  |   4 +-
 14 files changed, 264 insertions(+), 31 deletions(-)
 create mode 100644 Bitkit/Extensions/TrezorPublicKeyResponse+StoredKey.swift
 create mode 100644 BitkitTests/TrezorStoredAccountKeyTests.swift

diff --git a/Bitkit/Extensions/TrezorPublicKeyResponse+StoredKey.swift b/Bitkit/Extensions/TrezorPublicKeyResponse+StoredKey.swift
new file mode 100644
index 000000000..bc0e04e12
--- /dev/null
+++ b/Bitkit/Extensions/TrezorPublicKeyResponse+StoredKey.swift
@@ -0,0 +1,20 @@
+import BitkitCore
+
+extension TrezorPublicKeyResponse {
+    /// Account key to persist on a known device for `addressType`.
+    ///
+    /// Since bitkit-core 0.7.0 `xpub` is always a normalized `xpub`/`tpub`, while known devices
+    /// paired on earlier versions stored the firmware's SLIP-132 form (`ypub`/`zpub`/`upub`/`vpub`)
+    /// for BIP-49/BIP-84. Those strings feed `walletKey`, entry matching and `deriveWalletId`, so
+    /// they must stay byte-identical: SegWit types keep `xpubSegwit`, Legacy and Taproot keep `xpub`
+    /// (Taproot `xpubSegwit` can be a descriptor). See bitkit-core `src/modules/trezor/README.md`,
+    /// "Migrating to trezor-connect-rs 10.0.0 (Core 0.7.0)".
+    func storedAccountKey(for addressType: AddressScriptType) -> String {
+        switch addressType {
+        case .nestedSegwit, .nativeSegwit:
+            return xpubSegwit ?? xpub
+        case .legacy, .taproot:
+            return xpub
+        }
+    }
+}
diff --git a/Bitkit/Managers/TrezorManager.swift b/Bitkit/Managers/TrezorManager.swift
index 6def3f1f9..7547ba71e 100644
--- a/Bitkit/Managers/TrezorManager.swift
+++ b/Bitkit/Managers/TrezorManager.swift
@@ -813,7 +813,8 @@ final class TrezorManager {
             var lastError: Error?
             for attempt in 1 ... Self.maxXpubFetchAttempts {
                 do {
-                    result[addressType.stringValue] = try await trezorService.getPublicKey(params: params).xpub
+                    let response = try await trezorService.getPublicKey(params: params)
+                    result[addressType.stringValue] = response.storedAccountKey(for: addressType)
                     lastError = nil
                     break
                 } catch {
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index c92712210..c2cba39b9 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -132,13 +132,14 @@ final class UsdtWalletManager {
         return try PaykitUsdt.endpoint(address: wallet.receiveAddress())
     }
 
-    func send(_ quote: UsdtQuote) async throws {
+    func send(_ quote: UsdtQuote, beforeSubmission: @escaping @MainActor () async throws -> Void = {}) async throws {
         try beginOperation()
         defer { finishOperation() }
         let wallet = try await wallet()
         let transfer = try await ServiceQueue.background(.core, wrapErrors: false) {
             guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
             let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
+            try await beforeSubmission()
             return try await wallet.send(quoteId: quote.id, mnemonic: mnemonic, passphrase: passphrase)
         }
         transfers.removeAll { $0.id == transfer.id }
diff --git a/Bitkit/Services/BackupService.swift b/Bitkit/Services/BackupService.swift
index 975a9aa8d..332a9d26a 100644
--- a/Bitkit/Services/BackupService.swift
+++ b/Bitkit/Services/BackupService.swift
@@ -231,6 +231,7 @@ class BackupService {
 
             do {
                 if category == .wallet {
+                    try await PaykitPaymentActivity.shared.waitUntilIdle()
                     try await persistWalletBackup()
                 } else {
                     let data = try await getBackupDataBytes(category: category)
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
index 4770f7799..ccb56f2c3 100644
--- a/Bitkit/Services/PaykitUsdtPaymentService.swift
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -113,23 +113,24 @@ final class PaykitUsdtPaymentService {
     }
 
     func send(_ quote: UsdtQuote, context: ContactPaymentContext, paymentTerms: PaykitRequestPricing.Payment?,
-              wallet: UsdtWalletManager, authorize: () async throws -> Void) async throws
+              wallet: UsdtWalletManager, authorize: @escaping @MainActor () async throws -> Void) async throws
     {
         try setPaymentStarted(quoteId: quote.id, started: true)
         do {
-            try await authorize()
-            try Task.checkCancellation()
-            if let request = context.incomingPaymentRequest {
-                guard !request.isExpired(at: Date()),
-                      request.acceptsPayment(PaykitAmount(asset: .usdt, atomic: quote.amount), paymentTerms: paymentTerms)
-                else { throw PaykitPaymentRequestError.amountMismatch }
+            try await wallet.send(quote) {
+                do {
+                    try await authorize()
+                    try Task.checkCancellation()
+                    if let request = context.incomingPaymentRequest {
+                        guard !request.isExpired(at: Date()),
+                              request.acceptsPayment(PaykitAmount(asset: .usdt, atomic: quote.amount), paymentTerms: paymentTerms)
+                        else { throw PaykitPaymentRequestError.amountMismatch }
+                    }
+                } catch {
+                    try? self.setPaymentStarted(quoteId: quote.id, started: false)
+                    throw error
+                }
             }
-        } catch {
-            try? setPaymentStarted(quoteId: quote.id, started: false)
-            throw error
-        }
-        do {
-            try await wallet.send(quote)
         } catch {
             // Core persists signed operations before broadcast. Only this completed send can establish non-submission.
             if !(error is CancellationError), await (try? wallet.storedTransfer(quote.id) == nil) == true {
diff --git a/Bitkit/Services/PrivatePaykitService+Backup.swift b/Bitkit/Services/PrivatePaykitService+Backup.swift
index ba37f0be2..da15fb70d 100644
--- a/Bitkit/Services/PrivatePaykitService+Backup.swift
+++ b/Bitkit/Services/PrivatePaykitService+Backup.swift
@@ -7,8 +7,9 @@ extension PrivatePaykitService {
         guard try await PaykitSdkService.shared.currentPublicKey() != nil else {
             return nil
         }
+        // Wallet backups may be required before broadcast; they cannot wait for payment to finish.
         let backup = try await Backup(
-            sdkState: PaykitSdkService.shared.exportBackupState(),
+            sdkState: PaykitSdkService.shared.exportBackupState(priority: .interactive),
             consumedPrivatePaymentListVersions: state.contacts.compactMapValues { contactState in
                 contactState.consumedPrivatePaymentListVersion
             }
diff --git a/Bitkit/Services/PubkyService.swift b/Bitkit/Services/PubkyService.swift
index 6dc86a3a2..a037a7753 100644
--- a/Bitkit/Services/PubkyService.swift
+++ b/Bitkit/Services/PubkyService.swift
@@ -1192,17 +1192,17 @@ actor PaykitSdkService {
         }
     }
 
-    func exportBackupState() async throws -> String {
+    func exportBackupState(priority: PaykitSdkOperationLock.Priority = .background) async throws -> String {
         let generation = try operationLock.walletGeneration()
         let instance = try handle()
         while true {
-            try await PaykitPaymentActivity.shared.waitUntilIdle()
-            let exported: String? = try await withSdk(priority: .background) { sdk in
+            if priority == .background { try await PaykitPaymentActivity.shared.waitUntilIdle() }
+            let exported: String? = try await withSdk(priority: priority) { sdk in
                 guard sdk === instance, try operationLock.walletGeneration() == generation else {
                     throw PubkyServiceError.identityChanged
                 }
                 // Payment may have started while this export waited for the SDK lock.
-                guard await !PaykitPaymentActivity.shared.isActive else { return nil }
+                if priority == .background, await PaykitPaymentActivity.shared.isActive { return nil }
                 return try await sdk.exportBackupString()
             }
             if let exported { return exported }
diff --git a/Bitkit/ViewModels/Trezor/TrezorViewModel.swift b/Bitkit/ViewModels/Trezor/TrezorViewModel.swift
index 3c141df3f..51ede4b96 100644
--- a/Bitkit/ViewModels/Trezor/TrezorViewModel.swift
+++ b/Bitkit/ViewModels/Trezor/TrezorViewModel.swift
@@ -56,6 +56,20 @@ enum TrezorAccountTypeSelection: String, CaseIterable, Identifiable, CustomStrin
         case .taproot: "BIP86"
         }
     }
+
+    /// Explicit selection for the BIP purpose of `path` (e.g. `m/84'/1'/0'` is `.nativeSegwit`),
+    /// or nil when the purpose is not one of BIP-44/49/84/86.
+    static func matching(derivationPath path: String) -> TrezorAccountTypeSelection? {
+        let components = path.split(separator: "/")
+        guard components.count > 1, components[0] == "m" else { return nil }
+        switch components[1].trimmingCharacters(in: CharacterSet(charactersIn: "'hH")) {
+        case "44": return .legacy
+        case "49": return .wrappedSegwit
+        case "84": return .nativeSegwit
+        case "86": return .taproot
+        default: return nil
+        }
+    }
 }
 
 /// ViewModel for the Trezor hardware-wallet dev/dashboard screens. Owns only the dev-screen
@@ -113,9 +127,15 @@ class TrezorViewModel {
     /// Account-level derivation path for public key
     var publicKeyPath: String = "m/84'/\(OnChainHwService.defaultCoinTypeComponent)/0'"
 
-    /// Retrieved xpub string
+    /// Retrieved normalized xpub/tpub. Use with `publicKeyAccountType`, since it carries no type prefix.
     var xpub: String?
 
+    /// Retrieved key formatted for display (SLIP-132 for SegWit; can be a descriptor for Taproot)
+    var displayablePublicKey: String?
+
+    /// Account type matching the retrieved key's derivation path
+    var publicKeyAccountType: TrezorAccountTypeSelection?
+
     /// Retrieved compressed public key hex
     var publicKeyHex: String?
 
@@ -452,6 +472,8 @@ class TrezorViewModel {
 
             let response = try await trezorService.getPublicKey(params: params)
             xpub = response.xpub
+            displayablePublicKey = response.displayablePublicKey
+            publicKeyAccountType = TrezorAccountTypeSelection.matching(derivationPath: response.path)
             publicKeyHex = response.publicKey
             connection.showConfirmOnDevice = false
 
@@ -571,6 +593,8 @@ class TrezorViewModel {
     func clearWalletResults() {
         generatedAddress = nil
         xpub = nil
+        displayablePublicKey = nil
+        publicKeyAccountType = nil
         publicKeyHex = nil
         signedMessage = nil
         error = nil
@@ -962,10 +986,13 @@ class TrezorViewModel {
 
     // MARK: - Event Watcher Operations
 
-    /// Copy the most recently retrieved xpub into the watcher's extended-key field.
+    /// Copy the most recently retrieved xpub into the watcher's extended-key field and select the
+    /// account type of its derivation path, since a normalized xpub/tpub would otherwise be detected as Legacy.
     func populateWatcherFromXpub() {
-        if let xpub {
-            watcherExtendedKey = xpub
+        guard let xpub else { return }
+        watcherExtendedKey = xpub
+        if let publicKeyAccountType {
+            onchainAccountTypeSelection = publicKeyAccountType
         }
     }
 
diff --git a/Bitkit/Views/Trezor/TrezorPublicKeyView.swift b/Bitkit/Views/Trezor/TrezorPublicKeyView.swift
index ffa956681..b88650b7e 100644
--- a/Bitkit/Views/Trezor/TrezorPublicKeyView.swift
+++ b/Bitkit/Views/Trezor/TrezorPublicKeyView.swift
@@ -70,8 +70,8 @@ struct TrezorPublicKeyContent: View {
             .accessibilityIdentifier("TrezorPublicKeyGet")
 
             // Results
-            if let xpub = trezor.xpub {
-                CopyableField(label: "Extended Public Key (xpub)", value: xpub, accessibilityIdentifier: "TrezorXpub")
+            if let displayablePublicKey = trezor.displayablePublicKey {
+                CopyableField(label: "Account Public Key", value: displayablePublicKey, accessibilityIdentifier: "TrezorXpub")
             }
 
             if let pubKey = trezor.publicKeyHex {
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index 85a24466c..6843106f7 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -1842,7 +1842,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
         await manager.refresh()
 
-        XCTAssertEqual(manager.pendingRequests.map(\.paymentRequestId), ["incoming", "deadline-proposed"])
+        XCTAssertEqual(manager.pendingRequests.map(\.paymentRequestId), ["incoming"])
         XCTAssertEqual(
             Set(manager.historyRequests.map(\.paymentRequestId)),
             Set([
@@ -3028,8 +3028,12 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
         await manager.refresh()
 
-        XCTAssertEqual(manager.pendingRequests.count, 1)
-        XCTAssertFalse(try XCTUnwrap(manager.pendingRequests.first).payment(to: .btc, at: now).isValid(at: now))
+        XCTAssertTrue(manager.pendingRequests.isEmpty)
+        let payerSubscription = try XCTUnwrap(manager.subscriptions.first { $0.isPayer })
+        let unpaid = try XCTUnwrap(payerSubscription.paymentDueOnAcceptance(at: now))
+        XCTAssertFalse(try unpaid.payment(to: .btc, at: now).isValid(at: now))
+        XCTAssertTrue(unpaid.isPaymentDeadlineExpired(at: now))
+        XCTAssertEqual(unpaid.paymentDeadline?.timestamp, "2027-02-01T09:00:00Z")
         XCTAssertEqual(manager.subscriptions.count, 2)
         for subscription in manager.subscriptions {
             XCTAssertEqual(subscription.paidPeriods.count, 1)
diff --git a/BitkitTests/PaykitSdkOperationLockTests.swift b/BitkitTests/PaykitSdkOperationLockTests.swift
index c96f89c2b..b82afbef3 100644
--- a/BitkitTests/PaykitSdkOperationLockTests.swift
+++ b/BitkitTests/PaykitSdkOperationLockTests.swift
@@ -268,11 +268,15 @@ final class PaykitSdkOperationLockTests: XCTestCase {
         _ = try await service.identityStatus()
         let heldEvents = await recorder.events
         XCTAssertTrue(heldEvents.isEmpty)
+        let requiredBackup = try await service.exportBackupState(priority: .interactive)
+        XCTAssertEqual(requiredBackup, "backup")
+        let paymentEvents = await recorder.events
+        XCTAssertEqual(paymentEvents, ["export"])
         PaykitPaymentActivity.shared.end(payment)
         let backup = try await export.value
         XCTAssertEqual(backup, "backup")
         let events = await recorder.events
-        XCTAssertEqual(events, ["export"])
+        XCTAssertEqual(events, ["export", "export"])
     }
 
     @MainActor
diff --git a/BitkitTests/TrezorStoredAccountKeyTests.swift b/BitkitTests/TrezorStoredAccountKeyTests.swift
new file mode 100644
index 000000000..1ca0ba87e
--- /dev/null
+++ b/BitkitTests/TrezorStoredAccountKeyTests.swift
@@ -0,0 +1,135 @@
+@testable import Bitkit
+import BitkitCore
+import XCTest
+
+/// Keys stored for a known Trezor must stay byte-identical across the bitkit-core 0.7.0 upgrade,
+/// which normalized `TrezorPublicKeyResponse.xpub` and moved the firmware SLIP-132 form to `xpubSegwit`.
+/// Fixtures are the BIP-44/49/84/86 test vectors for the "abandon ... about" mnemonic.
+final class TrezorStoredAccountKeyTests: XCTestCase {
+    private static let legacyXpub =
+        "xpub6BosfCnifzxcFwrSzQiqu2DBVTshkCXacvNsWGYJVVhhawA7d4R5WSWGFNbi8Aw6ZRc1brxMyWMzG3DSSSSoekkudhUd9yLb6qx39T9nMdj"
+    private static let nestedYpub =
+        "ypub6Ww3ibxVfGzLrAH1PNcjyAWenMTbbAosGNB6VvmSEgytSER9azLDWCxoJwW7Ke7icmizBMXrzBx9979FfaHxHcrArf3zbeJJJUZPf663zsP"
+    private static let nestedXpub =
+        "xpub6C6nQwHaWbSrzs5tZ1q7m5R9cPK9eYpNMFesiXsYrgc1P8bvLLAet9JfHjYXKjToD8cBRswJXXbbFpXgwsswVPAZzKMa1jUp2kVkGVUaJa7"
+    private static let nativeZpub =
+        "zpub6rFR7y4Q2AijBEqTUquhVz398htDFrtymD9xYYfG1m4wAcvPhXNfE3EfH1r1ADqtfSdVCToUG868RvUUkgDKf31mGDtKsAYz2oz2AGutZYs"
+    private static let nativeXpub =
+        "xpub6CatWdiZiodmUeTDp8LT5or8nmbKNcuyvz7WyksVFkKB4RHwCD3XyuvPEbvqAQY3rAPshWcMLoP2fMFMKHPJ4ZeZXYVUhLv1VMrjPC7PW6V"
+    private static let taprootXpub =
+        "xpub6BgBgsespWvERF3LHQu6CnqdvfEvtMcQjYrcRzx53QJjSxarj2afYWcLteoGVky7D3UKDP9QyrLprQ3VCECoY49yfdDEHGCtMMj92pReUsQ"
+    private static let taprootDescriptor = "tr([73c5da0a/86'/0'/0']\(taprootXpub)/<0;1>/*)"
+
+    /// Keys exactly as Core 0.5.18 (trezor-connect-rs 0.4.0) returned them in `xpub`.
+    private static let storedBeforeUpgrade = [
+        "legacy": legacyXpub,
+        "nestedSegwit": nestedYpub,
+        "nativeSegwit": nativeZpub,
+        "taproot": taprootXpub,
+    ]
+
+    // MARK: - storedAccountKey(for:)
+
+    func testSegwitTypesKeepTheFirmwareSlip132Key() {
+        XCTAssertEqual(response(for: .nestedSegwit).storedAccountKey(for: .nestedSegwit), Self.nestedYpub)
+        XCTAssertEqual(response(for: .nativeSegwit).storedAccountKey(for: .nativeSegwit), Self.nativeZpub)
+    }
+
+    func testLegacyKeepsTheXpub() {
+        XCTAssertEqual(response(for: .legacy).storedAccountKey(for: .legacy), Self.legacyXpub)
+    }
+
+    func testTaprootNeverStoresTheDescriptor() {
+        let taproot = response(for: .taproot)
+
+        XCTAssertEqual(taproot.xpubSegwit, Self.taprootDescriptor)
+        XCTAssertEqual(taproot.storedAccountKey(for: .taproot), Self.taprootXpub)
+    }
+
+    func testSegwitFallsBackToXpubWithoutASegwitForm() {
+        let response = makeResponse(xpub: Self.nativeXpub, xpubSegwit: nil, path: "m/84'/0'/0'")
+
+        XCTAssertEqual(response.storedAccountKey(for: .nativeSegwit), Self.nativeXpub)
+    }
+
+    // MARK: - Reconnect identity
+
+    /// A device paired before the upgrade reconnects: the fetched keys must equal the stored ones,
+    /// so matching, `walletKey` and the derived wallet id (for entries without a persisted id) hold.
+    func testReconnectOfAPreviouslyPairedDeviceKeepsItsIdentity() throws {
+        let stored = makeDevice(xpubs: Self.storedBeforeUpgrade)
+        let fetched = Dictionary(uniqueKeysWithValues: AddressScriptType.allAddressTypes.map {
+            ($0.stringValue, response(for: $0).storedAccountKey(for: $0))
+        })
+
+        let previous = HwKnownDeviceMatching.previous(in: [stored], deviceId: stored.id, fetchedXpubs: fetched)
+        let mergedXpubs = (previous?.xpubs ?? [:]).merging(fetched) { _, new in new }
+        let refreshed = makeDevice(xpubs: mergedXpubs)
+
+        XCTAssertEqual(previous?.id, stored.id)
+        XCTAssertEqual(mergedXpubs, Self.storedBeforeUpgrade)
+        XCTAssertEqual(HwKnownDevice.walletKey(for: mergedXpubs, fallback: stored.id), stored.walletKey)
+        XCTAssertEqual(try HwWalletId.derive(xpubs: mergedXpubs, vendor: .trezor), stored.resolvedWalletId)
+        XCTAssertEqual(HwKnownDeviceMatching.merged([stored], with: refreshed, refreshed: previous).count, 1)
+    }
+
+    // MARK: - Helpers
+
+    /// A response shaped like Core 0.7.0 returns it for the account of `addressType`.
+    private func response(for addressType: AddressScriptType) -> TrezorPublicKeyResponse {
+        switch addressType {
+        case .legacy:
+            makeResponse(xpub: Self.legacyXpub, xpubSegwit: nil, path: "m/44'/0'/0'")
+        case .nestedSegwit:
+            makeResponse(xpub: Self.nestedXpub, xpubSegwit: Self.nestedYpub, path: "m/49'/0'/0'")
+        case .nativeSegwit:
+            makeResponse(xpub: Self.nativeXpub, xpubSegwit: Self.nativeZpub, path: "m/84'/0'/0'")
+        case .taproot:
+            makeResponse(
+                xpub: Self.taprootXpub,
+                xpubSegwit: Self.taprootDescriptor,
+                descriptor: Self.taprootDescriptor,
+                displayablePublicKey: Self.taprootDescriptor,
+                path: "m/86'/0'/0'"
+            )
+        }
+    }
+
+    private func makeResponse(
+        xpub: String,
+        xpubSegwit: String?,
+        descriptor: String? = nil,
+        displayablePublicKey: String? = nil,
+        path: String
+    ) -> TrezorPublicKeyResponse {
+        TrezorPublicKeyResponse(
+            xpub: xpub,
+            xpubSegwit: xpubSegwit,
+            descriptor: descriptor,
+            displayablePublicKey: displayablePublicKey ?? xpubSegwit ?? xpub,
+            path: path,
+            publicKey: "02",
+            chainCode: "00",
+            fingerprint: 0,
+            depth: 3,
+            rootFingerprint: 0x73C5_DA0A
+        )
+    }
+
+    private func makeDevice(xpubs: [String: String]) -> HwKnownDevice {
+        HwKnownDevice(
+            id: "dev1",
+            name: "Trezor",
+            path: "ble://dev1",
+            transportType: "bluetooth",
+            lastConnectedAt: Date(timeIntervalSince1970: 0),
+            xpubs: xpubs,
+            customLabel: nil,
+            walletId: nil,
+            passphraseProtected: false,
+            trezorDeviceId: nil,
+            vendor: .trezor,
+            jadeDeviceId: nil
+        )
+    }
+}
diff --git a/BitkitTests/TrezorViewModelWatcherTests.swift b/BitkitTests/TrezorViewModelWatcherTests.swift
index a6039f485..3aaf96841 100644
--- a/BitkitTests/TrezorViewModelWatcherTests.swift
+++ b/BitkitTests/TrezorViewModelWatcherTests.swift
@@ -520,4 +520,40 @@ final class TrezorViewModelWatcherTests: XCTestCase {
         XCTAssertTrue(service.snapshotStartedParams().isEmpty)
         XCTAssertNil(viewModel.activeWatcherId)
     }
+
+    /// Core 0.7.0 returns a normalized xpub/tpub that prefix detection reads as Legacy, so using the
+    /// fetched key must also select the account type of the path it was read from.
+    @MainActor
+    func testPopulateWatcherFromXpubSelectsTheFetchedKeysAccountType() {
+        let viewModel = makeViewModel(service: MockWatcherService())
+        viewModel.xpub = "tpubFetched"
+        viewModel.publicKeyAccountType = .nativeSegwit
+
+        viewModel.populateWatcherFromXpub()
+
+        XCTAssertEqual(viewModel.watcherExtendedKey, "tpubFetched")
+        XCTAssertEqual(viewModel.onchainAccountTypeSelection, .nativeSegwit)
+    }
+
+    @MainActor
+    func testPopulateWatcherFromXpubKeepsTheSelectionForAnUnknownPath() {
+        let viewModel = makeViewModel(service: MockWatcherService())
+        viewModel.onchainAccountTypeSelection = .taproot
+        viewModel.xpub = "xpubFetched"
+        viewModel.publicKeyAccountType = nil
+
+        viewModel.populateWatcherFromXpub()
+
+        XCTAssertEqual(viewModel.watcherExtendedKey, "xpubFetched")
+        XCTAssertEqual(viewModel.onchainAccountTypeSelection, .taproot)
+    }
+
+    func testAccountTypeSelectionFollowsThePathPurpose() {
+        XCTAssertEqual(TrezorAccountTypeSelection.matching(derivationPath: "m/44'/0'/0'"), .legacy)
+        XCTAssertEqual(TrezorAccountTypeSelection.matching(derivationPath: "m/49'/1'/0'"), .wrappedSegwit)
+        XCTAssertEqual(TrezorAccountTypeSelection.matching(derivationPath: "m/84'/1'/0'"), .nativeSegwit)
+        XCTAssertEqual(TrezorAccountTypeSelection.matching(derivationPath: "m/86h/0h/0h"), .taproot)
+        XCTAssertNil(TrezorAccountTypeSelection.matching(derivationPath: "m/45'/0'/0'"))
+        XCTAssertNil(TrezorAccountTypeSelection.matching(derivationPath: "84'/0'/0'"))
+    }
 }
diff --git a/Docs/USDT.md b/Docs/USDT.md
index 0d17c00c7..3d4e65b10 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -1,5 +1,7 @@
 # USDT configuration
 
+Normal builds use published bitkit-core `0.8.0-rc1`, including its matching native libraries and generated bindings.
+
 USDT uses Arbitrum One regardless of the Bitcoin network setting. `USDT_RPC_URL` and `USDT_BUNDLER_URL` must point to the controlled service's credential-free HTTPS chain and bundler routes. Info.plist/build settings provide release configuration; local runs can supply process environment overrides. Missing endpoints hide the wallet entry.
 
 Optional `USDT_DEPOSITS_URL` enables wallet-signed Orchestra deposits. Provider keys remain on the service. Source support covers Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain, subject to explicit service enablement and live route availability. Each source requires funded acceptance before release. Users approve a source-network refund address when requesting an eligible refund; unconverted Tron refunds require provider support. History and addresses recover under the same provider partner account. Linked order amounts are batch totals. Outbound USDT0 destinations are enabled with `USDT_BRIDGE_NETWORKS`, a comma-separated subset of `ethereum,polygon,plasma,stable`, matching the service configuration. Empty configuration offers Arbitrum only. Paykit always uses direct Arbitrum payments.
@@ -14,7 +16,7 @@ History catch-up is deferred while the USDT send sheet is open. Balance and pend
 
 ## Paykit
 
-Paykit uses the released rc63 SDK and a direct Arbitrum USDT0 endpoint (`usdt-arbitrum-address`). Existing public/private sharing settings control publication. The payload binds the address, chain 42161 and pinned token; bridge routes are excluded from Paykit choices.
+Paykit uses the rc66 SDK and a direct Arbitrum USDT0 endpoint (`usdt-arbitrum-address`). Existing public/private sharing settings control publication. The payload binds the address, chain 42161 and pinned token; bridge routes are excluded from Paykit choices.
 
 Bitkit creates BTC or USD requests and also reads USDT-denominated requests from other wallets. The accepted methods are immutable request terms. Every accepted cross-asset currency has an explicit requester-supplied rate; the denominating asset needs no conversion. USD/USDT is exactly 1:1. Bitcoin rates come from the existing BTC/USD source when issuing terms, not when verifying received funds. External requests without rates allow only same-asset payment. A listed method without its required rate cannot be used.
 

From 22f449ca2af7b64552acff4c165bbc3504c977bb Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 6 Oct 2026 22:41:25 -0500
Subject: [PATCH 03/62] chore: rename changelog fragment

---
 changelog.d/next/{usdt.added.md => 884.added.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename changelog.d/next/{usdt.added.md => 884.added.md} (100%)

diff --git a/changelog.d/next/usdt.added.md b/changelog.d/next/884.added.md
similarity index 100%
rename from changelog.d/next/usdt.added.md
rename to changelog.d/next/884.added.md

From cc5edea0256271ee06ef471424728e54b48ce9a7 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 6 Oct 2026 23:27:27 -0500
Subject: [PATCH 04/62] feat: add usdt bridge support actions

---
 .../Localization/en.lproj/Localizable.strings |  3 +
 Bitkit/Views/Wallets/UsdtActivityDetail.swift |  4 ++
 .../Wallets/UsdtDepositHistoryView.swift      |  1 +
 Bitkit/Views/Wallets/UsdtSupportActions.swift | 60 +++++++++++++++++++
 BitkitTests/BackupServiceTests.swift          | 17 +++---
 BitkitTests/UsdtSupportDetailsTests.swift     | 45 ++++++++++++++
 journeys/usdt-bridge-support.xml              | 12 ++++
 7 files changed, 133 insertions(+), 9 deletions(-)
 create mode 100644 Bitkit/Views/Wallets/UsdtSupportActions.swift
 create mode 100644 BitkitTests/UsdtSupportDetailsTests.swift
 create mode 100644 journeys/usdt-bridge-support.xml

diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 1a4d3cdde..125a3d2b0 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1920,3 +1920,6 @@
 "usdt__bridge_refunded_description" = "USDT was returned to your wallet. See details for the refunded amount.";
 "usdt__destination_tx" = "Destination transaction";
 "usdt__refund_tx" = "Refund transaction";
+
+"usdt__bridge_reference" = "Bridge reference";
+"usdt__copy_details" = "Copy Details";
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index 4fe496f6c..c563d4c45 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -106,6 +106,7 @@ struct UsdtActivityDetail: View {
                         }
                         if let bridge = transfer.orchestra {
                             SendSectionView(t("usdt__bridge_provider")) { BodySSBText("Orchestra") }
+                            SendSectionView(t("usdt__bridge_reference")) { BodySText(bridge.quoteId).textSelection(.enabled) }
                             if let hash = bridge.destinationTx {
                                 SendSectionView(t("usdt__destination_tx")) { BodySText(hash).textSelection(.enabled) }
                             }
@@ -125,6 +126,9 @@ struct UsdtActivityDetail: View {
                                 CustomButton(title: t("wallet__activity_explore"), variant: .secondary, shouldExpand: true) { openURL(url) }
                             }
                         }
+                        if transfer.destination != .arbitrum {
+                            UsdtSupportActions(details: transfer.supportDetails)
+                        }
                     }
                     .bottomSafeAreaPadding()
                 }
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index adb0c547a..1040ab1e4 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -141,6 +141,7 @@ struct UsdtDepositHistoryView: View {
                              isDisabled: busy || refundAddress.isEmpty, isLoading: busy) { if !busy { confirmRefund = true } }
                     .accessibilityIdentifier("UsdtDepositRefund")
             }
+            UsdtSupportActions(details: detail.supportDetails).disabled(busy || recoveryActive)
         }
     }
 
diff --git a/Bitkit/Views/Wallets/UsdtSupportActions.swift b/Bitkit/Views/Wallets/UsdtSupportActions.swift
new file mode 100644
index 000000000..b8fe2aefb
--- /dev/null
+++ b/Bitkit/Views/Wallets/UsdtSupportActions.swift
@@ -0,0 +1,60 @@
+import BitkitCore
+import SwiftUI
+
+struct UsdtSupportActions: View {
+    let details: String
+    @EnvironmentObject private var app: AppViewModel
+    @EnvironmentObject private var navigation: NavigationViewModel
+    @EnvironmentObject private var sheets: SheetViewModel
+
+    var body: some View {
+        VStack(spacing: 16) {
+            CustomButton(title: t("wallet__send_error_support"), variant: .secondary) {
+                sheets.hideSheet()
+                navigation.navigate(.reportIssue(ReportIssuePrefill(message: details)))
+            }
+            .accessibilityIdentifier("UsdtContactSupport")
+            CustomButton(title: t("usdt__copy_details"), variant: .secondary) {
+                UIPasteboard.general.string = details
+                app.toast(type: .success, title: t("common__copied"))
+            }
+            .accessibilityIdentifier("UsdtCopyDetails")
+        }
+    }
+}
+
+extension UsdtTransfer {
+    @MainActor var supportDetails: String {
+        var lines = [
+            "Asset: USDT",
+            "Bridge: \(orchestra == nil ? "USDT0" : "Orchestra")",
+            "Source network: Arbitrum One",
+            "Recipient network: \(destination.label)",
+            "Status: \(status)",
+        ]
+        if let reference = orchestra?.quoteId { lines.append("Bridge reference: \(reference)") }
+        if let txHash { lines.append("Source transaction: \(txHash)") }
+        if let bridgeGuid { lines.append("LayerZero message: \(bridgeGuid)") }
+        if let hash = orchestra?.destinationTx { lines.append("Destination transaction: \(hash)") }
+        if let hash = orchestra?.refundTx { lines.append("Refund transaction: \(hash)") }
+        return lines.joined(separator: "\n")
+    }
+}
+
+extension UsdtDepositDetail {
+    var supportDetails: String {
+        var lines = [
+            "Asset: \(deposit.asset)",
+            "Bridge: Orchestra",
+            "Source network: \(deposit.network)",
+            "Recipient network: Arbitrum One",
+            "Deposit reference: \(deposit.id)",
+            "Status: \(order?.status ?? deposit.status)",
+            "Source transaction: \(deposit.sourceTx)",
+        ]
+        if let statusCode { lines.append("Status code: \(statusCode)") }
+        if let hash = order?.destinationTx { lines.append("Destination transaction: \(hash)") }
+        if let hash = order?.refundTx ?? deposit.refundTx { lines.append("Refund transaction: \(hash)") }
+        return lines.joined(separator: "\n")
+    }
+}
diff --git a/BitkitTests/BackupServiceTests.swift b/BitkitTests/BackupServiceTests.swift
index 1f1110f71..aa6fb9b16 100644
--- a/BitkitTests/BackupServiceTests.swift
+++ b/BitkitTests/BackupServiceTests.swift
@@ -1,4 +1,5 @@
 @testable import Bitkit
+import Combine
 import Paykit
 import XCTest
 
@@ -8,7 +9,7 @@ final class BackupServiceTests: XCTestCase {
         let suite = "BackupServiceTests.\(UUID().uuidString)"
         let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
         defer { defaults.removePersistentDomain(forName: suite) }
-        let exportStarted = expectation(description: "Wallet export requested")
+        let backupStarted = expectation(description: "Wallet backup waiting for payment")
         let cancelledBackupFinished = expectation(description: "Cancelled wallet backup finished")
         let recorder = BackupRecorder()
         let sdk = WalletBackupSdk(noPointer: .init())
@@ -18,18 +19,22 @@ final class BackupServiceTests: XCTestCase {
             defaults: defaults,
             backupData: { category in
                 XCTAssertEqual(category, .wallet)
-                if await recorder.startExport() == 1 { exportStarted.fulfill() }
                 return try await Data(paykit.exportBackupState().utf8)
             },
             uploadBackup: { key, data in await recorder.recordUpload(key: key, data: data) }
         )
+        let statusSubscription = service.backupStatusesPublisher
+            .filter { $0[.wallet]?.running == true }
+            .first()
+            .sink { _ in backupStarted.fulfill() }
+        defer { statusSubscription.cancel() }
         let payment = PaykitPaymentActivity.shared.begin()
         defer { PaykitPaymentActivity.shared.end(payment) }
         let backup = Task {
             await service.triggerBackup(category: .wallet)
             cancelledBackupFinished.fulfill()
         }
-        await fulfillment(of: [exportStarted], timeout: 2)
+        await fulfillment(of: [backupStarted], timeout: 2)
         let running = service.getBackupStatus(category: .wallet)
         XCTAssertTrue(running.running)
         XCTAssertTrue(running.isRequired)
@@ -63,15 +68,9 @@ final class BackupServiceTests: XCTestCase {
 }
 
 private actor BackupRecorder {
-    private var attempts = 0
     private(set) var exports = 0
     private(set) var uploads: [(key: String, data: Data)] = []
 
-    func startExport() -> Int {
-        attempts += 1
-        return attempts
-    }
-
     func recordExport() {
         exports += 1
     }
diff --git a/BitkitTests/UsdtSupportDetailsTests.swift b/BitkitTests/UsdtSupportDetailsTests.swift
new file mode 100644
index 000000000..5767be457
--- /dev/null
+++ b/BitkitTests/UsdtSupportDetailsTests.swift
@@ -0,0 +1,45 @@
+@testable import Bitkit
+import BitkitCore
+import XCTest
+
+@MainActor
+final class UsdtSupportDetailsTests: XCTestCase {
+    func testTransferSupportIncludesProviderReferencesAndTransactions() {
+        var transfer = UsdtTransfer(
+            id: "local-id", txHash: "source-tx", userOperationHash: nil, bridgeGuid: "message-id", orchestra: nil,
+            recipient: "recipient-address", destination: .polygon, amount: 100, receivedAmount: 90,
+            fee: 10, isIncoming: false, status: .bridgeNeedsAttention, timestamp: 1
+        )
+        XCTAssertTrue(transfer.supportDetails.contains("Bridge: USDT0"))
+        XCTAssertTrue(transfer.supportDetails.contains("LayerZero message: message-id"))
+        XCTAssertFalse(transfer.supportDetails.contains("Destination transaction:"))
+
+        transfer.bridgeGuid = nil
+        transfer.orchestra = UsdtOrchestraTransfer(
+            quoteId: "order-id", fundingAddress: "funding-address", destinationTx: "destination-tx",
+            refundTx: "refund-tx", refundAmount: 90
+        )
+        let details = transfer.supportDetails
+        for value in ["Orchestra", "Arbitrum One", "Polygon", "order-id", "source-tx", "destination-tx", "refund-tx"] {
+            XCTAssertTrue(details.contains(value), value)
+        }
+        XCTAssertFalse(details.contains("recipient-address"))
+        XCTAssertFalse(details.contains("funding-address"))
+    }
+
+    func testDepositSupportUsesCurrentOrderStatusAndRefund() {
+        let deposit = UsdtDeposit(id: "deposit-id", network: "tron", asset: "USDT", amount: 100, sourceTx: "source-tx",
+                                  status: "held", code: "old-code", refundTx: "deposit-refund")
+        var detail = UsdtDepositDetail(deposit: deposit, order: nil)
+        XCTAssertTrue(detail.supportDetails.contains("Status code: old-code"))
+        XCTAssertTrue(detail.supportDetails.contains("Refund transaction: deposit-refund"))
+        detail.order = UsdtDepositOrder(status: "refunded", amountIn: 100, amountOut: nil,
+                                        destinationTx: nil, refundTx: "order-refund", code: nil)
+        let details = detail.supportDetails
+        for value in ["Orchestra", "tron", "Arbitrum One", "deposit-id", "source-tx", "refunded", "order-refund"] {
+            XCTAssertTrue(details.contains(value), value)
+        }
+        XCTAssertFalse(details.contains("old-code"))
+        XCTAssertFalse(details.contains("deposit-refund"))
+    }
+}
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
new file mode 100644
index 000000000..81167be69
--- /dev/null
+++ b/journeys/usdt-bridge-support.xml
@@ -0,0 +1,12 @@
+<journey name="usdt bridge support">
+  <description>Use an onboarded wallet with an outbound cross-network transfer and an Orchestra deposit in its history. Existing history or a provider fixture is sufficient; do not submit a payment or support request.</description>
+  <actions>
+    <action>Open USDT from Home, then open a cross-network transfer in Activity.</action>
+    <action>Verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed.</action>
+    <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
+    <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting.</action>
+    <action>Open USDT Receive and Cross-network Deposits, then open a deposit.</action>
+    <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard includes the deposit reference, source network and source transaction, plus the current status and any destination or refund transaction.</action>
+    <action>Tap Contact Support (id "UsdtContactSupport"). Verify the receive sheet closes and the report form opens with the deposit details prefilled. Return without submitting or requesting a refund.</action>
+  </actions>
+</journey>

From 32f5eb3c447d505e579b6176eefd479b5d91602f Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 7 Oct 2026 10:19:03 -0500
Subject: [PATCH 05/62] Make USDT sharing optional in companion authorization

---
 Bitkit/Models/PubkyAuthRequest.swift          | 38 ++++++++++-------
 .../Localization/en.lproj/Localizable.strings |  6 ++-
 Bitkit/Services/PubkyService.swift            |  4 +-
 .../PubkyAuthApprovalSheet.swift              | 36 ++++++++--------
 BitkitTests/PubkyAuthApprovalSheetTests.swift | 25 ++++++++++-
 Docs/earn-receiving-details.md                | 42 +++++++------------
 changelog.d/next/884.added.md                 |  2 +-
 .../pubky-auth/share-receiving-details.xml    |  7 +++-
 8 files changed, 93 insertions(+), 67 deletions(-)

diff --git a/Bitkit/Models/PubkyAuthRequest.swift b/Bitkit/Models/PubkyAuthRequest.swift
index 7ea45e683..77cf81f49 100644
--- a/Bitkit/Models/PubkyAuthRequest.swift
+++ b/Bitkit/Models/PubkyAuthRequest.swift
@@ -7,13 +7,12 @@ struct PubkyAuthClaim: Equatable {
         case paykitAccessV1 = "paykit-access-v1"
         case watchOnlyAccountV1 = "watch-only-account-v1"
         case usdtAddressV1 = "usdt-address-v1"
-        case paymentDetailsV1 = "payment-details-v1"
     }
 
     static let watchOnlyAccountV1 = Self(items: [.watchOnlyAccountV1])
     static let paykitAccessV1 = Self(items: [.paykitAccessV1])
     static let usdtAddressV1 = Self(items: [.usdtAddressV1])
-    static let paymentDetailsV1 = Self(items: [.paymentDetailsV1])
+    static let bitcoinAndUsdt = Self(items: [.watchOnlyAccountV1, .usdtAddressV1])
 
     private let items: [Item]
 
@@ -25,7 +24,6 @@ struct PubkyAuthClaim: Equatable {
         let values = rawValue.split(separator: ".", omittingEmptySubsequences: false)
         let items = values.compactMap { Item(rawValue: String($0)) }
         guard !items.isEmpty, items.count == values.count, Set(items).count == items.count else { return nil }
-        guard items.count == 1 || !items.contains(where: { $0 == .usdtAddressV1 || $0 == .paymentDetailsV1 }) else { return nil }
         self.items = items
     }
 
@@ -38,7 +36,7 @@ struct PubkyAuthClaim: Equatable {
     static let requiredCapabilities = Paykit.requiredSessionCapabilities()
 
     var includesWatchOnlyAccount: Bool {
-        items.contains(.watchOnlyAccountV1) || items.contains(.paymentDetailsV1)
+        items.contains(.watchOnlyAccountV1)
     }
 
     var includesPaykitAccess: Bool {
@@ -50,7 +48,7 @@ struct PubkyAuthClaim: Equatable {
     }
 
     var sharesUsdt: Bool {
-        items.contains(.usdtAddressV1) || items.contains(.paymentDetailsV1)
+        items.contains(.usdtAddressV1)
     }
 
     var sharesReceivingDetails: Bool {
@@ -61,13 +59,13 @@ struct PubkyAuthClaim: Equatable {
         guard sharesUsdt else {
             return try account.map { try WatchOnlyAccountClaimCodec.encode(record: $0) }
         }
-        guard let usdtEndpoint, usdtEndpoint.methodId == .usdtArbitrum,
-              PaykitUsdt.address(from: usdtEndpoint.rawPayload) == usdtEndpoint.value
-        else { throw PubkyAuthRequestError.invalidPaymentDetails }
-        var payload: [String: Any] = try [
-            PublicPaykitService.MethodId.usdtArbitrum.rawValue:
-                JSONSerialization.jsonObject(with: Data(usdtEndpoint.rawPayload.utf8)),
-        ]
+        var payload: [String: Any] = [:]
+        if let usdtEndpoint {
+            guard usdtEndpoint.methodId == .usdtArbitrum,
+                  PaykitUsdt.address(from: usdtEndpoint.rawPayload) == usdtEndpoint.value
+            else { throw PubkyAuthRequestError.invalidPaymentDetails }
+            payload[PublicPaykitService.MethodId.usdtArbitrum.rawValue] = try JSONSerialization.jsonObject(with: Data(usdtEndpoint.rawPayload.utf8))
+        }
         if sharesBitcoin {
             guard let account else { throw PubkyAuthRequestError.invalidPaymentDetails }
             _ = try WatchOnlyAccountClaimCodec.encode(record: account)
@@ -78,8 +76,20 @@ struct PubkyAuthClaim: Equatable {
 
     func encode(accountPayload: Data?, paykitKey: PaykitIdentitySecretKey?) throws -> Data {
         if sharesUsdt {
-            guard let accountPayload, !includesPaykitAccess else { throw PubkyAuthRequestError.invalidPaymentDetails }
-            return accountPayload
+            guard let accountPayload,
+                  var payload = try JSONSerialization.jsonObject(with: accountPayload) as? [String: Any],
+                  includesPaykitAccess == (paykitKey != nil)
+            else { throw PubkyAuthRequestError.invalidPaymentDetails }
+            if let paykitKey {
+                payload["paykit_access"] = [
+                    "key_generation": paykitKey.keyGeneration(),
+                    "secret": paykitKey.exportBytes().base64EncodedString()
+                        .replacingOccurrences(of: "+", with: "-")
+                        .replacingOccurrences(of: "/", with: "_")
+                        .replacingOccurrences(of: "=", with: ""),
+                ]
+            }
+            return try JSONSerialization.data(withJSONObject: payload, options: [.sortedKeys])
         }
         guard includesWatchOnlyAccount == (accountPayload != nil),
               includesPaykitAccess == (paykitKey != nil)
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 125a3d2b0..2a945ff46 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1899,11 +1899,11 @@
 "pubky_auth__bitcoin_account" = "Separate watch-only account · xpub";
 "pubky_auth__payment_details" = "PAYMENT DETAILS TO SHARE";
 "pubky_auth__payment_details_intro_title" = "<accent>EARN BITCOIN\nAND USDT</accent>\nFROM YOUR CONTENT";
-"pubky_auth__payment_details_intro_description" = "Share a separate Bitcoin account and your existing USDT address to receive earnings. Sharing these details does not let the service spend your funds.";
+"pubky_auth__payment_details_intro_description" = "Share a separate Bitcoin account to receive earnings. You can also share your existing USDT address. Sharing these details does not let the service spend your funds.";
 "pubky_auth__usdt_intro_title" = "<accent>EARN USDT</accent>\nFROM YOUR\nCONTENT";
 "pubky_auth__usdt_intro_description" = "Share your existing USDT address on Arbitrum One to receive earnings directly in Bitkit. The service cannot spend your funds.";
 "pubky_auth__usdt_privacy" = "This is your existing USDT account. The service can see its balance and transaction history, but cannot spend your funds.";
-"pubky_auth__usdt_unavailable" = "Your USDT address is unavailable. Try again before authorizing.";
+"pubky_auth__usdt_unavailable" = "Your USDT address is unavailable. You can retry or continue without sharing it.";
 "pubky_auth__shared_usdt" = "Your USDT receiving address was shared.";
 "pubky_auth__shared_bitcoin" = "Your Bitcoin watch-only account was shared.";
 "pubky_auth__shared_both" = "Your Bitcoin watch-only account and USDT receiving address were shared.";
@@ -1923,3 +1923,5 @@
 
 "usdt__bridge_reference" = "Bridge reference";
 "usdt__copy_details" = "Copy Details";
+
+"pubky_auth__share_usdt_optional" = "Share USDT address (optional)";
diff --git a/Bitkit/Services/PubkyService.swift b/Bitkit/Services/PubkyService.swift
index a037a7753..8eb01f7aa 100644
--- a/Bitkit/Services/PubkyService.swift
+++ b/Bitkit/Services/PubkyService.swift
@@ -194,8 +194,8 @@ enum PubkyService {
     ) async throws {
         guard authUrl == request.rawUrl else { throw PubkyServiceError.invalidAuthUrl }
         let endpoint: PublicPaykitService.Endpoint?
-        if request.bitkitClaim?.sharesUsdt == true {
-            guard let usdtEndpoint, let approvedUsdtAddress else { throw PubkyAuthRequestError.invalidPaymentDetails }
+        if request.bitkitClaim?.sharesUsdt == true, let approvedUsdtAddress {
+            guard let usdtEndpoint else { throw PubkyAuthRequestError.invalidPaymentDetails }
             endpoint = try await usdtEndpoint()
             guard endpoint?.value == approvedUsdtAddress else { throw PubkyAuthRequestError.invalidPaymentDetails }
         } else { endpoint = nil }
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index 115e72c8c..2eda23a1e 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -82,6 +82,7 @@ struct PubkyAuthApprovalSheet: View {
     @State private var usdtAddress: String?
     @State private var usdtUnavailable = false
     @State private var showsUsdtAddress = false
+    @State private var shareUsdt = true
 
     private var createsIdentity: Bool {
         Self.requiresIdentityCreation(for: config.request, profile: pubkyProfile)
@@ -222,7 +223,7 @@ struct PubkyAuthApprovalSheet: View {
                 CustomButton(title: t("pubky_auth__title")) {
                     await onAuthorize()
                 }
-                .disabled(config.request.bitkitClaim?.sharesUsdt == true && usdtAddress == nil)
+                .disabled(config.request.bitkitClaim?.sharesUsdt == true && shareUsdt && usdtAddress == nil)
                 .accessibilityIdentifier("PubkyAuthAuthorize")
             }
         }
@@ -250,7 +251,7 @@ struct PubkyAuthApprovalSheet: View {
                         successDescriptionText
                             .padding(.horizontal, 16)
                             .padding(.bottom, 16)
-                        if config.request.bitkitClaim?.sharesReceivingDetails == true {
+                        if config.request.bitkitClaim?.sharesBitcoin == true || (shareUsdt && usdtAddress != nil) {
                             BodyMText(t(sharingSuccessKey))
                                 .accessibilityIdentifier("PubkyAuthSharedDetails")
                                 .padding(.horizontal, 16)
@@ -368,27 +369,20 @@ struct PubkyAuthApprovalSheet: View {
     }
 
     private var introTitleKey: String {
-        switch config.request.bitkitClaim {
-        case .usdtAddressV1: "pubky_auth__usdt_intro_title"
-        case .paymentDetailsV1: "pubky_auth__payment_details_intro_title"
-        default: "pubky_auth__watch_only_intro_title"
-        }
+        guard config.request.bitkitClaim?.sharesUsdt == true else { return "pubky_auth__watch_only_intro_title" }
+        return config.request.bitkitClaim?.sharesBitcoin == true ? "pubky_auth__payment_details_intro_title" : "pubky_auth__usdt_intro_title"
     }
 
     private var introDescriptionKey: String {
-        switch config.request.bitkitClaim {
-        case .usdtAddressV1: "pubky_auth__usdt_intro_description"
-        case .paymentDetailsV1: "pubky_auth__payment_details_intro_description"
-        default: "pubky_auth__watch_only_intro_description"
-        }
+        guard config.request.bitkitClaim?.sharesUsdt == true else { return "pubky_auth__watch_only_intro_description" }
+        return config.request.bitkitClaim?.sharesBitcoin == true ? "pubky_auth__payment_details_intro_description" : "pubky_auth__usdt_intro_description"
     }
 
     private var sharingSuccessKey: String {
-        switch config.request.bitkitClaim {
-        case .usdtAddressV1: "pubky_auth__shared_usdt"
-        case .paymentDetailsV1: "pubky_auth__shared_both"
-        default: "pubky_auth__shared_bitcoin"
+        if shareUsdt, usdtAddress != nil, config.request.bitkitClaim?.sharesUsdt == true {
+            return config.request.bitkitClaim?.sharesBitcoin == true ? "pubky_auth__shared_both" : "pubky_auth__shared_usdt"
         }
+        return "pubky_auth__shared_bitcoin"
     }
 
     private var paymentDetailsSection: some View {
@@ -403,7 +397,12 @@ struct PubkyAuthApprovalSheet: View {
             }
             if config.request.bitkitClaim?.sharesUsdt == true {
                 VStack(alignment: .leading, spacing: 8) {
-                    BodySSBText("USDT · Arbitrum One", textColor: .greenAccent)
+                    Toggle(isOn: $shareUsdt) {
+                        BodySSBText(t("pubky_auth__share_usdt_optional"), textColor: .greenAccent)
+                    }
+                    .tint(.greenAccent)
+                    .disabled(state == .authorizing)
+                    .accessibilityIdentifier("PubkyAuthShareUsdt")
                     if let usdtAddress {
                         Button { showsUsdtAddress.toggle() } label: {
                             BodySText(showsUsdtAddress ? usdtAddress : String(usdtAddress.prefix(8)) + "…" + String(usdtAddress.suffix(6)))
@@ -440,6 +439,7 @@ struct PubkyAuthApprovalSheet: View {
         } catch {
             usdtAddress = nil
             usdtUnavailable = true
+            shareUsdt = false
         }
     }
 
@@ -610,7 +610,7 @@ struct PubkyAuthApprovalSheet: View {
                 authUrl: config.request.rawUrl,
                 accountName: watchOnlyAccountName,
                 secretKeyHex: secretKey,
-                approvedUsdtAddress: usdtAddress,
+                approvedUsdtAddress: shareUsdt ? usdtAddress : nil,
                 usdtEndpoint: { try await usdt.paymentEndpoint() }
             )
 
diff --git a/BitkitTests/PubkyAuthApprovalSheetTests.swift b/BitkitTests/PubkyAuthApprovalSheetTests.swift
index 4279e7009..936aacca0 100644
--- a/BitkitTests/PubkyAuthApprovalSheetTests.swift
+++ b/BitkitTests/PubkyAuthApprovalSheetTests.swift
@@ -49,7 +49,7 @@ final class PubkyAuthApprovalSheetTests: XCTestCase {
     @MainActor
     func testReceivingDetailsShareExactlyTheRequestedAssets() async throws {
         let endpoint = try PaykitUsdt.endpoint(address: "0x1111111111111111111111111111111111111111")
-        for claim in [PubkyAuthClaim.usdtAddressV1, .paymentDetailsV1] {
+        for claim in [PubkyAuthClaim.usdtAddressV1, .bitcoinAndUsdt] {
             let defaults = try XCTUnwrap(UserDefaults(suiteName: "EarnSharing.\(UUID().uuidString)"))
             let manager = Bitkit.WatchOnlyAccountManager(defaults: defaults, node: ApprovalFakeWatchOnlyAccountNode())
             let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: claim.rawValue)
@@ -84,7 +84,7 @@ final class PubkyAuthApprovalSheetTests: XCTestCase {
         let endpoint = try PaykitUsdt.endpoint(address: "0x1111111111111111111111111111111111111111")
         let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: "usdt-address-v1")
         let request = try PubkyAuthRequest.parse(url: url)
-        for approvedAddress in [nil, "0x2222222222222222222222222222222222222222"] as [String?] {
+        for approvedAddress in ["0x2222222222222222222222222222222222222222"] {
             do {
                 try await PubkyService.approveAuthRequest(
                     request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret",
@@ -98,6 +98,27 @@ final class PubkyAuthApprovalSheetTests: XCTestCase {
         }
     }
 
+    @MainActor
+    func testOptionalUsdtCanBeDeclinedWithoutLoadingAnAddress() async throws {
+        let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: "paykit-access-v1.usdt-address-v1")
+        let request = try PubkyAuthRequest.parse(url: url)
+        var shared: Data?
+        try await PubkyService.approveAuthRequest(
+            request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret",
+            approvedUsdtAddress: nil,
+            usdtEndpoint: { XCTFail("Declined permission must not read the wallet"); throw PubkyAuthRequestError.invalidPaymentDetails },
+            companionApproval: { _, _, _, payload, _ in shared = payload }
+        )
+        let claim = try XCTUnwrap(request.bitkitClaim)
+        let key = try PaykitIdentitySecretKey(bytes: Data(repeating: 11, count: 32), keyGeneration: 3)
+        let encoded = try claim.encode(accountPayload: shared, paykitKey: key)
+        let json = try XCTUnwrap(JSONSerialization.jsonObject(with: encoded) as? [String: Any])
+        XCTAssertEqual(Set(json.keys), ["paykit_access"])
+        let access = try XCTUnwrap(json["paykit_access"] as? [String: Any])
+        XCTAssertEqual(access["key_generation"] as? UInt64, 3)
+        XCTAssertEqual(access["secret"] as? String, "CwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCws")
+    }
+
     func testAuthDisplayPublicKeyOmitsPubkyPrefix() {
         XCTAssertEqual(pubkyAuthDisplayPublicKey("pubky3rsd123456789w5xg"), "3rsd...w5xg")
         XCTAssertEqual(pubkyAuthDisplayPublicKey("3rsd123456789w5xg"), "3rsd...w5xg")
diff --git a/Docs/earn-receiving-details.md b/Docs/earn-receiving-details.md
index 9e6030983..d404417e3 100644
--- a/Docs/earn-receiving-details.md
+++ b/Docs/earn-receiving-details.md
@@ -1,39 +1,29 @@
 # Earn receiving-details claims
 
-Bitkit lets an Earn service request a Bitcoin watch-only account, the existing USDT address on Arbitrum One, or both through the existing Pubky Auth approval flow. This contract covers address sharing, not USDT invoicing, payment verification or purchase delivery.
+Earn services request receiving details through Pubky Auth. USDT sharing is optional and uses the existing Arbitrum One account; it creates no account, enables no public-sharing setting, and grants no spending authority. Services see that address's public balance and history.
 
-## Request and approval
+Use exactly one `x-bitkit-claim` parameter containing a dot-separated list of independent permissions:
 
-Use exactly one `x-bitkit-claim` query parameter:
-
-| Claim | Shared details |
+| Permission | Shared authority/details |
 | --- | --- |
-| `watch-only-account-v1` | A separate native-SegWit Bitcoin account, using the existing 84-byte payload |
-| `usdt-address-v1` | The existing USDT Arbitrum receiving endpoint |
-| `payment-details-v1` | Both that endpoint and a separate Bitcoin account |
-
-All three require exactly `/pub/paykit/:rw`. Unknown or repeated claim parameters and mismatched capabilities are rejected. Changing the claim changes the request identity and companion channel.
-
-The user first sees the existing Earn introduction, then the authorization review showing the requested assets. The USDT address is expandable and copyable. Approval is unavailable until the address can be read, and Bitkit re-reads it before sending to ensure it is the address reviewed. Canceling before authorization shares nothing and allocates no Bitcoin account.
-
-USDT sharing creates no account, changes no public-sharing preference and gives no permission to spend. The receiver can observe the account's public balance and transaction history. Different services receive the same USDT address. Bitcoin sharing retains its separate account allocation and tracked retry/recovery lifecycle.
-
-## Payload
-
-For `usdt-address-v1`, the unsigned payload is a UTF-8 JSON object with exactly the `usdt-arbitrum-address` key. Its endpoint contains string fields `value` (the EVM address), `chain_id` (`42161`) and `token` (`0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9`).
+| `watch-only-account-v1` | Separate native-SegWit Bitcoin account |
+| `paykit-access-v1` | Generation-bound Paykit identity secret, never a wallet spending key |
+| `usdt-address-v1` | Existing USDT0 Arbitrum One address, if approved |
 
-For `payment-details-v1`, the unsigned JSON additionally contains `bitcoin_account`, with `account_index` (an unsigned integer), `address_type` (`nativeSegwit`) and `xpub` (Base58Check text). Wallet-local names and identifiers are not shared. The xpub's version identifies its Bitcoin network; the server must check it against its configured network.
+For example, `paykit-access-v1.watch-only-account-v1.usdt-address-v1` requests all three. Preserve the exact received order for signature and channel derivation. Unknown, duplicate or empty items are rejected. Requests require `/pub/paykit/:rw`.
 
-JSON key order is not significant. Verify the signature over the received bytes before decoding; do not reconstruct or reserialize the object for verification. The existing `watch-only-account-v1` binary format is unchanged.
+The existing Earn introduction leads to authorization review. USDT has an optional sharing toggle and expandable/copyable address. If loading fails, the user may retry or authorize without USDT. When selected, Bitkit re-reads the address and checks it matches the reviewed address. Canceling before authorization shares nothing. Bitcoin retains its separate account allocation and retry/recovery lifecycle.
 
-## Signed delivery
+## Payload and authentication
 
-Use Paykit's companion-claim approval API with the exact selected claim name. The signature input is UTF-8 `x-bitkit-claim|<claim>|`, followed by SHA256 of the decoded 32-byte auth request secret, followed by the unsigned payload bytes. Paykit appends the 64-byte Ed25519 signature and encrypts the signed payload using the existing XSalsa20-Poly1305 envelope.
+Selections containing USDT use a UTF-8 JSON object. Include only requested and approved fields:
 
-The companion channel is base64url-no-pad of BLAKE3 over UTF-8 `<claim>|` followed by the decoded request secret. The normal AuthToken channel is unchanged. Claim delivery precedes normal auth approval. The signature is verified against the creator's authenticated Pubky public key. It binds the receiving details to that identity and request, not to ownership of an EVM private key.
+- `usdt-arbitrum-address`: `{value, chain_id: "42161", token: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9"}`. Omit this field when declined.
+- `bitcoin_account`: `{account_index, address_type: "nativeSegwit", xpub}` when Bitcoin is requested. No wallet-local names or IDs.
+- `paykit_access`: `{key_generation, secret}` when Paykit access is requested. The generation is an exact nonzero unsigned 64-bit integer; the 32-byte secret uses unpadded base64url.
 
-## Server integration
+Selections without USDT retain the existing binary layouts: Bitcoin 84 bytes, Paykit 41 bytes, both 124 bytes. Those are independent supported permissions, not USDT compatibility paths.
 
-Paykit Server's current implementation accepts only `watch-only-account-v1`. Supporting the new claim names requires using the requested claim name for channel derivation and signature verification, parsing the appropriate payload after verification, validating the pinned endpoint and optional Bitcoin account, and durably storing the selected receiving details before acknowledging setup. Existing Bitcoin setup and stored credentials must remain readable; neither USDT-only sharing nor combined sharing authorizes deleting them.
+Paykit signs UTF-8 `x-bitkit-claim|<exact-list>|`, SHA256 of the 32-byte AUTH secret, and the unsigned payload. It appends the 64-byte Ed25519 signature and uses its XSalsa20-Poly1305 companion transport. The relay channel is unpadded base64url of BLAKE3 over UTF-8 `<exact-list>|` followed by the AUTH secret. Verify the received bytes before parsing; never reserialize JSON for signature verification.
 
-The server must not treat a shared USDT address as an enabled USDT checkout method. USDT invoice creation and payment verification are separate work. A server should issue these new claim requests only when it can accept and store them. Bitkit should not advertise a completed production Earn integration until that server behavior is available and tested together.
+The Creator's authenticated Pubky key verifies the claim. This binds receiving details to the identity and request, not ownership of the EVM private key. The server validates the pinned chain/token, address and Bitcoin account before persistence, and verifies delegated Paykit authority against the identity-signed Noise key authorization. A matching server can request USDT only when configured to store and verify it. Declining USDT leaves Bitcoin setup usable. Reconnect may add a missing USDT address while preserving existing receiving bindings.
diff --git a/changelog.d/next/884.added.md b/changelog.d/next/884.added.md
index eb1ecfe46..9c01713d0 100644
--- a/changelog.d/next/884.added.md
+++ b/changelog.d/next/884.added.md
@@ -1 +1 @@
-Send and receive USDT with fees paid in USDT, Paykit contact payments and requests, subscriptions, cross-network deposits, Earn address sharing, and encrypted payment recovery backups.
+Send and receive USDT with fees paid in USDT, Paykit contact payments and requests, subscriptions, cross-network deposits, optional Earn address sharing, and encrypted payment recovery backups.
diff --git a/journeys/pubky-auth/share-receiving-details.xml b/journeys/pubky-auth/share-receiving-details.xml
index 8d3d06717..020d32437 100644
--- a/journeys/pubky-auth/share-receiving-details.xml
+++ b/journeys/pubky-auth/share-receiving-details.xml
@@ -6,8 +6,11 @@
     <action>Verify only USDT Arbitrum details, the existing address and balance/history disclosure are shown</action>
     <action>Expand the address and copy it; verify it matches the wallet receive address</action>
     <action>Cancel and verify no Bitcoin account was created</action>
-    <action>Repeat with x-bitkit-claim=payment-details-v1; verify Bitcoin and USDT appear together, then cancel</action>
+    <action>Repeat with x-bitkit-claim=watch-only-account-v1.usdt-address-v1; verify Bitcoin and USDT appear together, then cancel</action>
     <action>Repeat with x-bitkit-claim=watch-only-account-v1; verify only Bitcoin is requested, then cancel</action>
-    <action>With USDT unavailable, verify USDT authorization is disabled and Retry reloads the address</action>
+    <action>With USDT unavailable, verify sharing is off and authorization remains enabled; turn USDT sharing on and verify authorization is disabled until Retry loads the address</action>
+    <action>Open the setup fixture with x-bitkit-claim=paykit-access-v1.watch-only-account-v1.usdt-address-v1</action>
+    <action>Continue to authorization; verify the Bitcoin account, Paykit access, and optional USDT sharing toggle are shown</action>
+    <action>Turn off PubkyAuthShareUsdt; verify authorization remains enabled, then cancel</action>
   </actions>
 </journey>

From e70c29361ae2b2a0690b2d7209091a10ad953355 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 7 Oct 2026 16:59:42 -0500
Subject: [PATCH 06/62] feat: apply usdt wallet designs

---
 .../tether-circle.imageset/Contents.json      |  12 +
 .../tether-circle.imageset/tether-circle.png  | Bin 0 -> 2497 bytes
 .../tether-coin.imageset/Contents.json        |  12 +
 .../tether-coin.imageset/tether-coin.png      | Bin 0 -> 2257140 bytes
 .../tether.imageset/Contents.json             |  12 +
 .../tether.imageset/tether.png                | Bin 0 -> 2762 bytes
 .../usdt-network.imageset/Contents.json       |  12 +
 .../usdt-network.imageset/usdt-network.png    | Bin 0 -> 872 bytes
 Bitkit/Components/Activity/ActivityList.swift |  55 ++--
 Bitkit/Components/PaykitAmountText.swift      |   4 +-
 Bitkit/Components/SendSectionView.swift       |   6 +-
 Bitkit/MainNavView.swift                      |   5 +-
 .../Localization/en.lproj/Localizable.strings |  17 +-
 Bitkit/Styles/Colors.swift                    |   1 +
 Bitkit/ViewModels/NavigationViewModel.swift   |   1 +
 Bitkit/Views/Home/HomeWalletView.swift        |  14 +-
 .../CreatePaymentRequestView.swift            |   4 +-
 .../PubkyAuthApprovalSheet.swift              |  10 +-
 .../CreateSubscriptionView.swift              |   2 +-
 .../Wallets/Activity/ActivityLatest.swift     |  23 +-
 .../Views/Wallets/Activity/ActivityRow.swift  |  43 +++
 Bitkit/Views/Wallets/Receive/QrArea.swift     |  30 +-
 .../Views/Wallets/Receive/ReceiveEdit.swift   |   2 +-
 Bitkit/Views/Wallets/Receive/ReceiveQr.swift  |  39 ++-
 .../Views/Wallets/Receive/ReceiveSheet.swift  |  12 +-
 .../Views/Wallets/Send/SendAmountView.swift   |   4 +-
 Bitkit/Views/Wallets/Sheets/ReceivedTx.swift  |  16 +-
 Bitkit/Views/Wallets/UsdtActivityDetail.swift |   4 +-
 .../Wallets/UsdtDepositHistoryView.swift      |   4 +-
 .../Views/Wallets/UsdtReceiveAmountView.swift | 107 +++++++
 Bitkit/Views/Wallets/UsdtReceiveView.swift    | 263 +++++++++++-------
 Bitkit/Views/Wallets/UsdtSendView.swift       |  74 ++---
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |  89 ++++--
 BitkitTests/UsdtDisplayTests.swift            |  22 ++
 Docs/USDT-QA.md                               |  15 +-
 journeys/paykit-quoted-usdt.xml               |   4 +-
 journeys/usdt-bridge-support.xml              |   2 +-
 journeys/usdt-receive-amount-and-units.xml    |  13 +
 journeys/usdt-wallet-navigation.xml           |   4 +-
 39 files changed, 646 insertions(+), 291 deletions(-)
 create mode 100644 Bitkit/Assets.xcassets/tether-circle.imageset/Contents.json
 create mode 100644 Bitkit/Assets.xcassets/tether-circle.imageset/tether-circle.png
 create mode 100644 Bitkit/Assets.xcassets/tether-coin.imageset/Contents.json
 create mode 100644 Bitkit/Assets.xcassets/tether-coin.imageset/tether-coin.png
 create mode 100644 Bitkit/Assets.xcassets/tether.imageset/Contents.json
 create mode 100644 Bitkit/Assets.xcassets/tether.imageset/tether.png
 create mode 100644 Bitkit/Assets.xcassets/usdt-network.imageset/Contents.json
 create mode 100644 Bitkit/Assets.xcassets/usdt-network.imageset/usdt-network.png
 create mode 100644 Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
 create mode 100644 BitkitTests/UsdtDisplayTests.swift
 create mode 100644 journeys/usdt-receive-amount-and-units.xml

diff --git a/Bitkit/Assets.xcassets/tether-circle.imageset/Contents.json b/Bitkit/Assets.xcassets/tether-circle.imageset/Contents.json
new file mode 100644
index 000000000..534338105
--- /dev/null
+++ b/Bitkit/Assets.xcassets/tether-circle.imageset/Contents.json
@@ -0,0 +1,12 @@
+{
+  "images": [
+    {
+      "filename": "tether-circle.png",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}
diff --git a/Bitkit/Assets.xcassets/tether-circle.imageset/tether-circle.png b/Bitkit/Assets.xcassets/tether-circle.imageset/tether-circle.png
new file mode 100644
index 0000000000000000000000000000000000000000..b8558cb76772bc427491dbb648105e83a308b74a
GIT binary patch
literal 2497
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
LNkvXXu0mjf=QqsT

literal 0
HcmV?d00001

diff --git a/Bitkit/Assets.xcassets/tether-coin.imageset/Contents.json b/Bitkit/Assets.xcassets/tether-coin.imageset/Contents.json
new file mode 100644
index 000000000..dd4386099
--- /dev/null
+++ b/Bitkit/Assets.xcassets/tether-coin.imageset/Contents.json
@@ -0,0 +1,12 @@
+{
+  "images": [
+    {
+      "filename": "tether-coin.png",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}
diff --git a/Bitkit/Assets.xcassets/tether-coin.imageset/tether-coin.png b/Bitkit/Assets.xcassets/tether-coin.imageset/tether-coin.png
new file mode 100644
index 0000000000000000000000000000000000000000..f283be245e77b338aeae3cbc1b9f31b4febe1166
GIT binary patch
literal 2257140
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
z%0D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%0A&cUx!E~nW@h4ax$t;>@q=o(w})C&9|shnfHl9Y
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%0AXmDO=u?cP|zL>Kk+y8pIxdD9TiDb
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%0AJiiun1X|i^Z
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
Ef(`y1B>(^b

literal 0
HcmV?d00001

diff --git a/Bitkit/Assets.xcassets/tether.imageset/Contents.json b/Bitkit/Assets.xcassets/tether.imageset/Contents.json
new file mode 100644
index 000000000..ae0079bc9
--- /dev/null
+++ b/Bitkit/Assets.xcassets/tether.imageset/Contents.json
@@ -0,0 +1,12 @@
+{
+  "images": [
+    {
+      "filename": "tether.png",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}
diff --git a/Bitkit/Assets.xcassets/tether.imageset/tether.png b/Bitkit/Assets.xcassets/tether.imageset/tether.png
new file mode 100644
index 0000000000000000000000000000000000000000..ccff3ff97ece660346fcf873edf2ffe7b9b46117
GIT binary patch
literal 2762
zcmV;*3N`hKP)<h;3K|Lk000e1NJLTq004jh004jp1^@s6!#-il00009a7bBm001mY
z001mY0i`{bsQ>^9d`Uz>RCt{2oqKRpcNNEf(Bh~geOYmQTd0n2i?$t|vFfO!)jHY&
zt?eJST5BD3eAPNSDr{T-aAHj}d(LJvYaoG!BoH1UB#>5KB@)0iKp+Gs2}whs$!<aj
zNm!O7WRG)hk~S?N*~i^`?&Ei6zQZs~Hs_x2=l*{8{C>Z?D3$351{Wy5f0+XCDS%Q1
za7ZDxD}ZwfU_>F3rv)%#)MC6QT$>VwxI!T=HEQR`$j!Y&AwH)N8x=rYyvR-!7`5XX
zW-G+om94|?zfK`OsQ^xh7tXzEGHRTaHDB2#va@ee08dX0W6}lkhQO%xQz{s|QO<ax
zISSxmh1err5bvr_A^t}Bd~>ZeKM=T8A=cWU09t6&V4w2)7g=LI;(ZFSUl$+k2H&7U
zd@ysy^DqODV}lFT!WnA79fRppg3tGsiT+d<A01EwfMOL2%`?w@fNkOzrA0~BpelU`
z_(>mejV?Yq6~L18rUO0alj8;OY-;8s-Y=fK7MTRWL&=%XJte?-Z2-ChLiREkT$s$f
zuNQgHb*eGEO<?GM%m&G7VMc23NFp0Mz1jeDCx8GEm6LPBOn3h?;z?>zhHJ3m>ihY6
zOP4$VVBhrT3HYFad~#Z7Ne!Nu4uD2&0D1+$rs>Y`NhhU+7S_P;Up)2h=L4MD0QBk-
zF~D*0gtW+F0FI2C&u7o|(QWb^fb4lFbThYq%fyq>A|VKt@cjRjHUPZ|A;5B;|4YRa
z(ITN5tmP4)UK@bkgb<*PM}Q9TM6^h#2JLF%?GkMQdawq(^Q#bt#S_sYp&DFb0JH(<
z;Tni1phX%04FTy9U=|4G<>t~~4jiC;U0qZki8w+P?d|mCO`GgJ%84hCpz@oV$cZsB
zHb!@rm5JBS(E!}FX%ofCxpBCshvo(X;&pT+0N3W`($TYL$?5UPjveB)bR+<OtgR(C
zL^v9y>p~&%dO8Y#4-^*C(8vh6CH_`dCtg!W0kFBPjocKm%a`fHYu1R@)e!)EtD=J3
z80%VE#A|DN0N$3DM{NTG<kq;$PHO|=2~4AB>gtjz=;@&$(FLE##fwSh`*I{=pSDmu
zfj8;a=bty`%4FjA`}T?Ej7N`>W7|UU1m2|W9UVy*(}@6t?a~&CCon}1zVJfQg>)(a
zwrLB+6PVEaP>9Z4xIkV4AZCZQP}=xO<uo*;R758OV2id;+IZGyOG{~VY>ZM3hUfF^
z*C(uZuUa)@J|A4YI;qcF-`bjT?!3wMrHvcC3&0#is_p6`D`U11BXI1PcXkV<0eEcJ
zF0wl827qW=C~5vp`T5k7<RXe&0SHUAg<d@6V@CkQ+CnMwzqnxojm0x_&gcB_Fx9;J
zD&-zKMt?qVfPS=dCw+VCR{C^F$*d263X!e}1n4~l1@yUf>*%|cmGqNcyJ*G1gY>WC
z$LYV}FkQ&d7WKu^QTov8)$Rv?Px&0_?KQ1%+(GaP;xAu%i9S(Wobmjx2?UI%e;!E~
zG&3=_ye*Uf;I}n3rrj}rudk;CD_2^64Qh&bF^5NobXr-lw$SQgy)_u5v$0s(g^G@j
z(jDv9&)8lrT(gG0S5-xi@7`?;;k;n8@#INbR$V<~j=$Qwmr7e&$luUl97X@}#1!)W
z!onGU?)z0$WJXk<I^|vfc!)M5wzRij0T!Fh4{-nK>Y{<+;fy>4o{hz5=jqe*&%=l5
zYvtv}bTIX2kC||QwL2PhF92`P%QNL6s<^q?_&gpi`EDJY!SGCW0ll%9(an5v;@RUs
zcQ>UQ{5<1Y09ZVv#!Ubq>(C+Fw1Jo7ar*h5J!u2b7mLxy)~<Co04#oDkEaR1M~jMR
zM`vf!Kf9r|l^&?Bru(a_>E3PI=o?$M(30)jjlVzi;)}HB%$cM<kK0+^58xIv9RPTG
zS-ftYwO&X8!1_fR5KK-1EG`<42LC&Ej;xBYc$^OP^w9Ey2aQuqlewe{0GoeXX{q%-
zNCLp(VKWs7_-&y%(|jJcgnU>3Y5#s>ZsxnWb7&}K&@RX0)IKmk|L*Lhyv9aj`rwY>
z`e~MJ`7moL9S%Q7@Q$d62hsqrewHEx{P6eA{QQJ|2X_hF7IGKDi#T5|FQ<DdD~(~F
zH)8nDyDKW_tD83)|IYI;ugdXT$%%YEZy_f;b%>j97XVn?tH)DZ_RT(W#4ye3oaY7t
z^p(w<X=PIrT}tvGD+h0ceWs*Dw)WD-Pt{L%?@nufpzFc~Drs(}U)R(acXFbmgGx~E
zEhwOGR#ea*YHO*yt<891Pc_(l-kXrFxvc=0JRe}@CJ`?epFDrwSR5*AZ8cW+zOZ4#
zj5*v>S!t{q@~dh4ySwSs;9yF3_|<~nBlwgZ%(o)|tVd0Tz)su25xd;^b_QT_u_#jz
zNC6PB)17a309d>z!)=%w0EpPpe7gfM`Lc-F5LgXBI2wIzufTQ^Par`E%-Cy}03d8<
z^PK_!>jx%6U=;x2Xw;GuN}d3~ObDz1AnXM5ody7lck$ANAkzSJJH>n_0$>INnFOFa
z8l{h0xu5Sv0MdOhob6r0vJ~I-<8LbYNKuh^Z9D-0i+AwM><-ciHh=250LMr?fi%S@
zeEIu$C8N`+=DPs^X$U%phG>yf&36j`tfkwxTMj{|)6I7i0IVezLU3wu(D~-O4S>nL
zd^7j%uVy|UFO$Aj4S)ayr`%*dOFV%L={sAunhrt7;2_=NCiC44fY}gqxY2yK1Hj@l
z{K<axtY^&k0s!ek@XEk|{Fgau0Mai4zx0tT1h2T=e3p0uHie+2zkk**gm8t#6A<{H
zNM?herN5uvS5P3Hs|G*-f)+2C&k|2SNc@V|#nI6>nBVL*^SulJ>&~(=+I{-8(dHGN
zI6?0c{<bkG0EWer&?2E4Tw(zFv;pW%2myMP0_YG=M2m!K(9R=3y*2>72_Zlo15hHK
zh!zRepopgcpEdx!2_e8=c?4K0o`@C+)!;s*g24p}Ag)b7uYowGLZO?L5r~a8NJtAU
zt-;}O^Tz>rP8)z;1MnYH0l3`;32C8)H3$T5dmR8h4UoqGY<i>l;{ZHqgT%DZk{Ud5
zB>-7j^A*53Z34O-!al?6X#?PC8ziWO8LR=oa&^@R25(e|J=z3xD}-Sc3SF;e48Q+T
z8zicQ8K^-Z@Iy6g5Y17D`?Lw@E(ihk8r~)pe*Yo`a9%uVEi$PF{VEt-n3(ymL$FL6
zfbM`0V2Mg80J6oC*P=9Qkfl<N@#ld;Z2~$IM1W%D^UYOhMJO~+0c;b$7%fWD{7S<+
zQ^M!FRw1s^CZJP5EHcmhsnY?#vo^RmExhVo&j)+55^wiX34nX`o&nks!T}WsJfJKI
z?kN##Y;e(9II+kBaEr1u#;1gb6+lEAfl?syTV0Q5cF3PCa&m4^h%59fW@w%90B4O|
zy;(PQtc*b59mYWefa7{Zz)YFnr~rOv)Y{hJ_b;C47#fV@$9k@&6l*Z10FD?3IIlRv
z=ak^H=e!opZ=vwY6u`?0plxEx(66SWQG-6CCR`iDwMMP@rH$9l?Po6j4{>J7JA!^v
QO#lD@07*qoM6N<$f=2%)R{#J2

literal 0
HcmV?d00001

diff --git a/Bitkit/Assets.xcassets/usdt-network.imageset/Contents.json b/Bitkit/Assets.xcassets/usdt-network.imageset/Contents.json
new file mode 100644
index 000000000..d69d3aa25
--- /dev/null
+++ b/Bitkit/Assets.xcassets/usdt-network.imageset/Contents.json
@@ -0,0 +1,12 @@
+{
+  "images": [
+    {
+      "filename": "usdt-network.png",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}
diff --git a/Bitkit/Assets.xcassets/usdt-network.imageset/usdt-network.png b/Bitkit/Assets.xcassets/usdt-network.imageset/usdt-network.png
new file mode 100644
index 0000000000000000000000000000000000000000..49ee71061b33d57ae40254f72762a9804ea95791
GIT binary patch
literal 872
zcmV-u1DE`XP)<h;3K|Lk000e1NJLTq001xm001}$1^@s6yHR`U00009a7bBm001mY
z001mY0i`{bsQ>^28c9S!RA_<iT03tOK@c7uNduywqoJaq0)fOsA_#r~5rLpIJPK$j
zDNh0lgGu6@Z=J*)1xkVuB@Kv<l8PolfsP_U0x1d-u?viL&sMniosYZSLyR=i>261!
z*`3$7V<H>KaYl*x8Uc$0tP=2}&+2)Rq@2`itR!H9m_HNHOW;q$e3`7Fc6$#2Pf{rE
zW#&3L&TboaKD+We{K&NO6Cp}<NXjJwZcw9fPP2LzVp)F+p2WDxfc5%3^9C_bkq{?C
zS;{HB#w)XCCa~RX<K20VQT|UOf+umcd;{E6xub-XONq)4nEAQSfM?|!!2HqY3fD6j
zaMNeNstE(Od<KkVFks9lyHza%W@pd)PGHl70Tp*4_<~r7H&qMbhk>FrH+Lsx8twXw
zzfzv!)6)lu`6)5~3aP5!wSrj-S*tZtX7O52=x@5(MU<bbz;-jvt-jlMciycZmx@<>
zX66t9FC!EVo<#bNv{tO*z1}XJU4U;93Va~oECG*)>O>RU={yKY$|D54jZj><NzEh6
zJg)sYdDqv{xy`T$$#M1)aF3XOMy!8F&F0b2-)yx;bYrH{BCw*1om=o$^gESp5(735
zLIO?@@IGSACINSgM^VUukit@<`~DR*8i$KjJQ^Ww6Cg;+(^RkT)2yDEx&JNBsC6Af
z1`*O1Vm=lrBjs^o{u+7`s#vL_We_24$0|Rd`S}YWJO6-;H&=j2Eh}Z)Muc=KwX6_l
z>_bRW?oTbN)>?;<WCjC-I1tGBr4v`(h2RTfmFLsTzAzueQcecasLJz6)NEc1Nu&3v
zbaI?g-I)0cS)3786*5Jts|@a@y2gX{a~0Tb#!)>yLN8m5wGsnzyUL0-bBa{EJ1j!7
zqMgo*kn#W;=Wox*@*t$FkP<e|$kKrNg$0!mET54Tb*+N3XJqLvwmNpt$daxWxjHkl
z;N>p!?ds0Rm|s`zdcEQU4*owQ>v`G~11Ip$&B&Ik6~sXV*ohr4Su-PxM}Ql4&&bjt
yz^;8Wvf>b6jf_(s1nAiCm$SlVWMqJHAi&?Yi?{q~MVx^E0000<MNUMnLSTY4cZ?1I

literal 0
HcmV?d00001

diff --git a/Bitkit/Components/Activity/ActivityList.swift b/Bitkit/Components/Activity/ActivityList.swift
index f7ca918be..027483529 100644
--- a/Bitkit/Components/Activity/ActivityList.swift
+++ b/Bitkit/Components/Activity/ActivityList.swift
@@ -2,18 +2,11 @@ import BitkitCore
 import SwiftUI
 
 struct ActivityList: View {
-    @AppStorage(PaykitFeatureFlags.uiEnabledKey) private var isPaykitUIEnabled = PaykitFeatureFlags.uiEnabledByDefault
-
+    @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject var activity: ActivityListViewModel
-    @EnvironmentObject var contactsManager: ContactsManager
-    @EnvironmentObject var feeEstimatesManager: FeeEstimatesManager
 
     let viewType: ActivityViewType
 
-    private var isPaykitUIActive: Bool {
-        PaykitFeatureFlags.isUIAvailable && isPaykitUIEnabled
-    }
-
     enum ActivityViewType {
         case all
         case lightning
@@ -22,31 +15,37 @@ struct ActivityList: View {
 
     var body: some View {
         let activities = getActivities()
-        let groupedItems = activity.groupActivities(activities)
-
-        if !groupedItems.isEmpty {
+        let rows = WalletActivity.merged(activities, filteredUsdt)
+        if !rows.isEmpty {
             LazyVStack(alignment: .leading, spacing: 16) {
-                ForEach(Array(zip(groupedItems.indices, groupedItems)), id: \.1) { index, groupItem in
-                    switch groupItem {
-                    case let .header(title):
-                        CaptionMText(title)
-                            .frame(height: 34, alignment: .bottom)
-
-                    case let .activity(item):
-                        NavigationLink(value: Route.activityDetail(item)) {
-                            ActivityRow(
-                                item: item,
-                                feeEstimates: feeEstimatesManager.estimates,
-                                contact: isPaykitUIActive ? item.contact(in: contactsManager.contacts) : nil
-                            )
-                        }
-                        .accessibilityIdentifier("Activity-\(index)")
+                ForEach(Array(rows.enumerated()), id: \.element) { index, item in
+                    if index == 0 || rows[index - 1].groupTitle != item.groupTitle {
+                        CaptionMText(item.groupTitle).frame(height: 34, alignment: .bottom)
                     }
+                    WalletActivityRow(item: item).accessibilityIdentifier("Activity-\(index)")
                 }
             }
         } else {
-            BodyMText(t("wallet__activity_no"))
-                .padding()
+            BodyMText(t("wallet__activity_no")).padding()
+        }
+    }
+
+    private var filteredUsdt: [UsdtTransfer] {
+        guard viewType == .all, activity.selectedTags.isEmpty else { return [] }
+        return usdt.transfers.filter { transfer in
+            let matchesTab: Bool = switch activity.selectedTab {
+            case .all: true
+            case .sent: !transfer.isIncoming
+            case .received: transfer.isIncoming
+            case .other: false
+            }
+            let date = Date(timeIntervalSince1970: TimeInterval(transfer.timestamp))
+            let start = activity.startDate.map { Calendar.current.startOfDay(for: $0) }
+            let end = activity.endDate.flatMap { Calendar.current.date(byAdding: .day, value: 1, to: Calendar.current.startOfDay(for: $0)) }
+            let search = activity.searchText
+            return matchesTab && (start.map { date >= $0 } ?? true) && (end.map { date < $0 } ?? true) &&
+                (search.isEmpty || transfer.recipient.localizedCaseInsensitiveContains(search) ||
+                    transfer.txHash?.localizedCaseInsensitiveContains(search) == true || "USDT".localizedCaseInsensitiveContains(search))
         }
     }
 
diff --git a/Bitkit/Components/PaykitAmountText.swift b/Bitkit/Components/PaykitAmountText.swift
index 6dde23439..3c6b4b488 100644
--- a/Bitkit/Components/PaykitAmountText.swift
+++ b/Bitkit/Components/PaykitAmountText.swift
@@ -11,9 +11,9 @@ struct PaykitAmountText: View {
             MoneyText(sats: Int(clamping: amount.atomic), size: size, symbol: true,
                       prefix: prefix, color: color, symbolColor: .textSecondary, fillsWidth: false)
         } else if size == .display {
-            NumberPadAmountText(value: prefix + amount.value, symbol: amount.asset == .usd ? "$" : "₮")
+            NumberPadAmountText(value: prefix + amount.value, symbol: "$")
         } else {
-            BodyMSBText(prefix + (amount.asset == .usd ? "$" : "₮") + amount.value, textColor: color)
+            BodyMSBText(prefix + "$" + amount.value, textColor: color)
         }
     }
 }
diff --git a/Bitkit/Components/SendSectionView.swift b/Bitkit/Components/SendSectionView.swift
index 98bb00128..00ca7484f 100644
--- a/Bitkit/Components/SendSectionView.swift
+++ b/Bitkit/Components/SendSectionView.swift
@@ -3,10 +3,12 @@ import SwiftUI
 /// A section with a caption label, content, and a divider below. Used for form-style rows (e.g. "Send from", "Send to").
 struct SendSectionView<Content: View>: View {
     private let title: String
+    private let dividerSpacing: CGFloat
     @ViewBuilder private let content: () -> Content
 
-    init(_ title: String, @ViewBuilder content: @escaping () -> Content) {
+    init(_ title: String, dividerSpacing: CGFloat = 16, @ViewBuilder content: @escaping () -> Content) {
         self.title = title
+        self.dividerSpacing = dividerSpacing
         self.content = content
     }
 
@@ -18,7 +20,7 @@ struct SendSectionView<Content: View>: View {
             content()
 
             CustomDivider()
-                .padding(.top, 16)
+                .padding(.top, dividerSpacing)
         }
         .frame(maxWidth: .infinity, alignment: .leading)
     }
diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 7c5fcce04..dd6e744b2 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -296,8 +296,8 @@ struct MainNavView: View {
             }
         }
         .onReceive(usdt.receivedTxPublisher) { tx in
-            guard navigation.currentRoute != .usdtWallet, !wallet.isRestoringWallet else { return }
-            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount))
+            guard navigation.currentRoute != .usdtWallet, !wallet.isRestoringWallet, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
+            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount, usdtTransferId: tx.id))
         }
         .onReceive(hwWalletManager.receivedTxPublisher) { tx in
             // New inbound transaction to a watched hardware wallet — show the received celebration.
@@ -463,6 +463,7 @@ struct MainNavView: View {
                 case .spendingWallet: SpendingWalletScreen()
                 case let .hardwareWallet(walletId): HardwareWalletScreen(walletId: walletId)
                 case .usdtWallet: UsdtWalletScreen()
+                case let .usdtActivity(transferId): UsdtActivityDetail(transferId: transferId)
                 case .scanner: ScannerScreen()
 
                 // Transfer
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 2a945ff46..6f1b1a886 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1850,7 +1850,7 @@
 "usdt__replaced" = "Replaced by another payment";
 
 "usdt__balance" = "Balance";
-"usdt__receive_title" = "Receive USDT";
+"usdt__receive_title" = "Receive Dollars";
 "usdt__send_title" = "Send USDT";
 
 "usdt__deposit_amount" = "Deposit amount";
@@ -1860,7 +1860,7 @@
 "usdt__deposit_empty" = "No deposits yet.";
 "usdt__deposit_estimate" = "Estimated received (USDT)";
 "usdt__deposit_estimate_note" = "Indicative price only. Costs are deducted from the USDT received and may change before conversion. The sender pays their network gas separately.";
-"usdt__deposit_fee_note" = "Fees are deducted from your deposit.";
+"usdt__deposit_fee_note" = "Fees are deducted from the USDT you receive. The sender pays their network fees separately.";
 "usdt__deposit_history" = "Cross-network Deposits";
 "usdt__deposit_limits" = "Deposit limits";
 "usdt__deposit_limits_note" = "Live liquidity and network costs can further restrict these limits. Amounts outside the limits may be held.";
@@ -1925,3 +1925,16 @@
 "usdt__copy_details" = "Copy Details";
 
 "pubky_auth__share_usdt_optional" = "Share USDT address (optional)";
+
+"usdt__receive_network_title" = "USDT Network";
+
+"usdt__receive_estimate" = "Receive (est)";
+"usdt__receive_fee" = "Fees";
+"usdt__receive_fees_title" = "Estimated Fees";
+
+"usdt__receive_network_note" = "Regardless of the receiving network, your USDT is credited to your Arbitrum One balance.";
+
+"usdt__receive_network" = "Network: {network}";
+
+"usdt__deposit_minimum" = "Minimum amount is {amount}";
+"usdt__deposit_maximum" = "Maximum amount is {amount}";
diff --git a/Bitkit/Styles/Colors.swift b/Bitkit/Styles/Colors.swift
index adb58e7d4..9a73ad40a 100644
--- a/Bitkit/Styles/Colors.swift
+++ b/Bitkit/Styles/Colors.swift
@@ -5,6 +5,7 @@ extension Color {
 
     static let brandAccent = Color(hex: 0xFF4400)
     static let blueAccent = Color(hex: 0x0085FF)
+    static let usdtAccent = Color(hex: 0x009393)
     static let greenAccent = Color(hex: 0x75BF72)
     static let purpleAccent = Color(hex: 0xB95CE8)
     static let redAccent = Color(hex: 0xE95164)
diff --git a/Bitkit/ViewModels/NavigationViewModel.swift b/Bitkit/ViewModels/NavigationViewModel.swift
index c53bc8bb4..81741e3d5 100644
--- a/Bitkit/ViewModels/NavigationViewModel.swift
+++ b/Bitkit/ViewModels/NavigationViewModel.swift
@@ -11,6 +11,7 @@ enum Route: Hashable {
     case spendingWallet
     case hardwareWallet(walletId: String)
     case usdtWallet
+    case usdtActivity(transferId: String)
     case activityList
     case activityDetail(Activity)
     case activityExplorer(Activity)
diff --git a/Bitkit/Views/Home/HomeWalletView.swift b/Bitkit/Views/Home/HomeWalletView.swift
index e017f2e61..fde2efaf7 100644
--- a/Bitkit/Views/Home/HomeWalletView.swift
+++ b/Bitkit/Views/Home/HomeWalletView.swift
@@ -6,19 +6,21 @@ struct HomeWalletView: View {
     @EnvironmentObject var app: AppViewModel
     @EnvironmentObject var navigation: NavigationViewModel
     @EnvironmentObject var settings: SettingsViewModel
+    @EnvironmentObject var currency: CurrencyViewModel
     @EnvironmentObject var wallet: WalletViewModel
     @Environment(UsdtWalletManager.self) private var usdt
     @Environment(HwWalletManager.self) private var hwWalletManager
 
     var hasActivity: Bool {
-        return activity.latestActivities?.isEmpty == false
+        return activity.latestActivities?.isEmpty == false || !usdt.transfers.isEmpty
     }
 
     /// Headline total including watch-only hardware-wallet balances (keeps `totalBalanceSats`
     /// semantics unchanged for send/transfer logic; only the headline folds hardware in).
     private var headlineSats: Int {
         let hw = Int(clamping: hwWalletManager.totalSats)
-        return wallet.totalBalanceSats.saturatingAdd(hw)
+        let usdtSats = usdt.balance.flatMap { usdtDisplaySats(amount: usdtFormatAmount(amount: $0), rate: currency.paykitRate) } ?? 0
+        return wallet.totalBalanceSats.saturatingAdd(hw).saturatingAdd(usdtSats)
     }
 
     var body: some View {
@@ -52,13 +54,13 @@ struct HomeWalletView: View {
                 }
             }
             .frame(height: 50)
-            .padding(.bottom, 32)
+            .padding(.bottom, usdt.isConfigured && hwWalletManager.wallets.isEmpty ? 24 : 32)
 
             if !hwWalletManager.wallets.isEmpty {
                 HardwareWalletsGrid(wallets: hwWalletManager.wallets) { hwWallet in
                     navigation.navigate(.hardwareWallet(walletId: hwWallet.id))
                 }
-                .padding(.bottom, 32)
+                .padding(.bottom, usdt.isConfigured ? 24 : 32)
             }
 
             if usdt.isConfigured {
@@ -67,9 +69,9 @@ struct HomeWalletView: View {
                         WalletBalanceContent {
                             CaptionMText("USDT")
                         } icon: {
-                            CircularIcon(icon: "coins", iconColor: .greenAccent, backgroundColor: .green16, size: 24)
+                            Image("tether-circle").resizable().frame(width: 24, height: 24)
                         } amount: {
-                            SubtitleText(settings.hideBalance ? " • • • • •" : usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—")
+                            SubtitleText(settings.hideBalance ? " • • • • •" : usdt.balance.map { usdtOverviewAmount($0) } ?? "—")
                                 .lineLimit(1).minimumScaleFactor(0.7)
                         }
                     }
diff --git a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
index 6136bae7c..28b8e5102 100644
--- a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
+++ b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
@@ -340,7 +340,7 @@ struct PaymentRequestAmountView: View {
             HStack {
                 Spacer()
                 ForEach([PaykitAsset.btc, .usd], id: \.self) { choice in
-                    NumberPadActionButton(text: choice.rawValue.uppercased(), color: choice == .usd ? .greenAccent : .brandAccent,
+                    NumberPadActionButton(text: choice.rawValue.uppercased(), color: choice == .usd ? .usdtAccent : .brandAccent,
                                           variant: asset == choice ? .primary : .secondary)
                     {
                         guard choice != asset else { return }
@@ -503,7 +503,7 @@ struct PaymentRequestDetailsView: View {
                     let selected = restrictedEndpoints ?? enabledEndpoints
                     let isSelected = endpoints.allSatisfy(selected.contains)
                     NumberPadActionButton(text: usdt ? "USDT" : t(lightning ? "lightning__spending" : "lightning__savings").uppercased(),
-                                          color: usdt ? .greenAccent : lightning ? .purpleAccent : .brandAccent,
+                                          color: usdt ? .usdtAccent : lightning ? .purpleAccent : .brandAccent,
                                           variant: isSelected ? .primary : .secondary)
                     {
                         restrictedEndpoints = isSelected
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index 2eda23a1e..d3648280c 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -177,7 +177,7 @@ struct PubkyAuthApprovalSheet: View {
             image: "coin-stack-4",
             continueText: t("pubky_auth__watch_only_intro_approve"),
             cancelText: t("common__cancel"),
-            accentColor: config.request.bitkitClaim == .usdtAddressV1 ? .greenAccent : .blueAccent,
+            accentColor: config.request.bitkitClaim == .usdtAddressV1 ? .usdtAccent : .blueAccent,
             testID: "PubkyAuthWatchOnlyConsent",
             cancelTestID: "PubkyAuthWatchOnlyCancel",
             continueTestID: "PubkyAuthWatchOnlyApprove",
@@ -398,9 +398,9 @@ struct PubkyAuthApprovalSheet: View {
             if config.request.bitkitClaim?.sharesUsdt == true {
                 VStack(alignment: .leading, spacing: 8) {
                     Toggle(isOn: $shareUsdt) {
-                        BodySSBText(t("pubky_auth__share_usdt_optional"), textColor: .greenAccent)
+                        BodySSBText(t("pubky_auth__share_usdt_optional"), textColor: .usdtAccent)
                     }
-                    .tint(.greenAccent)
+                    .tint(.usdtAccent)
                     .disabled(state == .authorizing)
                     .accessibilityIdentifier("PubkyAuthShareUsdt")
                     if let usdtAddress {
@@ -411,13 +411,13 @@ struct PubkyAuthApprovalSheet: View {
                         .accessibilityIdentifier("PubkyAuthUsdtAddress")
                         if showsUsdtAddress {
                             Button(t("common__copy")) { UIPasteboard.general.string = usdtAddress }
-                                .tint(.greenAccent)
+                                .tint(.usdtAccent)
                                 .accessibilityIdentifier("PubkyAuthCopyUsdtAddress")
                         }
                     } else if usdtUnavailable {
                         BodySText(t("pubky_auth__usdt_unavailable"), textColor: .white64)
                         Button(t("common__retry")) { Task { await loadUsdtAddress() } }
-                            .tint(.greenAccent)
+                            .tint(.usdtAccent)
                     } else {
                         ProgressView()
                     }
diff --git a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
index bed558168..cbd970249 100644
--- a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
+++ b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
@@ -120,7 +120,7 @@ struct CreateSubscriptionView: View {
             CaptionMText(t("wallet__payment_request_accepted_methods"), textColor: .white64)
             HStack(spacing: 16) {
                 if acceptedEndpoints.contains(PublicPaykitService.MethodId.usdtArbitrum.rawValue) {
-                    BodyMSBText("USDT", textColor: .greenAccent)
+                    BodyMSBText("USDT", textColor: .usdtAccent)
                 }
                 if acceptedEndpoints.contains(where: { PublicPaykitService.MethodId(rawValue: $0)?.onchainNetwork != nil }) {
                     BodyMSBText(t("lightning__savings"), textColor: .brandAccent)
diff --git a/Bitkit/Views/Wallets/Activity/ActivityLatest.swift b/Bitkit/Views/Wallets/Activity/ActivityLatest.swift
index dcd557e3c..be42901f7 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityLatest.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityLatest.swift
@@ -2,21 +2,15 @@ import BitkitCore
 import SwiftUI
 
 struct ActivityLatest: View {
-    @AppStorage(PaykitFeatureFlags.uiEnabledKey) private var isPaykitUIEnabled = PaykitFeatureFlags.uiEnabledByDefault
-
     @EnvironmentObject private var activity: ActivityListViewModel
     @EnvironmentObject private var app: AppViewModel
-    @EnvironmentObject private var contactsManager: ContactsManager
     @EnvironmentObject private var feeEstimatesManager: FeeEstimatesManager
     @EnvironmentObject private var navigation: NavigationViewModel
     @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var wallet: WalletViewModel
+    @Environment(UsdtWalletManager.self) private var usdt
     @Environment(HwWalletManager.self) private var hwWalletManager
 
-    private var isPaykitUIActive: Bool {
-        PaykitFeatureFlags.isUIAvailable && isPaykitUIEnabled
-    }
-
     private var shouldShowBanner: Bool {
         wallet.balanceInTransferToSavings > 0 || wallet.balanceInTransferToSpending > 0
     }
@@ -56,8 +50,9 @@ struct ActivityLatest: View {
         return max(0, slotCapacity - nonItemSlots)
     }
 
-    private var displayedActivities: [Activity]? {
-        guard let items = activity.latestActivities, !items.isEmpty else { return nil }
+    private var displayedActivities: [WalletActivity]? {
+        let items = WalletActivity.merged(activity.latestActivities ?? [], usdt.transfers)
+        guard !items.isEmpty else { return nil }
         return Array(items.prefix(maxActivityItemsOnHome))
     }
 
@@ -72,14 +67,8 @@ struct ActivityLatest: View {
             if let rows = displayedActivities {
                 LazyVStack(alignment: .leading, spacing: 16) {
                     ForEach(Array(zip(rows.indices, rows)), id: \.1) { index, item in
-                        NavigationLink(value: Route.activityDetail(item)) {
-                            ActivityRow(
-                                item: item,
-                                feeEstimates: feeEstimatesManager.estimates,
-                                contact: isPaykitUIActive ? item.contact(in: contactsManager.contacts) : nil
-                            )
-                        }
-                        .accessibilityIdentifier("ActivityShort-\(index)")
+                        WalletActivityRow(item: item)
+                            .accessibilityIdentifier("ActivityShort-\(index)")
                     }
                 }
 
diff --git a/Bitkit/Views/Wallets/Activity/ActivityRow.swift b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
index ea59a2f0b..0fce77d85 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityRow.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
@@ -100,3 +100,46 @@ struct ActivityRowContent<Icon: View, Amount: View>: View {
         }
     }
 }
+
+enum WalletActivity: Hashable {
+    case bitcoin(Activity)
+    case usdt(UsdtTransfer)
+
+    var timestamp: UInt64 {
+        switch self {
+        case let .bitcoin(.lightning(item)): item.timestamp
+        case let .bitcoin(.onchain(item)): item.timestamp
+        case let .usdt(item): item.timestamp
+        }
+    }
+
+    var groupTitle: String {
+        DateFormatterHelpers.getActivityGroupHeader(for: Date(timeIntervalSince1970: TimeInterval(timestamp)))
+    }
+
+    static func merged(_ bitcoin: [Activity], _ usdt: [UsdtTransfer]) -> [WalletActivity] {
+        (bitcoin.map(Self.bitcoin) + usdt.map(Self.usdt)).sorted { $0.timestamp > $1.timestamp }
+    }
+}
+
+struct WalletActivityRow: View {
+    let item: WalletActivity
+    @AppStorage(PaykitFeatureFlags.uiEnabledKey) private var isPaykitUIEnabled = PaykitFeatureFlags.uiEnabledByDefault
+    @EnvironmentObject private var feeEstimatesManager: FeeEstimatesManager
+    @EnvironmentObject private var contactsManager: ContactsManager
+    @EnvironmentObject private var settings: SettingsViewModel
+
+    var body: some View {
+        switch item {
+        case let .bitcoin(activity):
+            NavigationLink(value: Route.activityDetail(activity)) {
+                ActivityRow(item: activity, feeEstimates: feeEstimatesManager.estimates,
+                            contact: PaykitFeatureFlags.isUIAvailable && isPaykitUIEnabled ? activity.contact(in: contactsManager.contacts) : nil)
+            }
+        case let .usdt(transfer):
+            NavigationLink(value: Route.usdtActivity(transferId: transfer.id)) {
+                UsdtActivityRow(transfer: transfer, hideBalance: settings.hideBalance)
+            }
+        }
+    }
+}
diff --git a/Bitkit/Views/Wallets/Receive/QrArea.swift b/Bitkit/Views/Wallets/Receive/QrArea.swift
index 199a37868..f4038297f 100644
--- a/Bitkit/Views/Wallets/Receive/QrArea.swift
+++ b/Bitkit/Views/Wallets/Receive/QrArea.swift
@@ -5,25 +5,8 @@ struct QrArea: View {
     let uri: String
     let imageAsset: String?
     let accentColor: Color
-    @Binding var navigationPath: [ReceiveRoute]
-    let copyValue: String?
-    let editRoute: ReceiveRoute?
-
-    init(
-        uri: String,
-        imageAsset: String?,
-        accentColor: Color,
-        navigationPath: Binding<[ReceiveRoute]>,
-        copyValue: String? = nil,
-        editRoute: ReceiveRoute? = nil
-    ) {
-        self.uri = uri
-        self.imageAsset = imageAsset
-        self.accentColor = accentColor
-        _navigationPath = navigationPath
-        self.copyValue = copyValue
-        self.editRoute = editRoute
-    }
+    var copyValue: String?
+    var onEdit: (() -> Void)?
 
     @State private var showCopyTooltip = false
     @State private var showShareSheet = false
@@ -51,15 +34,14 @@ struct QrArea: View {
         }
 
         HStack {
-            if let editRoute {
+            if let onEdit {
                 CustomButton(
                     title: t("common__edit"),
                     size: .small,
                     icon: Image("pencil").foregroundColor(accentColor),
-                    shouldExpand: true
-                ) {
-                    navigationPath.append(editRoute)
-                }
+                    shouldExpand: true,
+                    action: onEdit
+                )
                 .accessibilityIdentifier("SpecifyInvoiceButton")
             }
 
diff --git a/Bitkit/Views/Wallets/Receive/ReceiveEdit.swift b/Bitkit/Views/Wallets/Receive/ReceiveEdit.swift
index 53cc9a914..bdeff3a75 100644
--- a/Bitkit/Views/Wallets/Receive/ReceiveEdit.swift
+++ b/Bitkit/Views/Wallets/Receive/ReceiveEdit.swift
@@ -36,7 +36,7 @@ struct ReceiveEdit: View {
             return .auto
         case .spending:
             return .spending
-        case .hardware:
+        case .hardware, .usdt:
             return .savings
         }
     }
diff --git a/Bitkit/Views/Wallets/Receive/ReceiveQr.swift b/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
index 8240424cf..3ea64838f 100644
--- a/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
+++ b/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
@@ -6,6 +6,7 @@ struct ReceiveQr: View {
     @EnvironmentObject private var app: AppViewModel
     @EnvironmentObject private var blocktank: BlocktankViewModel
     @EnvironmentObject private var wallet: WalletViewModel
+    @Environment(UsdtWalletManager.self) private var usdt
     @Environment(HwWalletManager.self) private var hwWalletManager
     @Environment(PaykitPaymentRequestManager.self) private var paymentRequests
     @Binding var navigationPath: [ReceiveRoute]
@@ -13,6 +14,7 @@ struct ReceiveQr: View {
     let tab: ReceiveTab?
     let hardwareWalletId: String?
 
+    @State private var needsInvoiceRefresh: Bool
     @State private var selectedTab: ReceiveTab
     @State private var showDetails = false
     @State private var hasAppliedDefaultTab = false
@@ -45,12 +47,13 @@ struct ReceiveQr: View {
             // We'll set this in onAppear since we need access to wallet.channelCount
             .savings
         }
+        _needsInvoiceRefresh = State(initialValue: tab == .usdt)
         _selectedTab = State(initialValue: defaultTab)
         _hasAppliedDefaultTab = State(initialValue: tab != nil)
     }
 
     enum ReceiveTab: CaseIterable, CustomStringConvertible {
-        case savings, unified, spending, hardware
+        case savings, unified, spending, hardware, usdt
 
         var description: String {
             switch self {
@@ -60,6 +63,8 @@ struct ReceiveQr: View {
                 return "Auto"
             case .spending:
                 return t("lightning__spending")
+            case .usdt:
+                return "USDT"
             case .hardware:
                 return t("hardware__receive_tab_hardware")
             }
@@ -79,6 +84,7 @@ struct ReceiveQr: View {
         if selectedHardwareWalletId != nil {
             items.insert(TabItem(.hardware, label: selectedHardwareWallet?.vendor.modelName), at: 0)
         }
+        if usdt.isConfigured, cjitInvoice == nil { items.append(TabItem(.usdt)) }
         return items
     }
 
@@ -120,6 +126,14 @@ struct ReceiveQr: View {
     }
 
     var body: some View {
+        if selectedTab == .usdt {
+            UsdtReceiveView(tabs: availableTabItems, onSelectTab: { selectedTabBinding.wrappedValue = $0 }, contactAction: paymentRequestAction)
+        } else {
+            bitcoinContent
+        }
+    }
+
+    private var bitcoinContent: some View {
         VStack(spacing: 0) {
             SheetHeader(title: t("wallet__receive_bitcoin"), action: paymentRequestAction)
                 .padding(.horizontal, 16)
@@ -142,6 +156,7 @@ struct ReceiveQr: View {
                     }
 
                     tabContent(for: .spending)
+                    if usdt.isConfigured, cjitInvoice == nil { Color.clear.tag(ReceiveTab.usdt) }
                 }
                 .tabViewStyle(PageTabViewStyle(indexDisplayMode: .never))
                 .indexViewStyle(PageIndexViewStyle(backgroundDisplayMode: .always))
@@ -308,7 +323,9 @@ struct ReceiveQr: View {
 
     func tabContent(for tab: ReceiveTab) -> some View {
         VStack(spacing: 0) {
-            if tab == .spending && !wallet.canCreateReceiveLightningInvoice && cjitInvoice == nil {
+            if needsInvoiceRefresh && tab != .hardware {
+                ProgressView()
+            } else if tab == .spending && !wallet.canCreateReceiveLightningInvoice && cjitInvoice == nil {
                 cjitOnboarding
             } else if showDetails {
                 detailsContent(for: tab)
@@ -335,9 +352,8 @@ struct ReceiveQr: View {
                     uri: uri,
                     imageAsset: "btc-circle-blue",
                     accentColor: .blueAccent,
-                    navigationPath: $navigationPath,
                     copyValue: uri.contains("?") ? uri : hardwareAddress.address,
-                    editRoute: .edit(tab: .hardware, onchainOnly: true)
+                    onEdit: { navigationPath.append(.edit(tab: .hardware, onchainOnly: true)) }
                 )
             } else if hardwareAddressLoadFailed {
                 VStack(spacing: 16) {
@@ -360,8 +376,9 @@ struct ReceiveQr: View {
                     uri: config.uri,
                     imageAsset: config.imageAsset,
                     accentColor: config.accentColor,
-                    navigationPath: $navigationPath,
-                    editRoute: editRoute(for: tab)
+                    onEdit: editRoute(for: tab).map { route in
+                        { navigationPath.append(route) }
+                    }
                 )
             } else {
                 ProgressView()
@@ -389,6 +406,8 @@ struct ReceiveQr: View {
                 imageAsset: "ln",
                 accentColor: .purpleAccent
             )
+        case .usdt:
+            return (uri: usdt.receiveUri, imageAsset: "tether-circle", accentColor: .usdtAccent)
         case .hardware:
             return (uri: "", imageAsset: "btc-circle-blue", accentColor: .blueAccent)
         }
@@ -487,6 +506,8 @@ struct ReceiveQr: View {
                             )
                         )
                     }
+                case .usdt:
+                    pairs.append(CopyAddressPair(title: t("wallet__activity_address"), address: usdt.address, type: .onchain))
                 case .hardware:
                     if let hardwareAddress = displayedHardwareAddress {
                         pairs.append(
@@ -527,7 +548,11 @@ struct ReceiveQr: View {
     func refreshBip21() async {
         guard wallet.nodeLifecycleState == .running else { return }
         do {
-            try await wallet.refreshBip21()
+            if needsInvoiceRefresh, let paymentId = await wallet.paymentId(), !paymentId.isEmpty {
+                try? await CoreService.shared.activity.resetPreActivityMetadataTags(paymentId: paymentId)
+            }
+            try await wallet.refreshBip21(forceRefreshBolt11: needsInvoiceRefresh)
+            needsInvoiceRefresh = false
         } catch {
             app.toast(error)
         }
diff --git a/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift b/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
index af1a88384..fad6d5447 100644
--- a/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
+++ b/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
@@ -59,14 +59,6 @@ struct ReceiveSheet: View {
     @State private var navigationPath: [ReceiveRoute] = []
 
     var body: some View {
-        if config.initialRoute == .usdt {
-            Sheet(id: .receive, data: config) { UsdtReceiveView() }
-        } else {
-            bitcoinReceiveSheet
-        }
-    }
-
-    private var bitcoinReceiveSheet: some View {
         Sheet(id: .receive, data: config) {
             NavigationStack(path: $navigationPath) {
                 viewForRoute(config.initialRoute)
@@ -76,7 +68,7 @@ struct ReceiveSheet: View {
             }
             .id(config.id)
         }
-        .offlineSheetOverlay(title: t("wallet__receive_bitcoin"))
+        .offlineSheetOverlay(title: t("wallet__receive"), isEnabled: config.initialRoute != .usdt)
         .sheet(isPresented: reconnectPairingBinding) {
             HardwarePairingSheet(config: HardwarePairingSheetItem())
         }
@@ -110,7 +102,7 @@ struct ReceiveSheet: View {
     @ViewBuilder
     private func viewForRoute(_ route: ReceiveRoute) -> some View {
         switch route {
-        case .usdt: EmptyView()
+        case .usdt: ReceiveQr(navigationPath: $navigationPath, tab: .usdt, hardwareWalletId: config.hardwareWalletId)
         case let .qr(cjitInvoice, tab):
             ReceiveQr(
                 navigationPath: $navigationPath,
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index 54c31e06a..0294b73d1 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -79,7 +79,7 @@ struct SendAmountView: View {
         switch selectedFundingSource {
         case .spending: .purpleAccent
         case .savings: .brandAccent
-        case .usdt: .greenAccent
+        case .usdt: .usdtAccent
         case .hardware: .blueAccent
         }
     }
@@ -136,7 +136,7 @@ struct SendAmountView: View {
 
             VStack(alignment: .leading, spacing: 0) {
                 if app.paykitUsesUsdt {
-                    NumberPadAmountText(value: usdtAmount.isEmpty ? "0" : usdtAmount, symbol: "₮")
+                    NumberPadAmountText(value: usdtAmount.isEmpty ? "0" : usdtAmount, symbol: "$")
                         .accessibilityIdentifier("SendNumberField")
                 } else {
                     NumberPadTextField(viewModel: amountViewModel, testIdentifier: "SendNumberField")
diff --git a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
index 9cb7dc8a9..bc8a3c8d2 100644
--- a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
+++ b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
@@ -10,6 +10,7 @@ struct ReceivedTxSheetDetails: Codable {
     let type: ReceivedTxType
     var sats: UInt64 = 0
     var usdtAmount: UInt64? = nil
+    var usdtTransferId: String? = nil
 }
 
 struct ReceivedTxSheetItem: SheetItem {
@@ -22,6 +23,7 @@ struct ReceivedTx: View {
     let config: ReceivedTxSheetItem
 
     @EnvironmentObject private var sheets: SheetViewModel
+    @EnvironmentObject private var navigation: NavigationViewModel
 
     /// Keep in state so we don't get a new random text on each render
     @State private var buttonText: String = localizedRandom("common__ok_random")
@@ -35,7 +37,7 @@ struct ReceivedTx: View {
             ZStack {
                 PaymentCelebration(
                     isOnchain: isOnchain, isReceived: true,
-                    confettiColor: config.details.usdtAmount != nil ? .greenAccent : nil
+                    confettiColor: config.details.usdtAmount != nil ? .usdtAccent : nil
                 )
 
                 VStack(alignment: .leading, spacing: 0) {
@@ -47,8 +49,16 @@ struct ReceivedTx: View {
                         MoneyStack(sats: Int(config.details.sats), showSymbol: true, testIdPrefix: "ReceivedTransaction")
                     }
                     Spacer()
-                    CustomButton(title: buttonText) { sheets.hideSheet() }
-                        .accessibilityIdentifier("ReceivedTransactionButton")
+                    HStack(spacing: 16) {
+                        if let transferId = config.details.usdtTransferId {
+                            CustomButton(title: t("wallet__send_details"), variant: .secondary) {
+                                sheets.hideSheet()
+                                navigation.navigate(.usdtActivity(transferId: transferId))
+                            }.accessibilityIdentifier("ReceivedTransactionDetails")
+                        }
+                        CustomButton(title: buttonText) { sheets.hideSheet() }
+                            .accessibilityIdentifier("ReceivedTransactionButton")
+                    }
                 }
                 .padding(.horizontal, 16)
             }
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index c563d4c45..e4c59d3c1 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -26,7 +26,7 @@ struct UsdtActivityRow: View {
                         accentColor: .textSecondary
                     )
                     .lineLimit(1).minimumScaleFactor(0.7)
-                    CaptionBText("USDT", textColor: .textSecondary)
+                    CaptionBText(hideBalance ? "• • • • •" : "$ " + usdtOverviewAmount(transfer.activityAmount), textColor: .textSecondary)
                 }
             }
         }
@@ -187,7 +187,7 @@ extension UsdtTransfer {
         switch status {
         case .failed, .replaced: .redAccent
         case .bridgeNeedsAttention, .bridgeFailed: .yellowAccent
-        default: .greenAccent
+        default: .usdtAccent
         }
     }
 }
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index 1040ab1e4..d55f57edb 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -39,8 +39,8 @@ struct UsdtDepositHistoryView: View {
                                         ActivityRowContent(title: deposit.network.uppercased(), subtitle: deposit.statusText) {
                                             CircularIcon(
                                                 icon: "arrow-down",
-                                                iconColor: .greenAccent,
-                                                backgroundColor: .greenAccent.opacity(0.16),
+                                                iconColor: .usdtAccent,
+                                                backgroundColor: .usdtAccent.opacity(0.16),
                                                 size: 40
                                             )
                                         } amount: { BodySSBText(deposit.asset == "USDT" ? amount(deposit.amount) : deposit.asset) }
diff --git a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
new file mode 100644
index 000000000..7d285357f
--- /dev/null
+++ b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
@@ -0,0 +1,107 @@
+import BitkitCore
+import SwiftUI
+
+struct UsdtReceiveAmountView: View {
+    @Binding var amount: String
+    let busy: Bool
+    let error: String?
+    let allowEmpty: Bool
+    let onContinue: () async -> Void
+
+    @EnvironmentObject private var currency: CurrencyViewModel
+    @State private var bitcoinInput: String?
+    @State private var conversionError: String?
+
+    private var isSatsInput: Bool {
+        bitcoinInput != nil && currency.displayUnit == .modern
+    }
+
+    private var canContinue: Bool {
+        !busy && conversionError == nil &&
+            (amount.isEmpty ? allowEmpty : (try? PaykitAmount(asset: .usdt, value: amount)) != nil)
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            VStack(alignment: .leading, spacing: 0) {
+                if let bitcoinInput {
+                    VStack(alignment: .leading, spacing: 16) {
+                        CaptionMText("$ " + (amount.isEmpty ? "0" : amount), textColor: .textSecondary)
+                        NumberPadAmountText(value: bitcoinInput.isEmpty ? "0" : bitcoinInput, symbol: "₿")
+                    }
+                } else {
+                    UsdtAmountHeader(amount: amount.isEmpty ? "0" : amount, network: "Arbitrum One")
+                }
+                Spacer(minLength: 16)
+                HStack(alignment: .bottom, spacing: 16) {
+                    if let message = conversionError ?? error { BodySText(message, textColor: .brandAccent) }
+                    Spacer(minLength: 0)
+                    NumberPadActionButton(text: bitcoinInput == nil ? "USD" : "BTC", imageName: "arrow-up-down",
+                                          color: .usdtAccent, disabled: busy, action: toggleUnit)
+                        .fixedSize()
+                        .accessibilityIdentifier("ReceiveNumberPadUnit")
+                }.padding(.bottom, 16)
+            }
+            .frame(minHeight: 156, alignment: .top)
+            .fixedSize(horizontal: false, vertical: true)
+            Divider()
+            NumberPad(type: isSatsInput ? .integer : .decimal, isDisabled: busy,
+                      onDeleteLongPress: { updateInput("") })
+            { key in
+                updateInput(NumberPadInputHandler.handleInput(key: key, current: bitcoinInput ?? amount,
+                                                              maxLength: 21, maxDecimals: isSatsInput ? 0 : (bitcoinInput == nil ? 6 : 8)))
+            }
+            .padding(.top, 24)
+            Spacer(minLength: 24)
+            CustomButton(title: t("common__continue"), isDisabled: !canContinue, isLoading: busy, action: onContinue)
+                .accessibilityIdentifier("UsdtDepositCreate")
+        }
+    }
+
+    private func toggleUnit() {
+        conversionError = nil
+        if bitcoinInput != nil { bitcoinInput = nil; return }
+        guard !amount.isEmpty, amount != "0" else { bitcoinInput = ""; return }
+        do {
+            let bitcoin = try PaykitAmount(asset: .usdt, value: amount).converted(to: .btc, rate: currency.paykitRate, at: Date())
+            // Display conversion must not round or replace the USDT amount when switching units.
+            bitcoinInput = currency.displayUnit == .modern ? String(bitcoin.atomic) : bitcoin.value
+        } catch {
+            conversionError = t(error as? PaykitAmountError == .rateUnavailable
+                ? "wallet__payment_request_rate_unavailable" : "usdt__error_amount")
+        }
+    }
+
+    private func updateInput(_ value: String) {
+        conversionError = nil
+        guard bitcoinInput != nil else { amount = value; return }
+        bitcoinInput = value
+        guard !value.isEmpty else { amount = ""; return }
+        do {
+            let bitcoin: PaykitAmount
+            if isSatsInput {
+                guard let sats = UInt64(value), sats > 0 else { throw PaykitAmountError.invalidAmount }
+                bitcoin = PaykitAmount(asset: .btc, atomic: sats)
+            } else { bitcoin = try PaykitAmount(asset: .btc, value: value) }
+            amount = try bitcoin.converted(to: .usdt, rate: currency.paykitRate, at: Date()).value
+        } catch {
+            conversionError = t(error as? PaykitAmountError == .rateUnavailable
+                ? "wallet__payment_request_rate_unavailable" : "usdt__error_amount")
+        }
+    }
+}
+
+@MainActor
+func usdtDepositAmountMessage(_ error: Error, amount: String) -> String {
+    if let error = error as? UsdtError, case let .DepositAmountOutOfRange(min, max) = error,
+       let value = Decimal(string: amount)
+    {
+        if let min, let cents = Decimal(string: min), value < cents / 100 {
+            return t("usdt__deposit_minimum", variables: ["amount": min.usdCents])
+        }
+        if let max, let cents = Decimal(string: max), value > cents / 100 {
+            return t("usdt__deposit_maximum", variables: ["amount": max.usdCents])
+        }
+    }
+    return UsdtWalletManager.message(for: error)
+}
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index 893f19e36..e9cfebc2b 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -2,54 +2,77 @@ import BitkitCore
 import SwiftUI
 
 struct UsdtReceiveView: View {
+    let tabs: [TabItem<ReceiveQr.ReceiveTab>]
+    let onSelectTab: (ReceiveQr.ReceiveTab) -> Void
+    var contactAction: AnyView?
     @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject private var sheets: SheetViewModel
-    @Environment(\.dismiss) private var dismiss
     @Environment(\.scenePhase) private var scenePhase
     @State private var networks: [UsdtDepositNetwork] = []
     @State private var network: UsdtDepositNetwork?
-    @State private var history = false
+    @State private var page = Page.address
     @State private var historyBlocking = false
-    @State private var unavailable = false
+    @State private var amount = ""
+    @State private var deposit: UsdtDepositAddress?
+    @State private var busy = false
+    @State private var error: String?
+
+    private enum Page { case address, networks, amount, fees, history }
+
+    private var networkName: String {
+        network?.label ?? "Arbitrum One"
+    }
+
+    private var title: String {
+        switch page {
+        case .address: t("usdt__receive_title")
+        case .networks: t("usdt__receive_network_title")
+        case .amount: t("wallet__receive_amount")
+        case .fees: t("usdt__receive_fees_title")
+        case .history: t("usdt__deposit_history")
+        }
+    }
+
+    private var receiveUri: String {
+        guard let atomic = try? PaykitAmount(asset: .usdt, value: amount).atomic else { return usdt.receiveUri }
+        return usdt.receiveUri + "&uint256=\(atomic)"
+    }
 
     var body: some View {
         VStack(spacing: 0) {
-            SheetHeader(title: t(history ? "usdt__deposit_history" : "usdt__receive_title"), showBackButton: true,
-                        onBack: { if history { history = false } else { dismiss() } })
-                .disabled(historyBlocking)
-            if history {
+            SheetHeader(title: title, showBackButton: page != .address, action: page == .address ? contactAction : nil,
+                        onBack: {
+                            if page == .fees { page = .amount }
+                            else if page == .amount, network != nil, deposit == nil { page = .networks }
+                            else { if deposit == nil { network = nil }; page = .address }
+                        })
+                        .disabled(busy || historyBlocking)
+            switch page {
+            case .address:
+                SegmentedControl(selectedTab: Binding(get: { .usdt }, set: onSelectTab), tabItems: tabs)
+                    .padding(.bottom, 16)
+                UsdtReceiveAddressContent(
+                    address: deposit?.address ?? usdt.address,
+                    uri: deposit?.uri ?? receiveUri,
+                    network: networkName,
+                    error: error ?? usdt.errorMessage,
+                    onEdit: { page = .amount },
+                    onNetwork: { page = .networks }
+                )
+            case .networks:
+                networkList
+            case .amount:
+                amountEntry
+            case .fees:
+                if let deposit { feeEstimate(deposit) }
+            case .history:
                 UsdtDepositHistoryView(onBlockingChange: { historyBlocking = $0 })
-            } else {
-                HStack {
-                    Menu {
-                        Button("Arbitrum One") { network = nil }
-                        ForEach(networks, id: \.self) { item in Button(item.label) { network = item } }
-                    } label: {
-                        NumberPadActionButton(text: network?.label ?? "Arbitrum One", color: .greenAccent, variant: .secondary) {}
-                    }
-                    .accessibilityIdentifier("UsdtReceiveNetwork")
-                    Spacer()
-                    if usdt.depositsConfigured {
-                        Button { history = true } label: { BodySSBText(t("usdt__activity"), textColor: .greenAccent) }
-                            .accessibilityIdentifier("UsdtDepositHistory")
-                    }
-                }.padding(.bottom, 16)
-                if let network { UsdtDepositReceiveView(network: network).id(network) }
-                else {
-                    if unavailable { BodySText(t("usdt__deposit_unavailable"), textColor: .textSecondary).padding(.bottom, 12) }
-                    UsdtReceiveAddressContent(
-                        address: usdt.address,
-                        uri: usdt.receiveUri,
-                        warning: t("usdt__receive_warning"),
-                        error: usdt.errorMessage
-                    )
-                }
             }
         }
         .padding(.horizontal, 16)
         .onReceive(usdt.receivedTxPublisher) { transfer in
             guard !historyBlocking, sheets.activeSheetConfiguration?.id == .receive else { return }
-            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: transfer.amount))
+            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: transfer.amount, usdtTransferId: transfer.id))
         }
         .task(id: scenePhase) {
             guard scenePhase == .active else { return }
@@ -60,96 +83,120 @@ struct UsdtReceiveView: View {
         }
         .task {
             do { networks = try await usdt.depositNetworks() }
-            catch is CancellationError {} catch { unavailable = true }
+            catch is CancellationError {} catch { self.error = t("usdt__deposit_unavailable") }
         }
     }
-}
 
-struct UsdtReceiveAddressContent<Details: View>: View {
-    let address: String
-    let uri: String
-    let warning: String
-    var error: String?
-    @ViewBuilder var details: () -> Details
-    @State private var showDetails = false
+    private var networkList: some View {
+        ScrollView {
+            VStack(spacing: 8) {
+                networkRow(nil)
+                ForEach(networks, id: \.self) { networkRow($0) }
+                BodySText(t("usdt__receive_network_note"), textColor: .textSecondary)
+                    .frame(maxWidth: .infinity, alignment: .leading).padding(.vertical, 16)
+                UsdtCoinIllustration()
+                if usdt.depositsConfigured {
+                    CustomButton(title: t("usdt__deposit_history"), variant: .tertiary) { page = .history }
+                        .accessibilityIdentifier("UsdtDepositHistory")
+                }
+                if let error { BodySText(error, textColor: .textSecondary) }
+            }
+        }
+    }
 
-    var body: some View {
-        ScrollView(showsIndicators: false) {
-            VStack(alignment: .leading, spacing: 16) {
-                if !uri.isEmpty {
-                    if showDetails {
-                        CopyAddressCard(addresses: [CopyAddressPair(title: t("usdt__receive_title"), address: address, type: .onchain)],
-                                        navigationPath: .constant([]), editRoute: nil, accentColor: .greenAccent)
-                    } else {
-                        QrArea(uri: uri, imageAsset: nil, accentColor: .greenAccent, navigationPath: .constant([]),
-                               copyValue: address, editRoute: nil)
-                    }
-                    BodySText(address, textColor: .textSecondary).lineLimit(1).truncationMode(.middle).textSelection(.enabled)
-                        .accessibilityIdentifier("UsdtReceiveAddress")
-                } else if let error { BodySText(error, textColor: .brandAccent) }
-                else { ProgressView() }
-                details()
-                BodySText(warning, textColor: .textSecondary)
+    private func networkRow(_ item: UsdtDepositNetwork?) -> some View {
+        Button {
+            if network != item { deposit = nil; amount = ""; error = nil }
+            network = item
+            page = item == nil || deposit != nil ? .address : .amount
+        } label: {
+            HStack(spacing: 16) {
+                Image("tether").resizable().frame(width: 40, height: 40)
+                BodyMSBText(item?.label ?? "Arbitrum One")
+                if item == nil { BodySText(t("common__default"), textColor: .textSecondary) }
+                Spacer()
+                if network == item { Image("check-mark").resizable().frame(width: 24, height: 24).foregroundColor(.usdtAccent) }
             }
+            .padding(16).background(Color.gray6).clipShape(RoundedRectangle(cornerRadius: 16))
+        }
+        .buttonStyle(.plain)
+        .accessibilityIdentifier("UsdtNetwork-\(item?.label ?? "Arbitrum")")
+    }
+
+    private var amountEntry: some View {
+        UsdtReceiveAmountView(amount: $amount, busy: busy, error: error, allowEmpty: network == nil) {
+            guard let network else { page = .address; return }
+            busy = true
+            error = nil
+            defer { busy = false }
+            do {
+                deposit = try await usdt.prepareDeposit(network: network, amount: amount)
+                page = .fees
+            } catch {
+                self.error = usdtDepositAmountMessage(error, amount: amount)
+            }
+        }
+        .onChange(of: amount) { error = nil }
+    }
+
+    private func feeEstimate(_ deposit: UsdtDepositAddress) -> some View {
+        VStack(alignment: .leading, spacing: 24) {
+            UsdtAmountHeader(amount: usdtFormatAmount(amount: deposit.amount), network: networkName)
+            BodyMText(t("usdt__deposit_fee_note"), textColor: .textSecondary)
+            VStack(alignment: .leading, spacing: 24) {
+                feeRow(
+                    t("usdt__receive_fee"),
+                    amount: deposit.amount >= deposit.estimatedReceived ? deposit.amount - deposit.estimatedReceived : nil
+                )
+                feeRow(t("usdt__receive_estimate"), amount: deposit.estimatedReceived)
+            }
+            Spacer()
+            CustomButton(title: t("common__continue")) { page = .address }
+                .accessibilityIdentifier("UsdtReceiveFeesContinue")
         }
-        CustomButton(title: t(showDetails ? "wallet__receive_show_qr" : "common__show_details"),
-                     variant: showDetails ? .primary : .tertiary,
-                     icon: showDetails ? Image("qr").resizable().frame(width: 16, height: 16) : nil, shouldExpand: true)
-        {
-            showDetails.toggle()
-        }.accessibilityIdentifier("UsdtReceiveDetails")
     }
-}
 
-extension UsdtReceiveAddressContent where Details == EmptyView {
-    init(address: String, uri: String, warning: String, error: String? = nil) {
-        self.address = address; self.uri = uri; self.warning = warning; self.error = error; details = { EmptyView() }
+    private func feeRow(_ title: String, amount: UInt64?) -> some View {
+        SendSectionView(title.uppercased(), dividerSpacing: 24) {
+            BodyMSBText("<accent>± $</accent> " + (amount.map { usdtFormatAmount(amount: $0) } ?? "—"), accentColor: .textSecondary)
+        }
     }
 }
 
-private struct UsdtDepositReceiveView: View {
-    let network: UsdtDepositNetwork
-    @Environment(UsdtWalletManager.self) private var usdt
-    @State private var amount = ""
-    @State private var deposit: UsdtDepositAddress?
-    @State private var busy = false
-    @State private var error: String?
+struct UsdtReceiveAddressContent: View {
+    let address: String
+    let uri: String
+    let network: String
+    var error: String?
+    let onEdit: () -> Void
+    let onNetwork: () -> Void
+    @State private var showDetails = false
 
     var body: some View {
-        if let deposit {
-            UsdtReceiveAddressContent(address: deposit.address, uri: deposit.uri, warning: t("usdt__deposit_notice")) {
-                SendSectionView(t("usdt__deposit_estimate")) { BodySSBText(usdtFormatAmount(amount: deposit.estimatedReceived) + " USDT") }
-                SendSectionView(t("usdt__deposit_cost")) {
-                    BodySSBText(deposit.amount >= deposit
-                        .estimatedReceived ? usdtFormatAmount(amount: deposit.amount - deposit.estimatedReceived) + " USDT" : "—")
-                }
-                BodySText(t("usdt__deposit_estimate_note"), textColor: .textSecondary)
-                SendSectionView(t("usdt__deposit_limits")) {
-                    BodySSBText((deposit.minUsdCents?.usdCents ?? "—") + " – " + (deposit.maxUsdCents?.usdCents ?? "—"))
-                }
-                BodySText(t("usdt__deposit_limits_note"), textColor: .textSecondary)
-                CustomButton(title: t("usdt__deposit_refresh"), variant: .secondary, shouldExpand: true) { self.deposit = nil }
-            }
-        } else {
-            VStack(alignment: .leading, spacing: 0) {
-                CaptionMText(t("usdt__deposit_amount")).padding(.bottom, 12)
-                NumberPadAmountText(value: amount.isEmpty ? "0" : amount, symbol: "₮")
-                Spacer(minLength: 16)
-                BodySText(error ?? t("usdt__deposit_fee_note"), textColor: error == nil ? .textSecondary : .brandAccent)
-                    .padding(.bottom, 16)
-                Divider()
-                NumberPad(type: .decimal, isDisabled: busy, onDeleteLongPress: { amount = "" }) { key in
-                    amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
+        ScrollView(showsIndicators: false) {
+            if !uri.isEmpty {
+                if showDetails {
+                    CopyAddressCard(
+                        addresses: [CopyAddressPair(title: network + " " + t("wallet__activity_address"), address: address, type: .onchain)],
+                        navigationPath: .constant([]),
+                        editRoute: nil,
+                        accentColor: .usdtAccent
+                    )
+                    .accessibilityIdentifier("UsdtReceiveAddress")
+                } else {
+                    QrArea(uri: uri, imageAsset: "tether-circle", accentColor: .usdtAccent,
+                           copyValue: address, onEdit: onEdit)
                 }
-                CustomButton(title: t("usdt__deposit_create"), isDisabled: busy || amount.isEmpty, isLoading: busy) {
-                    busy = true; error = nil
-                    defer { busy = false }
-                    do { deposit = try await usdt.prepareDeposit(network: network, amount: amount) }
-                    catch { self.error = UsdtWalletManager.message(for: error) }
-                }.accessibilityIdentifier("UsdtDepositCreate")
-            }
-            .onChange(of: amount) { error = nil }
+            } else if let error { BodySText(error, textColor: .brandAccent) }
+            else { ProgressView() }
         }
+        CustomButton(title: t("usdt__receive_network", variables: ["network": network]), variant: .secondary, size: .small,
+                     icon: Image("usdt-network").resizable().frame(width: 16, height: 16), shouldExpand: true, action: onNetwork)
+            .padding(.bottom, 16)
+            .accessibilityIdentifier("UsdtReceiveNetwork")
+        CustomButton(title: t(showDetails ? "wallet__receive_show_qr" : "common__show_details"),
+                     icon: showDetails ? Image("qr").resizable().frame(width: 16, height: 16) : nil, shouldExpand: true)
+        { showDetails.toggle() }.accessibilityIdentifier("UsdtReceiveDetails")
     }
 }
 
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 6fabe892b..8c0428bd6 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -107,7 +107,7 @@ struct UsdtSendView: View {
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         .background {
             if submitted, !busy, submittedStatus == .confirmed {
-                PaymentCelebration(isOnchain: true, isReceived: false, confettiColor: .greenAccent)
+                PaymentCelebration(isOnchain: true, isReceived: false, confettiColor: .usdtAccent)
             }
         }
         .sheetBackground()
@@ -163,7 +163,7 @@ struct UsdtSendView: View {
                         }
                     }
                 } label: {
-                    NumberPadActionButton(text: destination.label, color: .greenAccent, variant: .secondary) {}
+                    NumberPadActionButton(text: destination.label, color: .usdtAccent, variant: .secondary) {}
                 }
                 .accessibilityIdentifier("UsdtNetwork")
             } else {
@@ -180,13 +180,13 @@ struct UsdtSendView: View {
             Scanner(onScan: { payload in if let value = payload.string { useRecipient(value) } }, onImageSelection: readImage)
                 .frame(maxWidth: .infinity, maxHeight: .infinity)
             RectangleButton(
-                icon: "clipboard", iconColor: .greenAccent, title: t("common__paste"), testID: "UsdtPaste"
+                icon: "clipboard", iconColor: .usdtAccent, title: t("common__paste"), testID: "UsdtPaste"
             ) {
                 if let value = UIPasteboard.general.string, !value.isEmpty { useRecipient(value) }
                 else { error = t("wallet__send_clipboard_empty_text") }
             }
             RectangleButton(
-                icon: "pencil", iconColor: .greenAccent, title: t("wallet__recipient_manual"), testID: "UsdtManual"
+                icon: "pencil", iconColor: .usdtAccent, title: t("wallet__recipient_manual"), testID: "UsdtManual"
             ) { editingRecipient = true }
             if let error { BodySText(error, textColor: .brandAccent) }
             BodySText(t("usdt__network_warning"), textColor: .textSecondary).padding(.top, 8)
@@ -217,23 +217,24 @@ struct UsdtSendView: View {
     private var amountContent: some View {
         VStack(alignment: .leading, spacing: 0) {
             CaptionMText("USDT · " + destination.label).padding(.bottom, 8)
-            NumberPadAmountText(value: amount.isEmpty ? "0" : amount, symbol: "₮")
+            NumberPadAmountText(value: amount.isEmpty ? "0" : amount, symbol: "$")
                 .accessibilityIdentifier("UsdtAmount")
-            Spacer(minLength: 16)
+                .padding(.bottom, 32)
             if let error {
                 BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError").padding(.bottom, 16)
             }
             HStack(alignment: .bottom) {
-                VStack(alignment: .leading, spacing: 4) {
+                VStack(alignment: .leading, spacing: 8) {
                     CaptionMText(t("usdt__balance"))
                     BodySSBText((settings.hideBalance ? " • • • • •" : usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—") + " USDT")
                 }
                 Spacer()
-                NumberPadActionButton(text: "USDT", color: .greenAccent, variant: .secondary, disabled: true) {}
+                NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
             }
-            .padding(.bottom, 12)
+            .padding(.bottom, 16)
             CustomDivider()
             NumberPad(type: .decimal, isDisabled: busy || embedded, onDeleteLongPress: { amount = "" }, onPress: enterAmount)
+                .frame(maxHeight: .infinity)
             CustomButton(title: t("common__continue"), isDisabled: busy || amount.isEmpty, isLoading: busy) {
                 guard !busy, quote == nil else { return }
                 busy = true
@@ -259,12 +260,12 @@ struct UsdtSendView: View {
                 VStack(alignment: .leading, spacing: 0) {
                     UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), network: quote.destination.label)
                         .contentShape(Rectangle()).onTapGesture { if !busy { goBack() } }
-                        .padding(.bottom, 32)
+                        .padding(.bottom, 44)
                     if showDetails {
                         VStack(alignment: .leading, spacing: 16) {
                             HStack(alignment: .top, spacing: 16) {
                                 SendSectionView(t("wallet__send_from")) {
-                                    NumberPadActionButton(text: "USDT", color: .greenAccent, variant: .secondary, disabled: true) {}
+                                    NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
                                 }
                                 SendSectionView(t("usdt__destination")) { BodySSBText(quote.destination.label).frame(height: 28) }
                             }
@@ -276,39 +277,40 @@ struct UsdtSendView: View {
                     } else {
                         PaymentReviewIllustration(swipeProgress: swipeProgress, maximumHeight: 220)
                     }
-                }
-            }
-            if quote.destination != .arbitrum {
-                SendSectionView(t(quote.bridgeProvider == .orchestra ? "usdt__expected_amount" : "usdt__recipient_gets")) {
-                    BodySSBText(usdtFormatAmount(amount: quote.receivedAmount) + " USDT")
-                }.padding(.top, 16)
-                if quote.bridgeProvider == .orchestra {
-                    SendSectionView(t("usdt__bridge_deducted_fee")) {
-                        BodySSBText(usdtFormatAmount(amount: quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
-                    }.padding(.top, 16)
-                }
-            }
-            SendSectionView(t("usdt__maximum_fee")) {
-                BodySSBText(usdtFormatAmount(amount: quote.maximumFee) + " USDT")
-            }
-            .padding(.top, 16)
-            if quote.destination != .arbitrum {
-                SendSectionView(t("usdt__maximum_total")) { BodySSBText(usdtFormatAmount(amount: quote.amount + quote.maximumFee) + " USDT") }
+                    if quote.destination != .arbitrum {
+                        SendSectionView(t(quote.bridgeProvider == .orchestra ? "usdt__expected_amount" : "usdt__recipient_gets")) {
+                            BodySSBText(usdtFormatAmount(amount: quote.receivedAmount) + " USDT")
+                        }.padding(.top, 16)
+                        if quote.bridgeProvider == .orchestra {
+                            SendSectionView(t("usdt__bridge_deducted_fee")) {
+                                BodySSBText(usdtFormatAmount(amount: quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
+                            }.padding(.top, 16)
+                        }
+                    }
+                    SendSectionView(t("usdt__maximum_fee")) {
+                        BodySSBText(usdtFormatAmount(amount: quote.maximumFee) + " USDT")
+                    }
                     .padding(.top, 16)
+                    if quote.destination != .arbitrum {
+                        SendSectionView(t("usdt__maximum_total")) { BodySSBText(usdtFormatAmount(amount: quote.amount + quote.maximumFee) + " USDT") }
+                            .padding(.top, 16)
+                    }
+                    BodySText(t(quote.bridgeProvider == .orchestra ? "usdt__bridge_estimate_note" : "usdt__fee_note"), textColor: .textSecondary)
+                        .padding(
+                            .top,
+                            12
+                        )
+                    if let error { BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError") }
+                }
             }
-            BodySText(t(quote.bridgeProvider == .orchestra ? "usdt__bridge_estimate_note" : "usdt__fee_note"), textColor: .textSecondary).padding(
-                .top,
-                12
-            )
-            if let error { BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError") }
             CustomButton(
                 title: t(showDetails ? "common__hide_details" : "common__show_details"), size: .small,
-                icon: Image(showDetails ? "eye-slash" : "coins").foregroundColor(.greenAccent), background: Color(hex: 0x151515)
+                icon: Image(showDetails ? "eye-slash" : "coins").foregroundColor(.usdtAccent), background: Color(hex: 0x151515)
             ) { showDetails.toggle() }
                 .frame(maxWidth: .infinity).padding(.vertical, 24)
                 .accessibilityIdentifier("UsdtReviewDetails")
             SwipeButton(
-                title: t("wallet__send_swipe"), accentColor: .greenAccent, isDisabled: busy, isLoading: busy, swipeProgress: $swipeProgress
+                title: t("wallet__send_swipe"), accentColor: .usdtAccent, isDisabled: busy, isLoading: busy, swipeProgress: $swipeProgress
             ) {
                 await confirmPayment()
                 if !submitted { throw CancellationError() }
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index 0c4b27adc..dd751b2b5 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -10,6 +10,11 @@ struct UsdtWalletScreen: View {
 
     var body: some View {
         ZStack(alignment: .top) {
+            UsdtCoinIllustration()
+                .scaleEffect(x: -1, y: 1)
+                .frame(maxWidth: .infinity, alignment: .trailing)
+                .offset(x: 97, y: 4)
+                .allowsHitTesting(false)
             ScrollView(showsIndicators: false) {
                 VStack(alignment: .leading, spacing: 32) {
                     UsdtAmountHeader(
@@ -18,18 +23,6 @@ struct UsdtWalletScreen: View {
                     )
                     .balanceVisibilityToggle()
                     .accessibilityIdentifier("UsdtBalance")
-                    HStack(spacing: 16) {
-                        CustomButton(
-                            title: t("usdt__receive"), variant: .secondary,
-                            icon: Image("arrow-down").foregroundColor(.greenAccent), shouldExpand: true
-                        ) { sheets.showSheet(.receive, data: ReceiveConfig(view: .usdt)) }
-                            .accessibilityIdentifier("UsdtReceive")
-                        CustomButton(
-                            title: t("usdt__send"),
-                            icon: Image("arrow-up").foregroundColor(.greenAccent), shouldExpand: true
-                        ) { showSend = true }
-                            .accessibilityIdentifier("UsdtSend")
-                    }
                     if let error = usdt.errorMessage { BodySText(error, textColor: .brandAccent) }
                     activityList
                 }
@@ -37,13 +30,37 @@ struct UsdtWalletScreen: View {
             .contentMargins(.top, ScreenLayout.topPaddingWithoutSafeArea)
             .contentMargins(.bottom, ScreenLayout.bottomPaddingWithSafeArea)
             .refreshable { await usdt.refresh(includeHistory: true) }
-            NavigationBar(title: "USDT")
+            VStack {
+                Spacer()
+                LinearGradient(
+                    colors: [.black.opacity(0), .black],
+                    startPoint: .top,
+                    endPoint: .bottom
+                )
+                .frame(height: ScreenLayout.bottomPaddingWithSafeArea)
+            }
+            .ignoresSafeArea(edges: .bottom)
+            .allowsHitTesting(false)
+            VStack {
+                Spacer()
+                HStack(spacing: 0) {
+                    TabBarButton(title: t("wallet__send"), icon: "arrow-up", variant: .left) { showSend = true }
+                        .accessibilityIdentifier("UsdtSend")
+                    TabBarButton(title: t("wallet__receive"), icon: "arrow-down", variant: .right) {
+                        sheets.showSheet(.receive, data: ReceiveConfig(view: .usdt))
+                    }
+                    .accessibilityIdentifier("UsdtReceive")
+                }
+                .overlay { ScanButton { sheets.showSheet(.scanner) } }
+            }
+            .bottomSafeAreaPadding()
+            NavigationBar(title: "USDT", icon: "tether-circle")
         }
         .padding(.horizontal, 16)
         .navigationBarHidden(true)
         .onReceive(usdt.receivedTxPublisher) { tx in
             guard !showSend, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
-            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount))
+            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount, usdtTransferId: tx.id))
         }
         .sheet(isPresented: $showSend) {
             Sheet(id: .send, data: SendSheetItem()) {
@@ -63,16 +80,10 @@ struct UsdtWalletScreen: View {
 
     private var activityList: some View {
         LazyVStack(alignment: .leading, spacing: 16) {
-            if usdt.transfers.isEmpty {
-                CaptionMText(t("usdt__activity"))
-                RectangleButton(icon: "heartbeat", iconColor: .yellowAccent, title: t("usdt__empty"), testID: "UsdtEmptyActivity") {
-                    sheets.showSheet(.receive, data: ReceiveConfig(view: .usdt))
-                }
-            }
             ForEach(Array(usdt.transfers.enumerated()), id: \.element.id) { index, transfer in
                 let header = transfer.groupTitle
                 if index == 0 || usdt.transfers[index - 1].groupTitle != header {
-                    CaptionMText(header).frame(height: 34, alignment: .bottom)
+                    CaptionMText(header).padding(.top, index == 0 ? 0 : 16)
                 }
                 Button { selectedTransferId = transfer.id } label: {
                     UsdtActivityRow(transfer: transfer, hideBalance: settings.hideBalance)
@@ -85,17 +96,34 @@ struct UsdtWalletScreen: View {
     }
 }
 
+struct UsdtCoinIllustration: View {
+    var body: some View {
+        Image("tether-coin")
+            .resizable().scaledToFill()
+            .frame(width: 304.76, height: 228.57).clipped()
+            .frame(width: 256, height: 256)
+            .accessibilityHidden(true)
+    }
+}
+
 struct UsdtAmountHeader: View {
     let amount: String
     let network: String
     var prefix = ""
     var hideBalance = false
 
+    @EnvironmentObject private var currency: CurrencyViewModel
+
     var body: some View {
         VStack(alignment: .leading, spacing: 16) {
-            CaptionMText("USDT · " + network, textColor: .textSecondary)
+            if let sats = usdtDisplaySats(amount: amount, rate: currency.paykitRate) {
+                MoneyText(sats: sats, forceUnit: .bitcoin, size: .caption, symbol: true,
+                          enableHide: hideBalance, color: .textSecondary)
+            } else {
+                CaptionMText("USDT · " + network, textColor: .textSecondary)
+            }
             DisplayText(
-                "<accent>\(prefix)₮</accent> " + (hideBalance ? " • • • • •" : amount),
+                "<accent>\(prefix)$</accent> " + (hideBalance ? " • • • • •" : amount),
                 accentColor: .textSecondary, accentFont: Fonts.extraBold
             )
             .lineLimit(1).minimumScaleFactor(0.5)
@@ -134,3 +162,18 @@ extension UsdtTransferStatus {
         }
     }
 }
+
+func usdtDisplaySats(amount: String, rate: PaykitExchangeRate?, now: Date = Date()) -> Int? {
+    guard let dollars = Decimal(string: amount, locale: Locale(identifier: "en_US_POSIX")),
+          dollars >= 0, let price = try? rate?.value(at: now), price > 0 else { return nil }
+    var value = dollars / price * 100_000_000
+    var rounded = Decimal()
+    NSDecimalRound(&rounded, &value, 0, .down)
+    guard rounded <= Decimal(Int.max) else { return nil }
+    return NSDecimalNumber(decimal: rounded).intValue
+}
+
+func usdtOverviewAmount(_ amount: UInt64) -> String {
+    if amount > 0, amount < 10000 { return "<0.01" }
+    return (Decimal(amount) / 1_000_000).formatted(.number.precision(.fractionLength(0 ... 2)))
+}
diff --git a/BitkitTests/UsdtDisplayTests.swift b/BitkitTests/UsdtDisplayTests.swift
new file mode 100644
index 000000000..97191cb6d
--- /dev/null
+++ b/BitkitTests/UsdtDisplayTests.swift
@@ -0,0 +1,22 @@
+@testable import Bitkit
+import Foundation
+import XCTest
+
+final class UsdtDisplayTests: XCTestCase {
+    func testBitcoinEquivalentRequiresFreshRateAndFitsDisplayBounds() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let rate = PaykitExchangeRate(price: "100000", timestamp: now)
+        XCTAssertEqual(usdtDisplaySats(amount: "3.5", rate: rate, now: now), 3500)
+        XCTAssertEqual(usdtDisplaySats(amount: "0.000001", rate: rate, now: now), 0)
+        XCTAssertNil(usdtDisplaySats(amount: "3.5", rate: nil, now: now))
+        XCTAssertNil(usdtDisplaySats(amount: "3.5", rate: PaykitExchangeRate(price: "100000", timestamp: now.addingTimeInterval(-601)), now: now))
+        XCTAssertNil(usdtDisplaySats(amount: "-1", rate: rate, now: now))
+        XCTAssertNil(usdtDisplaySats(amount: "999999999999999999999999", rate: rate, now: now))
+    }
+
+    func testSmallNonzeroBalancesRemainVisible() {
+        XCTAssertEqual(usdtOverviewAmount(0), "0")
+        XCTAssertEqual(usdtOverviewAmount(1), "<0.01")
+        XCTAssertEqual(usdtOverviewAmount(9999), "<0.01")
+    }
+}
diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index d6e896ce5..83290690c 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -38,8 +38,8 @@ Requires a wallet with USDT enabled and a matching backend with Orchestra creden
 - [ ] Return to Arbitrum One and verify its original wallet address remains unchanged.
 - [ ] Open cross-network deposit activity. Verify empty history and Load more work without showing a failure.
 - [ ] Enter an amount below the route minimum and verify the limit error appears without a deposit address.
-- [ ] Edit the amount. Verify the old limit error clears immediately, one short fee hint is shown above the keypad divider, and the keypad and button remain fully visible. Get an address with an amount within the route limits.
-- [ ] With a separately authorized source deposit, verify pending progress becomes completed only after destination delivery, and that the green receive celebration, normal USDT activity and main-screen balance independently show the Arbitrum receipt. Record the complete flow.
+- [ ] Edit the amount. Verify the old limit error clears immediately and the keypad and button remain fully visible. Get an address with an amount within the route limits.
+- [ ] With a separately authorized source deposit, verify pending progress becomes completed only after destination delivery, and that the teal receive celebration, normal USDT activity and main-screen balance independently show the Arbitrum receipt. Record the complete flow.
 - [ ] Reopen the app and verify the reusable address and deposit history are recovered. Inspect source and destination transaction IDs in the details.
 - [ ] For a provider-held deposit, verify refund-address entry, explicit review and payment authentication. Do not submit a live refund without authorization. Unknown assets require support. For a completed refund, verify the refund transaction is shown and no delivery is claimed.
 
@@ -68,3 +68,14 @@ Requires funded Arbitrum accounts, controlled billing time, and controlled recei
 - [ ] Using a controlled billing clock, advance to the next installment with the requester offline. Verify its USD amount still maps exactly to USDT, the fee remains additional, and earlier paid periods remain unchanged.
 - [ ] Using controlled payment evidence, verify underpayment and payment after expiry show actual received funds and the corresponding status, without reporting the transfer as failed.
 - [ ] Pay a contact directly without a request and verify the normal asset selector, send review and activity attribution still work. Verify selecting USDT does not request camera access for an already resolved recipient.
+
+## USDT design and receive estimates
+
+Reference: [USDT designs](https://www.figma.com/design/ltqvnKiejWj0JQiqtDf2JJ/Bitkit-Wallet?node-id=48063-274766).
+
+- [ ] Check funded and empty Home and USDT wallet layouts; the USDT accent is #009393 throughout receive, send, Paykit, sharing and celebrations.
+- [ ] In Receive, open Network and select an enabled source. Verify the minimum-amount error is compact and clears on editing.
+- [ ] Enter an accepted amount, switch BTC/USD twice and verify the amount is preserved. Continue and verify Estimated Fees shows the expected deduction and received amount, then continues to the QR for that network.
+- [ ] Open address details, verify Copy and QR target the same address, and return to the QR.
+- [ ] Back out of an unprepared network and verify the displayed network always matches the QR. Return to Arbitrum and verify its original wallet address.
+- [ ] With an authorized incoming transfer or an explicitly identified fixture, verify teal receive confetti, Details and OK; Details opens that transfer.
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index b93cef431..126a0ce4f 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -3,9 +3,9 @@
   <actions>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
-    <action>On the payer, open the request. Verify Amount shows exactly 1 USDT, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing.</action>
+    <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
-    <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its amount, recurrence and payment method; close before subscribing.</action>
+    <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method; close before subscribing.</action>
     <action>Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
index 81167be69..71eff70a7 100644
--- a/journeys/usdt-bridge-support.xml
+++ b/journeys/usdt-bridge-support.xml
@@ -5,7 +5,7 @@
     <action>Verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting.</action>
-    <action>Open USDT Receive and Cross-network Deposits, then open a deposit.</action>
+    <action>Open USDT Receive, then Network and Deposit Activity, and open a deposit.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard includes the deposit reference, source network and source transaction, plus the current status and any destination or refund transaction.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the receive sheet closes and the report form opens with the deposit details prefilled. Return without submitting or requesting a refund.</action>
   </actions>
diff --git a/journeys/usdt-receive-amount-and-units.xml b/journeys/usdt-receive-amount-and-units.xml
new file mode 100644
index 000000000..ce25c5905
--- /dev/null
+++ b/journeys/usdt-receive-amount-and-units.xml
@@ -0,0 +1,13 @@
+<journey name="usdt receive amount and units">
+  <description>Use an onboarded wallet with USDT configured and a fresh BTC/USD rate. No payment is submitted. Cross-network estimates require a live enabled provider and are covered by the manual USDT checks.</description>
+  <actions>
+    <action>Open USDT from Home. Verify the USDT balance, teal Tether icon and existing activity rows.</action>
+    <action>Open Receive. Verify Receive Dollars, the USDT tab and Network: Arbitrum One.</action>
+    <action>Tap Edit. Enter 3.5 in USD mode. Verify the dollar amount and BTC equivalent are displayed. Check that the unit toggle stays near the amount, the keypad follows the divider, and Continue stays at the bottom without overlap.</action>
+    <action>Tap the unit toggle (id "ReceiveNumberPadUnit"). Verify BTC input and the USD equivalent. Toggle back and verify the USD amount is still exactly 3.5.</action>
+    <action>Continue to the QR. Verify it requests the Arbitrum USDT token, the wallet address and uint256=3500000, never Bitcoin.</action>
+    <action>Open Show Details. Verify the same Arbitrum address and teal Copy control. Return to the QR.</action>
+    <action>Select Savings. Verify Receive Bitcoin and a Bitcoin QR. Select USDT and verify Receive Dollars and the Arbitrum USDT QR.</action>
+    <action>Close Receive and return Home. Open a USDT activity row, then Show All. Verify USDT details and mixed activity remain reachable.</action>
+  </actions>
+</journey>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index da33097fb..a6511a552 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -1,10 +1,12 @@
 <journey name="usdt wallet navigation">
   <description>Use an onboarded wallet in an E2E build with USDT RPC and bundler URLs configured. No chain funding or live provider is required. A network error may be visible when services are offline; no payment is submitted.</description>
   <actions>
-    <action>Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet.</action>
+    <action>On Home, verify the Savings/Spending and USDT balance dividers align vertically, including any hardware wallet rows.</action>
+    <action>Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet, with its Tether coin illustration anchored at the upper right.</action>
     <action>Open Receive. Verify the address starts with 0x and the network is Arbitrum One. Open details and verify Copy and the QR show the same address.</action>
     <action>Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing.</action>
     <action>Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote.</action>
+    <action>Set an amount and note in Bitcoin Receive, then close it. Open a fresh USDT Receive sheet and switch to Savings and Spending. Verify the new Bitcoin QR has no previous amount or note, and hardware-wallet receive remains available when paired.</action>
     <action>Return Home and open Bitcoin Receive. Verify the Bitcoin address, network and amount controls remain separate from USDT.</action>
   </actions>
 </journey>

From 949200981ae474da66153c7992082d1b45c55edc Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 7 Oct 2026 17:44:22 -0500
Subject: [PATCH 07/62] fix: align paykit pricing with selected payment methods

---
 Bitkit/Models/PaykitRequestPricing.swift      | 43 ++++++-----
 .../Localization/en.lproj/Localizable.strings |  2 +
 .../PaykitPaymentRequestService.swift         | 26 +++++--
 .../Services/PaykitUsdtPaymentService.swift   | 10 ++-
 Bitkit/ViewModels/AppViewModel.swift          | 29 ++++++-
 .../PaymentRequests/PaymentRequestsView.swift |  1 +
 .../Views/Wallets/Send/LnurlPayConfirm.swift  | 11 ++-
 .../Views/Wallets/Send/SendAmountView.swift   | 19 ++---
 .../Wallets/Send/SendConfirmationView.swift   | 23 +++++-
 Bitkit/Views/Wallets/Send/SendSheet.swift     | 22 +++++-
 .../PaykitPaymentRequestServiceTests.swift    | 50 +++++++++----
 BitkitTests/PaykitRequestPricingTests.swift   | 75 +++++++++++++++----
 journeys/paykit-quoted-usdt.xml               |  4 +-
 13 files changed, 231 insertions(+), 84 deletions(-)

diff --git a/Bitkit/Models/PaykitRequestPricing.swift b/Bitkit/Models/PaykitRequestPricing.swift
index 908b97a24..a67d2a2a1 100644
--- a/Bitkit/Models/PaykitRequestPricing.swift
+++ b/Bitkit/Models/PaykitRequestPricing.swift
@@ -20,42 +20,45 @@ struct PaykitRequestPricing: Hashable {
 
     func payment(
         requested: PaykitAmount,
-        asset: PaykitAsset,
+        endpoint: String,
         period: PaykitBillingPeriod?,
         at date: Date,
         quoteId: String? = nil
     ) throws -> Payment {
+        let parts = endpoint.split(separator: "-", omittingEmptySubsequences: false)
+        guard parts.count == 3, parts.allSatisfy({ !$0.isEmpty && $0.allSatisfy { $0.isASCII && ($0.isLowercase || $0.isNumber) } }),
+              let asset = PaykitAsset(rawValue: String(parts[0]))
+        else { throw PaykitAmountError.invalidAmount }
         let deadline = try paymentDeadline(period: period)
-        if requested.asset == asset {
-            guard quoteId == nil else { throw PaykitAmountError.invalidAmount }
-            return Payment(amount: requested, quoteId: nil, validFrom: nil, expiresAt: deadline)
-        }
-        let rates: [Paykit.ConversionRate]
+        var rates: [Paykit.ConversionRate] = []
         var selected: Paykit.PaymentConversionQuoteRecord?
         switch conversion {
         case let .fixed(values):
             guard quoteId == nil else { throw PaykitAmountError.invalidAmount }
             rates = values
         case .perPeriod:
-            guard let period else { throw PaykitAmountError.invalidAmount }
-            selected = quotes.last { quote in
-                guard let quotedPeriod = PaykitBillingPeriod(sdkPeriod: quote.billingPeriod), quotedPeriod == period else { return false }
-                if let quoteId { return quote.eventId == quoteId }
-                guard let start = PaykitPaymentRequest.parseDate(quote.validFrom),
-                      let end = PaykitPaymentRequest.parseDate(quote.expiresAt)
-                else { return false }
-                return date >= start && date <= end
+            if requested.asset != asset || quoteId != nil {
+                guard let period else { throw PaykitAmountError.invalidAmount }
+                selected = quotes.last { quote in
+                    guard let quotedPeriod = PaykitBillingPeriod(sdkPeriod: quote.billingPeriod), quotedPeriod == period else { return false }
+                    if let quoteId { return quote.eventId == quoteId }
+                    guard let start = PaykitPaymentRequest.parseDate(quote.validFrom),
+                          let end = PaykitPaymentRequest.parseDate(quote.expiresAt)
+                    else { return false }
+                    return date >= start && date <= end
+                }
+                guard let selected else { throw PaykitAmountError.rateUnavailable }
+                if requested.asset != asset { rates = selected.rates }
             }
-            guard let selected else { throw PaykitAmountError.rateUnavailable }
-            rates = selected.rates
         case nil:
-            // External requests without rates can only be paid in their denominating asset.
-            throw PaykitAmountError.rateUnavailable
+            guard quoteId == nil else { throw PaykitAmountError.invalidAmount }
         }
-        guard let rate = rates.first(where: { $0.asset == asset.rawValue }) else { throw PaykitAmountError.rateUnavailable }
+        let selector = parts.prefix(2).joined(separator: "-")
+        let rate = rates.first(where: { $0.asset == selector }) ?? rates.first(where: { $0.asset == asset.rawValue })
+        guard rate != nil || requested.asset == asset else { throw PaykitAmountError.rateUnavailable }
         let quoteExpiry = selected.flatMap { PaykitPaymentRequest.parseDate($0.expiresAt) }
         return try Payment(
-            amount: requested.quoted(to: asset, multiplier: rate.value),
+            amount: requested.quoted(to: asset, multiplier: rate?.value ?? "1"),
             quoteId: selected?.eventId,
             validFrom: selected.flatMap { PaykitPaymentRequest.parseDate($0.validFrom) },
             expiresAt: [deadline, quoteExpiry].compactMap { $0 }.min()
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 6f1b1a886..c00640b83 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1938,3 +1938,5 @@
 
 "usdt__deposit_minimum" = "Minimum amount is {amount}";
 "usdt__deposit_maximum" = "Maximum amount is {amount}";
+
+"wallet__payment_request_requested_amount" = "Requested amount";
diff --git a/Bitkit/Services/PaykitPaymentRequestService.swift b/Bitkit/Services/PaykitPaymentRequestService.swift
index 99ba2a1fc..7a1437862 100644
--- a/Bitkit/Services/PaykitPaymentRequestService.swift
+++ b/Bitkit/Services/PaykitPaymentRequestService.swift
@@ -364,31 +364,41 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         }
     }
 
-    func payment(to asset: PaykitAsset, at date: Date = Date(), quoteId: String? = nil) throws -> PaykitRequestPricing.Payment {
-        try pricing.payment(requested: amount, asset: asset, period: billingPeriod, at: date, quoteId: quoteId)
+    func payment(using method: PublicPaykitService.MethodId, at date: Date = Date(), quoteId: String? = nil) throws -> PaykitRequestPricing.Payment {
+        try pricing.payment(requested: amount, endpoint: method.rawValue, period: billingPeriod, at: date, quoteId: quoteId)
     }
 
     func acceptsLightningInvoiceAmount(milliSatoshis: UInt64?, paymentTerms: PaykitRequestPricing.Payment? = nil, at date: Date = Date()) -> Bool {
         guard let milliSatoshis else { return true }
-        guard let payment = try? payment(to: .btc, at: date, quoteId: paymentTerms?.quoteId),
+        guard let payment = try? payment(using: .bitcoinLightningBolt11, at: date, quoteId: paymentTerms?.quoteId),
               paymentTerms == nil || paymentTerms == payment, payment.isValid(at: date) else { return false }
         let (required, overflow) = payment.amount.atomic.multipliedReportingOverflow(by: 1000)
         return !overflow && milliSatoshis == required
     }
 
     func acceptsLightningInvoiceAmount(satoshis: UInt64) -> Bool {
-        satoshis == 0 || acceptsPaymentAmount(satoshis)
+        satoshis == 0 || acceptsPaymentAmount(satoshis, method: .bitcoinLightningBolt11)
     }
 
-    func acceptsPaymentAmount(_ amountSats: UInt64, paymentTerms: PaykitRequestPricing.Payment? = nil, at date: Date = Date()) -> Bool {
-        guard let payment = try? payment(to: .btc, at: date, quoteId: paymentTerms?.quoteId),
+    func acceptsPaymentAmount(
+        _ amountSats: UInt64,
+        method: PublicPaykitService.MethodId,
+        paymentTerms: PaykitRequestPricing.Payment? = nil,
+        at date: Date = Date()
+    ) -> Bool {
+        guard let payment = try? payment(using: method, at: date, quoteId: paymentTerms?.quoteId),
               paymentTerms == nil || paymentTerms == payment, payment.isValid(at: date) else { return false }
         return payment.amount.atomic == amountSats
     }
 
-    func acceptsPayment(_ amount: PaykitAmount, paymentTerms: PaykitRequestPricing.Payment?, at date: Date = Date()) -> Bool {
+    func acceptsPayment(
+        _ amount: PaykitAmount,
+        method: PublicPaykitService.MethodId,
+        paymentTerms: PaykitRequestPricing.Payment?,
+        at date: Date = Date()
+    ) -> Bool {
         guard let paymentTerms, paymentTerms.amount == amount, paymentTerms.isValid(at: date),
-              let current = try? payment(to: amount.asset, at: date, quoteId: paymentTerms.quoteId)
+              let current = try? payment(using: method, at: date, quoteId: paymentTerms.quoteId)
         else { return false }
         return current == paymentTerms
     }
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
index ccb56f2c3..c06186a4a 100644
--- a/Bitkit/Services/PaykitUsdtPaymentService.swift
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -123,7 +123,11 @@ final class PaykitUsdtPaymentService {
                     try Task.checkCancellation()
                     if let request = context.incomingPaymentRequest {
                         guard !request.isExpired(at: Date()),
-                              request.acceptsPayment(PaykitAmount(asset: .usdt, atomic: quote.amount), paymentTerms: paymentTerms)
+                              request.acceptsPayment(
+                                  PaykitAmount(asset: .usdt, atomic: quote.amount),
+                                  method: .usdtArbitrum,
+                                  paymentTerms: paymentTerms
+                              )
                         else { throw PaykitPaymentRequestError.amountMismatch }
                     }
                 } catch {
@@ -262,7 +266,7 @@ final class PaykitUsdtPaymentService {
         if let request {
             guard request.acceptedPaymentEndpointIdentifiers.contains(PublicPaykitService.MethodId.usdtArbitrum.rawValue),
                   !request.isExpired(at: Date()),
-                  request.acceptsPayment(payment, paymentTerms: paymentTerms)
+                  request.acceptsPayment(payment, method: .usdtArbitrum, paymentTerms: paymentTerms)
             else { throw PaykitPaymentRequestError.amountMismatch }
         }
         let owner = wallet.address.lowercased()
@@ -385,7 +389,7 @@ final class PaykitUsdtPaymentService {
                             $0.wallet == owner && $0.paymentId == payment.paymentId && ($0.identity != identity || $0.requestId != request.id)
                         }) else { continue }
                         let receivedAt = Date(timeIntervalSince1970: TimeInterval(payment.timestamp))
-                        let terms = try request.payment(to: .usdt, at: receivedAt, quoteId: submission.conversionQuoteId)
+                        let terms = try request.payment(using: .usdtArbitrum, at: receivedAt, quoteId: submission.conversionQuoteId)
                         let received = PaykitAmount(asset: .usdt, atomic: payment.amount)
                         current.receipts.removeAll { $0.wallet == owner && $0.identity == identity && $0.paymentId == payment.paymentId }
                         current.receipts.append(Receipt(wallet: owner, identity: identity, requestId: request.id,
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index c5e127b30..8db47411b 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -33,7 +33,8 @@ struct ContactPaymentContext: Equatable {
     let endpoints: [PublicPaykitService.Endpoint]
 
     var requiresAssetSelection: Bool {
-        endpoints.contains { $0.methodId == .usdtArbitrum } || incomingPaymentRequest.map { $0.amount.asset != .btc } == true
+        endpoints.contains { $0.methodId == .usdtArbitrum } ||
+            incomingPaymentRequest.map { $0.amount.asset != .btc || $0.pricing.conversion != nil } == true
     }
 
     func prefersUsdt(onchainBalanceSats: UInt64) -> Bool {
@@ -611,6 +612,20 @@ extension AppViewModel {
     }
 }
 
+extension AppViewModel {
+    var paykitPaymentMethod: PublicPaykitService.MethodId {
+        if paykitUsesUsdt { return .usdtArbitrum }
+        return paykitBitcoinMethod(for: selectedWalletToPayFrom)
+    }
+
+    func paykitBitcoinMethod(for wallet: WalletType) -> PublicPaykitService.MethodId {
+        if wallet == .lightning {
+            return lnurlPayData != nil ? .bitcoinLightningLnurl : .bitcoinLightningBolt11
+        }
+        return PublicPaykitService.onchainMethodId(for: scannedOnchainInvoice?.address ?? "")
+    }
+}
+
 // MARK: Scanning/pasting handling
 
 extension AppViewModel {
@@ -736,7 +751,6 @@ extension AppViewModel {
             data = try await decode(invoice: uri)
             try ensureScannedDataHandlingOwnership(handlingId, claimedContactPaymentContext: claimedContactPaymentContext)
         }
-        let requestedAmount = try contactPaymentContext?.incomingPaymentRequest?.payment(to: .btc, at: Date()).amount.atomic
         let paymentState = scanPaymentOperations.state()
 
         if scope == .onchainPayments {
@@ -746,6 +760,9 @@ extension AppViewModel {
         switch data {
         // BIP21 (Unified) invoice handling
         case let .onChain(invoice):
+            let requestedAmount = try contactPaymentContext?.incomingPaymentRequest?.payment(
+                using: PublicPaykitService.onchainMethodId(for: invoice.address)
+            ).amount.atomic
             // Check network first - treat wrong network as decoding error
             let addressValidation = try? validateBitcoinAddress(address: invoice.address)
             let addressNetwork: LDKNode.Network? = addressValidation.map { NetworkValidationHelper.convertNetworkType($0.network) }
@@ -777,7 +794,10 @@ extension AppViewModel {
                         if nodeIsRunning {
                             // Node is running → we have fresh balances; validate immediately.
                             // Prefer lightning; if insufficient or no channels/capacity, fall back to onchain.
-                            let canSendLightning = scanPaymentOperations.canSendLightning(requestedAmount ?? lightningInvoice.amountSatoshis)
+                            let canSendLightning = try scanPaymentOperations.canSendLightning(
+                                contactPaymentContext?.incomingPaymentRequest?.payment(using: .bitcoinLightningBolt11).amount.atomic ??
+                                    lightningInvoice.amountSatoshis
+                            )
 
                             if canSendLightning {
                                 handleScannedLightningInvoice(lightningInvoice, bolt11: lnInvoice, onchainInvoice: invoice)
@@ -841,6 +861,7 @@ extension AppViewModel {
 
             handleScannedOnchainInvoice(invoice)
         case let .lightning(invoice):
+            let requestedAmount = try contactPaymentContext?.incomingPaymentRequest?.payment(using: .bitcoinLightningBolt11).amount.atomic
             // Check network first - treat wrong network as decoding error
             let invoiceNetwork = NetworkValidationHelper.convertNetworkType(invoice.networkType)
             if NetworkValidationHelper.isNetworkMismatch(addressNetwork: invoiceNetwork, currentNetwork: Env.network) {
@@ -994,7 +1015,7 @@ extension AppViewModel {
     }
 
     func handleLnurlPayInvoice(_ data: LnurlPayData) throws {
-        let requestedAmount = try contactPaymentContext?.incomingPaymentRequest?.payment(to: .btc, at: Date()).amount.atomic
+        let requestedAmount = try contactPaymentContext?.incomingPaymentRequest?.payment(using: .bitcoinLightningLnurl, at: Date()).amount.atomic
         if let requestedAmount,
            requestedAmount < data.minSendableSat || requestedAmount > data.maxSendableSat
         {
diff --git a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
index 53b24790a..5887735f1 100644
--- a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
+++ b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
@@ -587,6 +587,7 @@ struct PaymentRequestDetailView: View {
         let paymentDirection = PaymentRequestDisplay.paymentDirection(for: request)
 
         return VStack(alignment: .leading, spacing: 8) {
+            CaptionMText(t("wallet__payment_request_requested_amount"), textColor: .white64)
             if request.amount.asset == .btc {
                 MoneyText(sats: Int(clamping: request.amount.atomic), unitType: .secondary, size: .caption,
                           symbol: true, color: .white64)
diff --git a/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift b/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
index 1819d768d..f956e46b4 100644
--- a/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
+++ b/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
@@ -41,12 +41,17 @@ struct LnurlPayConfirm: View {
         return try await send()
     }
 
+    private var shouldAutomaticallyPay: Bool {
+        app.contactPaymentContext?.isInitialSubscriptionPayment == true &&
+            app.contactPaymentContext?.incomingPaymentRequest?.pricing.conversion == nil
+    }
+
     var body: some View {
         ZStack {
             if let lnurlPayData = app.lnurlPayData {
                 confirmationContent(lnurlPayData: lnurlPayData)
             }
-            if app.contactPaymentContext?.isInitialSubscriptionPayment == true {
+            if shouldAutomaticallyPay {
                 InitialSubscriptionPaymentProgress()
             }
         }
@@ -178,7 +183,7 @@ struct LnurlPayConfirm: View {
     @MainActor
     private func startAutomaticPaymentIfNeeded() async {
         guard let lnurlPayData = app.lnurlPayData,
-              app.contactPaymentContext?.isInitialSubscriptionPayment == true,
+              shouldAutomaticallyPay,
               !hasStartedAutomaticPayment
         else { return }
         hasStartedAutomaticPayment = true
@@ -398,7 +403,7 @@ struct LnurlPayConfirm: View {
         }
         guard app.ownsContactPaymentContext(context) else { throw PaykitPaymentRequestError.requestUnavailable }
         guard let amountSats = wallet.sendAmountSats,
-              request.acceptsPaymentAmount(amountSats, paymentTerms: app.paykitPaymentTerms),
+              request.acceptsPaymentAmount(amountSats, method: .bitcoinLightningLnurl, paymentTerms: app.paykitPaymentTerms),
               request.acceptsLightningInvoiceAmount(milliSatoshis: amountMsats, paymentTerms: app.paykitPaymentTerms)
         else {
             throw PaykitPaymentRequestError.amountMismatch
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index 0294b73d1..73c57e8e8 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -304,8 +304,7 @@ struct SendAmountView: View {
 
         do {
             if let request = app.contactPaymentContext?.incomingPaymentRequest {
-                let asset: PaykitAsset = app.paykitUsesUsdt ? .usdt : .btc
-                let terms = try request.payment(to: asset)
+                let terms = try request.payment(using: app.paykitPaymentMethod)
                 guard terms.isValid(at: Date()) else { throw PaykitPaymentRequestError.requestExpired }
                 let expected = terms.amount
                 let entered = app.paykitUsesUsdt ? try PaykitAmount(asset: .usdt, value: usdtAmount) : PaykitAmount(asset: .btc, atomic: amountSats)
@@ -414,16 +413,18 @@ struct SendAmountView: View {
 
     private func selectFundingSource(_ source: SendFundingSource) {
         let target: PaykitAsset = source == .usdt ? .usdt : .btc
-        if app.paykitUsesUsdt != (source == .usdt) {
+        if app.contactPaymentContext?.incomingPaymentRequest != nil || app.paykitUsesUsdt != (source == .usdt) {
             do {
                 let value = app.contactPaymentContext?.incomingPaymentRequest?.amount ??
                     (app.paykitUsesUsdt ? (try? PaykitAmount(asset: .usdt, value: usdtAmount)) : PaykitAmount(asset: .btc, atomic: amountSats))
                 if let value, value.atomic > 0 {
-                    let converted = try app.contactPaymentContext?.incomingPaymentRequest?.payment(to: target).amount ?? value.converted(
-                        to: target,
-                        rate: currency.paykitRate,
-                        at: Date()
-                    )
+                    let converted = try app.contactPaymentContext?.incomingPaymentRequest?
+                        .payment(using: source == .usdt ? .usdtArbitrum : app.paykitBitcoinMethod(for: source == .spending ? .lightning : .onchain))
+                        .amount ?? value.converted(
+                            to: target,
+                            rate: currency.paykitRate,
+                            at: Date()
+                        )
                     if target == .usdt { usdtAmount = converted.value }
                     else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
                 }
@@ -460,7 +461,7 @@ struct SendAmountView: View {
         let request = paymentRequests.pendingRequests.first { $0.id == original.id } ?? original
         if request != original { app.contactPaymentContext?.incomingPaymentRequest = request }
         do {
-            let terms = try request.payment(to: app.paykitUsesUsdt ? .usdt : .btc)
+            let terms = try request.payment(using: app.paykitPaymentMethod)
             guard terms.isValid(at: Date()) else { throw PaykitPaymentRequestError.requestExpired }
             let converted = terms.amount
             if app.paykitUsesUsdt { usdtAmount = converted.value }
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index 727ffedb3..2ec52395f 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -221,7 +221,7 @@ struct SendConfirmationView: View {
     private var shouldAutomaticallyPay: Bool {
         retainedHardwareRetry == nil && preparingRequest == nil && app.contactPaymentContext?.isInitialSubscriptionPayment == true && app
             .selectedWalletToPayFrom == .lightning &&
-            !hwSend.isActive && !requiresPaymentConfirmation
+            !hwSend.isActive && !requiresPaymentConfirmation && app.contactPaymentContext?.incomingPaymentRequest?.pricing.conversion == nil
     }
 
     static func acceptedOnchainRoute(
@@ -267,6 +267,8 @@ struct SendConfirmationView: View {
 
             VStack(alignment: .leading, spacing: 0) {
                 if let preparingRequest {
+                    CaptionMText(t("wallet__payment_request_requested_amount"), textColor: .white64)
+                        .padding(.bottom, 8)
                     if preparingRequest.amount.asset == .btc {
                         MoneyStack(sats: Int(clamping: preparingRequest.amount.atomic), showSymbol: true, testIdPrefix: "ReviewAmount")
                     } else {
@@ -366,7 +368,7 @@ struct SendConfirmationView: View {
             if presentationID == nil {
                 presentationID = sheets.activeSheetConfiguration?.presentationID
             }
-            guard preparingRequest == nil else { return }
+            guard preparingRequest == nil, !returnToAmountReviewIfNeeded() else { return }
             ensureSendAmountFromScannedInvoicesIfNeeded()
             if app.contactPaymentContext?.isInitialSubscriptionPayment == true, !shouldAutomaticallyPay {
                 requiresPaymentConfirmation = true
@@ -390,6 +392,7 @@ struct SendConfirmationView: View {
             }
         }
         .onChange(of: app.selectedWalletToPayFrom) {
+            guard preparingRequest == nil, !returnToAmountReviewIfNeeded() else { return }
             walletSwitchContext = sendContext
         }
         .onChange(of: sendContext) { _, context in
@@ -1436,7 +1439,9 @@ struct SendConfirmationView: View {
             wallet.sendAmountSats ?? app.scannedOnchainInvoice?.amountSatoshis
         }
 
-        guard let paymentAmount, request.acceptsPaymentAmount(paymentAmount, paymentTerms: app.paykitPaymentTerms) else {
+        guard let paymentAmount,
+              request.acceptsPaymentAmount(paymentAmount, method: app.paykitPaymentMethod, paymentTerms: app.paykitPaymentTerms)
+        else {
             throw PaykitPaymentRequestError.amountMismatch
         }
         guard app.selectedWalletToPayFrom == .lightning else { return }
@@ -1619,6 +1624,18 @@ struct SendConfirmationView: View {
         }
     }
 
+    private func returnToAmountReviewIfNeeded() -> Bool {
+        guard let request = app.contactPaymentContext?.incomingPaymentRequest, request.pricing.conversion != nil else { return false }
+        let terms = try? request.payment(using: app.paykitPaymentMethod, quoteId: app.paykitPaymentTerms?.quoteId)
+        guard let terms, terms == app.paykitPaymentTerms, terms.isValid(at: Date()) else {
+            app.paykitPaymentTerms = nil
+            app.paykitReviewedAmount = nil
+            navigationPath = [.amount]
+            return true
+        }
+        return false
+    }
+
     private func navigateToAmount() {
         guard canEditAmount else { return }
 
diff --git a/Bitkit/Views/Wallets/Send/SendSheet.swift b/Bitkit/Views/Wallets/Send/SendSheet.swift
index 0eec53eb1..2816be96d 100644
--- a/Bitkit/Views/Wallets/Send/SendSheet.swift
+++ b/Bitkit/Views/Wallets/Send/SendSheet.swift
@@ -372,7 +372,7 @@ struct SendSheet: View {
             if PaykitSubscriptionNotificationTargetStore.load()?.matches(request) == true {
                 PaykitSubscriptionNotificationTargetStore.clear()
             }
-            wallet.sendAmountSats = request.amount.asset == .btc ? request.amount.atomic : nil
+            wallet.sendAmountSats = try? request.payment(using: app.paykitPaymentMethod).amount.atomic
             incomingPaymentRequest = request
         } else {
             tagManager.clearSelectedTags()
@@ -416,7 +416,7 @@ struct SendSheet: View {
             }
             if let request = incomingPaymentRequest, app.contactPaymentContext?.requiresAssetSelection != true {
                 guard isCurrentIncomingRequest(request.id) else { return }
-                guard let amount = try? request.payment(to: .btc).amount.atomic,
+                guard let amount = try? request.payment(using: app.paykitPaymentMethod).amount.atomic,
                       await selectHardwareFundingSourceIfNeeded(amountSats: amount, requestId: request.id) else { return }
                 guard isCurrentIncomingRequest(request.id) else { return }
                 if !shouldShowSyncOverlay {
@@ -560,7 +560,13 @@ struct SendSheet: View {
             // Original signed bytes only; new-payment balance admission does not apply.
             return .ready
         }
-        let requestedAmount = app.contactPaymentContext?.incomingPaymentRequest?.amountSats
+        if app.contactPaymentContext?.endpoints.isEmpty == false { hasValidatedAfterSync = true; return .ready }
+        let request = app.contactPaymentContext?.incomingPaymentRequest
+        let requestedAmount = try? request?.payment(using: app.paykitPaymentMethod, at: Date()).amount.atomic
+        if request != nil && requestedAmount == nil {
+            app.toast(PaykitAmountError.rateUnavailable)
+            return .failed
+        }
 
         if let lnurlPayData = app.lnurlPayData, let requestedAmount {
             let minimumAmount = max(1, lnurlPayData.minSendableSat)
@@ -620,13 +626,17 @@ struct SendSheet: View {
                     app.scannedOnchainInvoice = onchainInvoice
                     app.scannedLightningInvoice = nil
 
+                    let onchainAmount = try? request?.payment(using: app.paykitPaymentMethod).amount.atomic
+                    if request != nil && onchainAmount == nil { return .failed }
+                    if let onchainAmount { wallet.sendAmountSats = onchainAmount }
+
                     // Validate onchain balance BEFORE navigating
                     let onchainBalance = max(
                         LightningService.shared.balances?.spendableOnchainBalanceSats ?? 0,
                         hwWalletManager.maximumFundingBalanceSats
                     )
                     guard validateOnchainBalanceAndDismissIfInsufficient(
-                        invoiceAmount: requestedAmount ?? onchainInvoice.amountSatoshis,
+                        invoiceAmount: onchainAmount ?? onchainInvoice.amountSatoshis,
                         onchainBalance: onchainBalance
                     ) else {
                         hasValidatedAfterSync = true
@@ -1006,6 +1016,10 @@ struct SendSheet: View {
         let previousVersion = await PrivatePaykitService.shared.consumedPaymentListVersion(publicKey: request.counterparty, attemptId: context?.id)
         do {
             try await prepareIncomingPaymentRequest(context: context)
+            guard context.map(app.ownsContactPaymentContext) == true, !request.isExpired(at: Date()),
+                  paymentTerms != nil || request.amount.asset == .btc,
+                  request.acceptsPaymentAmount(signedTx.totalSpentSats - signedTx.miningFeeSats, method: PublicPaykitService.onchainMethodId(for: address), paymentTerms: paymentTerms)
+            else { throw PaykitPaymentRequestError.amountMismatch }
             try await PaykitPaymentProofService.shared.markOnchainPaymentStarted(
                 request, address: address, hardwareWalletId: walletId, paymentIdentity: paymentIdentity,
                 signedTx: signedTx, privatePaymentListVersion: privateContext.paymentListVersion,
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index 6843106f7..c17cbc24d 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -2241,7 +2241,12 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 XCTAssertEqual(subscription.pricing.conversion, .fixed(rates: [ConversionRate(asset: "usdt", value: "1")]))
                 let later = now.addingTimeInterval(40 * 86400)
                 let period = try XCTUnwrap(subscription.recurrence.periods(through: later, acceptedAt: PaykitPreciseInstant(date: now)).last)
-                let payment = try subscription.pricing.payment(requested: subscription.amount, asset: .usdt, period: period, at: later)
+                let payment = try subscription.pricing.payment(
+                    requested: subscription.amount,
+                    endpoint: "usdt-arbitrum-address",
+                    period: period,
+                    at: later
+                )
                 XCTAssertEqual(payment.amount.value, "5")
                 XCTAssertNil(payment.quoteId)
                 XCTAssertTrue(payment.isValid(at: later))
@@ -3031,7 +3036,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertTrue(manager.pendingRequests.isEmpty)
         let payerSubscription = try XCTUnwrap(manager.subscriptions.first { $0.isPayer })
         let unpaid = try XCTUnwrap(payerSubscription.paymentDueOnAcceptance(at: now))
-        XCTAssertFalse(try unpaid.payment(to: .btc, at: now).isValid(at: now))
+        XCTAssertFalse(try unpaid.payment(using: .bitcoinLightningBolt11, at: now).isValid(at: now))
         XCTAssertTrue(unpaid.isPaymentDeadlineExpired(at: now))
         XCTAssertEqual(unpaid.paymentDeadline?.timestamp, "2027-02-01T09:00:00Z")
         XCTAssertEqual(manager.subscriptions.count, 2)
@@ -3810,9 +3815,9 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             now: Date()
         ))
 
-        XCTAssertTrue(request.acceptsPaymentAmount(2500))
-        XCTAssertFalse(request.acceptsPaymentAmount(0))
-        XCTAssertFalse(request.acceptsPaymentAmount(2501))
+        XCTAssertTrue(request.acceptsPaymentAmount(2500, method: .bitcoinLightningBolt11))
+        XCTAssertFalse(request.acceptsPaymentAmount(0, method: .bitcoinLightningBolt11))
+        XCTAssertFalse(request.acceptsPaymentAmount(2501, method: .bitcoinLightningBolt11))
         XCTAssertTrue(request.acceptsLightningInvoiceAmount(milliSatoshis: nil))
         XCTAssertTrue(request.acceptsLightningInvoiceAmount(milliSatoshis: 2_500_000))
         XCTAssertFalse(request.acceptsLightningInvoiceAmount(milliSatoshis: 2_499_999))
@@ -8320,21 +8325,34 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
     func testPaymentApprovalRequiresTheApprovedAmountAndUnexpiredTerms() throws {
         var record = try paymentRequestRecord(amount: "5", asset: "usd", paymentDeadline: .at(timestamp: "2027-01-15T08:10:00Z"))
-        record.terms?.conversion = .fixed(rates: [ConversionRate(asset: "btc", value: "0.00001"), ConversionRate(asset: "usdt", value: "1")])
+        record.terms?.conversion = .fixed(rates: [
+            ConversionRate(asset: "btc", value: "0.00002"),
+            ConversionRate(asset: "btc-lightning", value: "0.00001"),
+            ConversionRate(asset: "usdt", value: "1"),
+        ])
         let now = try XCTUnwrap(PaykitPaymentRequest.parseDate("2027-01-15T08:00:00Z"))
         let request = try XCTUnwrap(PaykitPaymentRequest(historyRecord: record, now: now))
-        let approved = try request.payment(to: .btc, at: now)
-        XCTAssertTrue(request.acceptsPaymentAmount(5000, paymentTerms: approved, at: now))
-        XCTAssertFalse(request.acceptsPaymentAmount(5001, paymentTerms: approved, at: now))
-        XCTAssertFalse(request.acceptsPaymentAmount(5000, paymentTerms: approved, at: now.addingTimeInterval(601)))
-        let usdt = try request.payment(to: .usdt, at: now)
-        XCTAssertTrue(request.acceptsPayment(usdt.amount, paymentTerms: usdt, at: now))
-        XCTAssertFalse(request.acceptsPayment(usdt.amount, paymentTerms: nil, at: now))
-        XCTAssertFalse(request.acceptsPayment(usdt.amount, paymentTerms: usdt, at: now.addingTimeInterval(601)))
-        XCTAssertFalse(request.acceptsPayment(PaykitAmount(asset: .usdt, atomic: usdt.amount.atomic + 1), paymentTerms: usdt, at: now))
+        let approved = try request.payment(using: .bitcoinLightningBolt11, at: now)
+        XCTAssertTrue(request.acceptsPaymentAmount(5000, method: .bitcoinLightningBolt11, paymentTerms: approved, at: now))
+        XCTAssertFalse(request.acceptsPaymentAmount(5001, method: .bitcoinLightningBolt11, paymentTerms: approved, at: now))
+        XCTAssertFalse(request.acceptsPaymentAmount(5000, method: .bitcoinLightningBolt11, paymentTerms: approved, at: now.addingTimeInterval(601)))
+        let onchain = try request.payment(using: .bitcoinOnchainP2wpkh, at: now)
+        XCTAssertEqual(onchain.amount.atomic, 10000)
+        XCTAssertFalse(request.acceptsPaymentAmount(10000, method: .bitcoinOnchainP2wpkh, paymentTerms: approved, at: now))
+        XCTAssertTrue(request.acceptsPaymentAmount(10000, method: .bitcoinOnchainP2wpkh, paymentTerms: onchain, at: now))
+        let usdt = try request.payment(using: .usdtArbitrum, at: now)
+        XCTAssertTrue(request.acceptsPayment(usdt.amount, method: .usdtArbitrum, paymentTerms: usdt, at: now))
+        XCTAssertFalse(request.acceptsPayment(usdt.amount, method: .usdtArbitrum, paymentTerms: nil, at: now))
+        XCTAssertFalse(request.acceptsPayment(usdt.amount, method: .usdtArbitrum, paymentTerms: usdt, at: now.addingTimeInterval(601)))
+        XCTAssertFalse(request.acceptsPayment(
+            PaykitAmount(asset: .usdt, atomic: usdt.amount.atomic + 1),
+            method: .usdtArbitrum,
+            paymentTerms: usdt,
+            at: now
+        ))
         record.terms?.conversion = .fixed(rates: [ConversionRate(asset: "btc", value: "0.00002")])
         let changed = try XCTUnwrap(PaykitPaymentRequest(historyRecord: record, now: now))
-        XCTAssertFalse(changed.acceptsPaymentAmount(10000, paymentTerms: approved, at: now))
+        XCTAssertFalse(changed.acceptsPaymentAmount(10000, method: .bitcoinLightningBolt11, paymentTerms: approved, at: now))
     }
 
     func testReceivedUsdtProofsRequireSatisfiedReceiptsForPaidThroughAndStatus() throws {
diff --git a/BitkitTests/PaykitRequestPricingTests.swift b/BitkitTests/PaykitRequestPricingTests.swift
index 0d05b1f35..1b9efb5e1 100644
--- a/BitkitTests/PaykitRequestPricingTests.swift
+++ b/BitkitTests/PaykitRequestPricingTests.swift
@@ -12,10 +12,53 @@ final class PaykitRequestPricingTests: XCTestCase {
             ConversionRate(asset: "btc", value: "0.000012345"), ConversionRate(asset: "usdt", value: "1"),
         ]))
         let requested = try PaykitAmount(asset: .usd, value: "0.05")
-        XCTAssertEqual(try pricing.payment(requested: requested, asset: .btc, period: nil, at: now).amount.atomic, 62)
-        XCTAssertEqual(try pricing.payment(requested: requested, asset: .usdt, period: nil, at: now).amount.atomic, 50000)
-        XCTAssertEqual(try pricing.payment(requested: requested, asset: .usd, period: nil, at: now).amount, requested)
-        XCTAssertThrowsError(try pricing.payment(requested: requested, asset: .usdt, period: nil, at: now, quoteId: "unknown"))
+        XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "btc-bitcoin-p2wpkh", period: nil, at: now).amount.atomic, 62)
+        XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "usdt-arbitrum-address", period: nil, at: now).amount.atomic, 50000)
+        XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "usd-bank-account", period: nil, at: now).amount, requested)
+        XCTAssertThrowsError(try pricing.payment(requested: requested, endpoint: "usdt-arbitrum-address", period: nil, at: now, quoteId: "unknown"))
+    }
+
+    func testFixedPricingSelectsTheRailBeforeTheAssetIncludingSameAssetPayments() throws {
+        let requested = try PaykitAmount(asset: .btc, value: "1")
+        let rates = [ConversionRate(asset: "btc", value: "2"), ConversionRate(asset: "btc-lightning", value: "0.5")]
+        for values in [rates, Array(rates.reversed())] {
+            let pricing = PaykitRequestPricing(conversion: .fixed(rates: Array(values)))
+            XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "btc-lightning-bolt11", period: nil, at: now).amount.value, "0.5")
+            XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "btc-lightning-lnurl", period: nil, at: now).amount.value, "0.5")
+            XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "btc-bitcoin-p2wpkh", period: nil, at: now).amount.value, "2")
+        }
+        let pricing = PaykitRequestPricing(conversion: .fixed(rates: [rates[1]]))
+        XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "btc-bitcoin-p2wpkh", period: nil, at: now).amount, requested)
+    }
+
+    func testPaymentMarketValueIsIndependentOfTheRequestedValue() throws {
+        let pricing = PaykitRequestPricing(conversion: .fixed(rates: [ConversionRate(asset: "btc", value: "0.001")]))
+        let requested = try PaykitAmount(asset: .usd, value: "1000")
+        let payment = try pricing.payment(requested: requested, endpoint: "btc-bitcoin-p2wpkh", period: nil, at: now)
+        XCTAssertEqual(payment.amount.value, "1")
+        let valuation = try payment.amount.converted(to: .usd, rate: PaykitExchangeRate(price: "2000", timestamp: now), at: now)
+        XCTAssertEqual(valuation.value, "2000")
+        XCTAssertEqual(requested.value, "1000")
+    }
+
+    func testSameAssetRecurringPaymentsUseParityAndOptionalQuoteValidity() throws {
+        let requested = try PaykitAmount(asset: .btc, value: "1")
+        let period = PaykitBillingPeriod(startsAt: now, endsAt: now.addingTimeInterval(86400))
+        let quote = PaymentConversionQuoteRecord(eventId: "quote", billingPeriod: period.sdkValue,
+                                                 rates: [ConversionRate(asset: "usdt", value: "100000")],
+                                                 validFrom: period.sdkValue.startsAt,
+                                                 expiresAt: ISO8601DateFormatter().string(from: now.addingTimeInterval(60)), outboundStatus: nil)
+        let pricing = PaykitRequestPricing(conversion: .perPeriod, quotes: [quote])
+        let unquoted = try pricing.payment(requested: requested, endpoint: "btc-lightning-bolt11", period: period, at: now)
+        XCTAssertEqual(unquoted.amount, requested)
+        XCTAssertNil(unquoted.quoteId)
+        let quoted = try pricing.payment(requested: requested, endpoint: "btc-lightning-bolt11", period: period, at: now, quoteId: "quote")
+        XCTAssertEqual(quoted.amount, requested)
+        XCTAssertEqual(quoted.quoteId, "quote")
+        XCTAssertFalse(quoted.isValid(at: now.addingTimeInterval(-1)))
+        XCTAssertTrue(quoted.isValid(at: now.addingTimeInterval(60)))
+        XCTAssertFalse(quoted.isValid(at: now.addingTimeInterval(61)))
+        XCTAssertThrowsError(try pricing.payment(requested: requested, endpoint: "btc-lightning-bolt11", period: period, at: now, quoteId: "unknown"))
     }
 
     func testSubscriptionsKeepOnePaymentCurrencyAcrossBillingPeriods() throws {
@@ -23,7 +66,7 @@ final class PaykitRequestPricingTests: XCTestCase {
         let lightning = PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue
         let usdt = PublicPaykitService.MethodId.usdtArbitrum.rawValue
         let available = [bitcoin, lightning, usdt]
-        for (asset, endpoints, paidAsset) in [(PaykitAsset.btc, [bitcoin, lightning], PaykitAsset.btc), (.usd, [usdt], .usdt)] {
+        for (asset, endpoints) in [(PaykitAsset.btc, [bitcoin, lightning]), (.usd, [usdt])] {
             let selected = PaykitRequestPricing.subscriptionEndpoints(requested: asset, available: available)
             XCTAssertEqual(selected, endpoints)
             XCTAssertTrue(PaykitRequestPricing.subscriptionEndpoints(requested: asset, available: available.filter { !endpoints.contains($0) })
@@ -32,7 +75,7 @@ final class PaykitRequestPricingTests: XCTestCase {
             let pricing = PaykitRequestPricing(conversion: rates.isEmpty ? nil : .fixed(rates: rates))
             let requested = try PaykitAmount(asset: asset, value: "5")
             let nextPeriod = PaykitBillingPeriod(startsAt: now.addingTimeInterval(31 * 86400), endsAt: now.addingTimeInterval(62 * 86400))
-            let payment = try pricing.payment(requested: requested, asset: paidAsset, period: nextPeriod, at: nextPeriod.startsAt)
+            let payment = try pricing.payment(requested: requested, endpoint: endpoints[0], period: nextPeriod, at: nextPeriod.startsAt)
             XCTAssertEqual(payment.amount.value, "5")
             XCTAssertNil(payment.quoteId)
             XCTAssertNil(payment.expiresAt)
@@ -44,8 +87,8 @@ final class PaykitRequestPricingTests: XCTestCase {
     func testMissingTermsOrRateNeverImplicitlyEnableConversion() throws {
         let requested = try PaykitAmount(asset: .usd, value: "5")
         for pricing in [PaykitRequestPricing(), PaykitRequestPricing(conversion: .fixed(rates: [ConversionRate(asset: "btc", value: "0.00001")]))] {
-            XCTAssertThrowsError(try pricing.payment(requested: requested, asset: .usdt, period: nil, at: now))
-            XCTAssertEqual(try pricing.payment(requested: requested, asset: .usd, period: nil, at: now).amount, requested)
+            XCTAssertThrowsError(try pricing.payment(requested: requested, endpoint: "usdt-arbitrum-address", period: nil, at: now))
+            XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "usd-bank-account", period: nil, at: now).amount, requested)
         }
     }
 
@@ -91,17 +134,23 @@ final class PaykitRequestPricingTests: XCTestCase {
         later.rates = [ConversionRate(asset: "usdt", value: "110000")]
         let pricing = PaykitRequestPricing(conversion: .perPeriod, deadline: .periodStart(seconds: 30), quotes: [first, later])
         let requested = try PaykitAmount(asset: .btc, value: "0.00001")
-        let selected = try pricing.payment(requested: requested, asset: .usdt, period: period, at: now)
+        let selected = try pricing.payment(requested: requested, endpoint: "usdt-arbitrum-address", period: period, at: now)
         XCTAssertEqual(selected.amount.value, "1.1")
         XCTAssertEqual(selected.quoteId, "later")
-        let pinned = try pricing.payment(requested: requested, asset: .usdt, period: period, at: now, quoteId: "first")
+        let pinned = try pricing.payment(requested: requested, endpoint: "usdt-arbitrum-address", period: period, at: now, quoteId: "first")
         XCTAssertEqual(pinned.amount.value, "1")
         XCTAssertTrue(pinned.isValid(at: now.addingTimeInterval(30)))
         XCTAssertFalse(pinned.isValid(at: now.addingTimeInterval(31)))
         XCTAssertFalse(pinned.isValid(at: now.addingTimeInterval(-1)))
-        XCTAssertEqual(try pricing.payment(requested: requested, asset: .usdt, period: period,
+        XCTAssertEqual(try pricing.payment(requested: requested, endpoint: "usdt-arbitrum-address", period: period,
                                            at: now.addingTimeInterval(600), quoteId: "first"), pinned)
-        XCTAssertThrowsError(try pricing.payment(requested: requested, asset: .usdt, period: period, at: now, quoteId: "missing"))
-        XCTAssertThrowsError(try pricing.payment(requested: requested, asset: .usdt, period: nil, at: now))
+        XCTAssertThrowsError(try pricing.payment(
+            requested: requested,
+            endpoint: "usdt-arbitrum-address",
+            period: period,
+            at: now,
+            quoteId: "missing"
+        ))
+        XCTAssertThrowsError(try pricing.payment(requested: requested, endpoint: "usdt-arbitrum-address", period: nil, at: now))
     }
 }
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index 126a0ce4f..f9c4f6f00 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -1,10 +1,12 @@
 <journey name="paykit quoted usdt requests">
-  <description>Two linked Bitkit wallets with Paykit and USDT enabled, sharing enabled by their owners, and a fresh BTC/USD rate. No funded account is required: stop at Amount and do not authorize a payment. Funded settlement, later installments and controlled evidence checks are manual tests in Docs/USDT-QA.md.</description>
+  <description>Two linked Bitkit wallets with Paykit and USDT enabled, sharing enabled by their owners, and a fresh BTC/USD rate. Ordinary request-creation checks can stop at Amount without funds. The controlled quote checks need a linked test peer and sufficient regtest balance to reach confirmation; do not authorize a payment. Funded settlement, later installments and controlled evidence checks are manual tests in Docs/USDT-QA.md.</description>
   <actions>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
     <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
+    <action>With a linked test payer, open a quoted request for 1000 USD requiring 1 BTC while Bitkit's BTC/USD rate is 2000. Verify the request details label 1000 USD as Requested amount. On payment review, verify 1 BTC and Bitkit's approximately 2000 USD valuation. Close without paying.</action>
+    <action>Open a BTC request with different quoted prices for Bitcoin and Lightning. Switch Savings and Spending and verify the payable BTC amount changes to the selected method's quoted amount. Verify the confirmation uses Bitkit's own fiat valuation and requires approval. Close without paying.</action>
     <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method; close before subscribing.</action>
     <action>Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing.</action>
   </actions>

From 6da0318c6894c15c452675cb0803766db9a28efc Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Thu, 8 Oct 2026 08:43:19 -0500
Subject: [PATCH 08/62] fix: align USDT and Paykit screens with design updates

---
 .../PaymentRequestInvoiceNote.swift           | 22 ++++++
 Bitkit/Components/PaymentRequestSummary.swift | 46 ++++++++++++
 .../Localization/en.lproj/Localizable.strings |  2 +
 .../PubkyAuthApprovalSheet.swift              |  6 +-
 .../Wallets/Send/SendConfirmationView.swift   | 70 ++----------------
 Bitkit/Views/Wallets/Send/SendSheet.swift     |  2 +-
 Bitkit/Views/Wallets/Sheets/ReceivedTx.swift  |  2 +-
 Bitkit/Views/Wallets/UsdtActivityDetail.swift |  2 +-
 .../Wallets/UsdtDepositHistoryView.swift      |  3 +-
 .../Views/Wallets/UsdtReceiveAmountView.swift | 71 +++----------------
 Bitkit/Views/Wallets/UsdtReceiveView.swift    | 18 +++--
 Bitkit/Views/Wallets/UsdtSendView.swift       | 49 +++++++++++--
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |  6 +-
 journeys/paykit-quoted-usdt.xml               |  2 +-
 .../pubky-auth/share-receiving-details.xml    |  4 +-
 journeys/usdt-receive-amount-and-units.xml    |  7 +-
 16 files changed, 158 insertions(+), 154 deletions(-)
 create mode 100644 Bitkit/Components/PaymentRequestInvoiceNote.swift
 create mode 100644 Bitkit/Components/PaymentRequestSummary.swift

diff --git a/Bitkit/Components/PaymentRequestInvoiceNote.swift b/Bitkit/Components/PaymentRequestInvoiceNote.swift
new file mode 100644
index 000000000..8f6b38ea3
--- /dev/null
+++ b/Bitkit/Components/PaymentRequestInvoiceNote.swift
@@ -0,0 +1,22 @@
+import SwiftUI
+
+struct PaymentRequestInvoiceNote: View {
+    let note: String
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            CaptionMText(t("wallet__activity_invoice_note"))
+                .padding(.bottom, 8)
+
+            VStack(alignment: .leading, spacing: 0) {
+                ZigzagDivider()
+
+                TitleText(note, textColor: .primary)
+                    .padding(24)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .background(Color.white10)
+                    .accessibilityIdentifier("PaymentRequestInvoiceNote")
+            }
+        }
+    }
+}
diff --git a/Bitkit/Components/PaymentRequestSummary.swift b/Bitkit/Components/PaymentRequestSummary.swift
new file mode 100644
index 000000000..4a578641c
--- /dev/null
+++ b/Bitkit/Components/PaymentRequestSummary.swift
@@ -0,0 +1,46 @@
+import SwiftUI
+
+struct PaymentRequestSummary: View {
+    let contactName: String
+    let note: String?
+
+    var body: some View {
+        HStack(alignment: .top, spacing: 16) {
+            SendSectionView(t("wallet__send_from")) {
+                paymentRequestSummaryValue(
+                    contactName,
+                    icon: "user",
+                    accessibilityIdentifier: "PaymentRequestFrom"
+                )
+            }
+
+            SendSectionView(t("wallet__payment_request_for")) {
+                paymentRequestSummaryValue(
+                    note ?? t("wallet__payment_request_for_not_specified"),
+                    icon: "note",
+                    textColor: note == nil ? .textSecondary : .textPrimary,
+                    accessibilityIdentifier: "PaymentRequestFor"
+                )
+            }
+        }
+    }
+
+    private func paymentRequestSummaryValue(
+        _ text: String,
+        icon: String,
+        textColor: Color = .textPrimary,
+        accessibilityIdentifier: String
+    ) -> some View {
+        HStack(spacing: 4) {
+            Image(icon)
+                .resizable()
+                .scaledToFit()
+                .foregroundColor(.white)
+                .frame(width: 16, height: 16)
+
+            BodySSBText(text, textColor: textColor)
+                .lineLimit(1)
+                .accessibilityIdentifier(accessibilityIdentifier)
+        }
+    }
+}
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index c00640b83..8cb4f88ca 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1940,3 +1940,5 @@
 "usdt__deposit_maximum" = "Maximum amount is {amount}";
 
 "wallet__payment_request_requested_amount" = "Requested amount";
+
+"profile__auth_approval_services_separator" = " and ";
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index d3648280c..1f8283be2 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -320,7 +320,7 @@ struct PubkyAuthApprovalSheet: View {
                         .accessibilityIdentifier("PubkyAuthPaykitAccess")
                     }
 
-                    Spacer(minLength: 32)
+                    Spacer().frame(height: 32)
 
                     trustWarning
                         .padding(.bottom, 16)
@@ -350,7 +350,7 @@ struct PubkyAuthApprovalSheet: View {
     }
 
     private var serviceText: String {
-        pubkyAuthLiteralText(config.request.serviceNames.joined(separator: " and "))
+        pubkyAuthLiteralText(config.request.serviceNames.joined(separator: t("profile__auth_approval_services_separator")))
     }
 
     private var requesterText: String {
@@ -546,6 +546,8 @@ struct PubkyAuthApprovalSheet: View {
         .padding(24)
         .background(Color.gray6)
         .cornerRadius(16)
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("PubkyAuthProfile")
     }
 
     /// Figma draws the check illustration at 274pt inside its 256pt slot.
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index 2ec52395f..35913ba0b 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -303,8 +303,11 @@ struct SendConfirmationView: View {
                 }
             } else {
                 if let request = oneOffPaymentRequest {
-                    paymentRequestSummary(request)
-                        .padding(.bottom, 16)
+                    PaymentRequestSummary(
+                        contactName: contactPaymentContact?.displayName ?? PubkyPublicKeyFormat.displayTruncated(request.counterparty),
+                        note: oneOffPaymentRequestNote
+                    )
+                    .padding(.bottom, 16)
                 }
 
                 PaymentReviewIllustration(swipeProgress: swipeProgress)
@@ -602,7 +605,7 @@ struct SendConfirmationView: View {
             }
 
             if let note = oneOffPaymentRequestNote {
-                paymentRequestInvoiceNote(note)
+                PaymentRequestInvoiceNote(note: note)
             }
         }
     }
@@ -723,7 +726,7 @@ struct SendConfirmationView: View {
             }
 
             if let note = oneOffPaymentRequestNote {
-                paymentRequestInvoiceNote(note)
+                PaymentRequestInvoiceNote(note: note)
             }
         }
     }
@@ -1038,65 +1041,6 @@ struct SendConfirmationView: View {
         return note
     }
 
-    private func paymentRequestSummary(_ request: PaykitPaymentRequest) -> some View {
-        HStack(alignment: .top, spacing: 16) {
-            SendSectionView(t("wallet__send_from")) {
-                paymentRequestSummaryValue(
-                    contactPaymentContact?.displayName ?? PubkyPublicKeyFormat.displayTruncated(request.counterparty),
-                    icon: "user",
-                    accessibilityIdentifier: "PaymentRequestFrom"
-                )
-            }
-
-            let note = oneOffPaymentRequestNote
-
-            SendSectionView(t("wallet__payment_request_for")) {
-                paymentRequestSummaryValue(
-                    note ?? t("wallet__payment_request_for_not_specified"),
-                    icon: "note",
-                    textColor: note == nil ? .textSecondary : .textPrimary,
-                    accessibilityIdentifier: "PaymentRequestFor"
-                )
-            }
-        }
-    }
-
-    private func paymentRequestInvoiceNote(_ note: String) -> some View {
-        VStack(alignment: .leading, spacing: 0) {
-            CaptionMText(t("wallet__activity_invoice_note"))
-                .padding(.bottom, 8)
-
-            VStack(alignment: .leading, spacing: 0) {
-                ZigzagDivider()
-
-                TitleText(note, textColor: .primary)
-                    .padding(24)
-                    .frame(maxWidth: .infinity, alignment: .leading)
-                    .background(Color.white10)
-                    .accessibilityIdentifier("PaymentRequestInvoiceNote")
-            }
-        }
-    }
-
-    private func paymentRequestSummaryValue(
-        _ text: String,
-        icon: String,
-        textColor: Color = .textPrimary,
-        accessibilityIdentifier: String
-    ) -> some View {
-        HStack(spacing: 4) {
-            Image(icon)
-                .resizable()
-                .scaledToFit()
-                .foregroundColor(accentColor)
-                .frame(width: 16, height: 16)
-
-            BodySSBText(text, textColor: textColor)
-                .lineLimit(1)
-                .accessibilityIdentifier(accessibilityIdentifier)
-        }
-    }
-
     private func performPayment(isAutomatic: Bool) async throws {
         let paymentActivity = PaykitPaymentActivity.shared.begin()
         defer { PaykitPaymentActivity.shared.end(paymentActivity) }
diff --git a/Bitkit/Views/Wallets/Send/SendSheet.swift b/Bitkit/Views/Wallets/Send/SendSheet.swift
index 2816be96d..666480fb6 100644
--- a/Bitkit/Views/Wallets/Send/SendSheet.swift
+++ b/Bitkit/Views/Wallets/Send/SendSheet.swift
@@ -809,7 +809,7 @@ struct SendSheet: View {
         case let .usdt(recipient, amount):
             UsdtSendView(onDetails: { id in
                 usdtDetails = id
-            }, initialRecipient: recipient, initialAmount: amount, embedded: true,
+            }, initialRecipient: recipient, initialAmount: amount, embedded: true, paymentContext: app.contactPaymentContext,
             sendPayment: { quote in
                 guard let context = app.contactPaymentContext else { throw PaykitPaymentRequestError.requestUnavailable }
                 let paymentTerms = app.paykitPaymentTerms
diff --git a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
index bc8a3c8d2..c7496fe60 100644
--- a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
+++ b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
@@ -43,7 +43,7 @@ struct ReceivedTx: View {
                 VStack(alignment: .leading, spacing: 0) {
                     SheetHeader(title: title)
                     if let amount = config.details.usdtAmount {
-                        UsdtAmountHeader(amount: usdtFormatAmount(amount: amount), network: "Arbitrum One")
+                        UsdtAmountHeader(amount: usdtFormatAmount(amount: amount))
                             .accessibilityIdentifier("ReceivedTransaction")
                     } else {
                         MoneyStack(sats: Int(config.details.sats), showSymbol: true, testIdPrefix: "ReceivedTransaction")
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index e4c59d3c1..cfa39d154 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -64,7 +64,7 @@ struct UsdtActivityDetail: View {
                     VStack(alignment: .leading, spacing: 16) {
                         HStack(alignment: .bottom) {
                             UsdtAmountHeader(
-                                amount: usdtFormatAmount(amount: transfer.activityAmount), network: transfer.destination.label,
+                                amount: usdtFormatAmount(amount: transfer.activityAmount),
                                 prefix: transfer.isIncoming ? "+ " : "− ", hideBalance: settings.hideBalance
                             )
                             UsdtActivityIcon(transfer: transfer, size: 48)
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index d55f57edb..f9f21e879 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -110,8 +110,7 @@ struct UsdtDepositHistoryView: View {
     private func detail(_ detail: UsdtDepositDetail) -> some View {
         VStack(alignment: .leading, spacing: 16) {
             if detail.deposit.asset == "USDT" {
-                UsdtAmountHeader(amount: detail.deposit.amount.map { usdtFormatAmount(amount: $0) } ?? "—",
-                                 network: detail.deposit.network.uppercased(), hideBalance: settings.hideBalance)
+                UsdtAmountHeader(amount: detail.deposit.amount.map { usdtFormatAmount(amount: $0) } ?? "—", hideBalance: settings.hideBalance)
             } else {
                 BodySSBText(detail.deposit.asset + " · " + detail.deposit.network.uppercased())
             }
diff --git a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
index 7d285357f..33fc5ee73 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
@@ -8,48 +8,25 @@ struct UsdtReceiveAmountView: View {
     let allowEmpty: Bool
     let onContinue: () async -> Void
 
-    @EnvironmentObject private var currency: CurrencyViewModel
-    @State private var bitcoinInput: String?
-    @State private var conversionError: String?
-
-    private var isSatsInput: Bool {
-        bitcoinInput != nil && currency.displayUnit == .modern
-    }
-
     private var canContinue: Bool {
-        !busy && conversionError == nil &&
-            (amount.isEmpty ? allowEmpty : (try? PaykitAmount(asset: .usdt, value: amount)) != nil)
+        !busy && (amount.isEmpty ? allowEmpty : (try? PaykitAmount(asset: .usdt, value: amount)) != nil)
     }
 
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
             VStack(alignment: .leading, spacing: 0) {
-                if let bitcoinInput {
-                    VStack(alignment: .leading, spacing: 16) {
-                        CaptionMText("$ " + (amount.isEmpty ? "0" : amount), textColor: .textSecondary)
-                        NumberPadAmountText(value: bitcoinInput.isEmpty ? "0" : bitcoinInput, symbol: "₿")
-                    }
-                } else {
-                    UsdtAmountHeader(amount: amount.isEmpty ? "0" : amount, network: "Arbitrum One")
-                }
+                UsdtAmountHeader(amount: amount.isEmpty ? "0" : amount)
                 Spacer(minLength: 16)
-                HStack(alignment: .bottom, spacing: 16) {
-                    if let message = conversionError ?? error { BodySText(message, textColor: .brandAccent) }
-                    Spacer(minLength: 0)
-                    NumberPadActionButton(text: bitcoinInput == nil ? "USD" : "BTC", imageName: "arrow-up-down",
-                                          color: .usdtAccent, disabled: busy, action: toggleUnit)
-                        .fixedSize()
-                        .accessibilityIdentifier("ReceiveNumberPadUnit")
-                }.padding(.bottom, 16)
+                if let error {
+                    BodySText(error, textColor: .brandAccent)
+                        .padding(.bottom, 16)
+                }
             }
             .frame(minHeight: 156, alignment: .top)
             .fixedSize(horizontal: false, vertical: true)
             Divider()
-            NumberPad(type: isSatsInput ? .integer : .decimal, isDisabled: busy,
-                      onDeleteLongPress: { updateInput("") })
-            { key in
-                updateInput(NumberPadInputHandler.handleInput(key: key, current: bitcoinInput ?? amount,
-                                                              maxLength: 21, maxDecimals: isSatsInput ? 0 : (bitcoinInput == nil ? 6 : 8)))
+            NumberPad(type: .decimal, isDisabled: busy, onDeleteLongPress: { amount = "" }) { key in
+                amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
             }
             .padding(.top, 24)
             Spacer(minLength: 24)
@@ -57,38 +34,6 @@ struct UsdtReceiveAmountView: View {
                 .accessibilityIdentifier("UsdtDepositCreate")
         }
     }
-
-    private func toggleUnit() {
-        conversionError = nil
-        if bitcoinInput != nil { bitcoinInput = nil; return }
-        guard !amount.isEmpty, amount != "0" else { bitcoinInput = ""; return }
-        do {
-            let bitcoin = try PaykitAmount(asset: .usdt, value: amount).converted(to: .btc, rate: currency.paykitRate, at: Date())
-            // Display conversion must not round or replace the USDT amount when switching units.
-            bitcoinInput = currency.displayUnit == .modern ? String(bitcoin.atomic) : bitcoin.value
-        } catch {
-            conversionError = t(error as? PaykitAmountError == .rateUnavailable
-                ? "wallet__payment_request_rate_unavailable" : "usdt__error_amount")
-        }
-    }
-
-    private func updateInput(_ value: String) {
-        conversionError = nil
-        guard bitcoinInput != nil else { amount = value; return }
-        bitcoinInput = value
-        guard !value.isEmpty else { amount = ""; return }
-        do {
-            let bitcoin: PaykitAmount
-            if isSatsInput {
-                guard let sats = UInt64(value), sats > 0 else { throw PaykitAmountError.invalidAmount }
-                bitcoin = PaykitAmount(asset: .btc, atomic: sats)
-            } else { bitcoin = try PaykitAmount(asset: .btc, value: value) }
-            amount = try bitcoin.converted(to: .usdt, rate: currency.paykitRate, at: Date()).value
-        } catch {
-            conversionError = t(error as? PaykitAmountError == .rateUnavailable
-                ? "wallet__payment_request_rate_unavailable" : "usdt__error_amount")
-        }
-    }
 }
 
 @MainActor
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index e9cfebc2b..7a1407286 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -55,6 +55,7 @@ struct UsdtReceiveView: View {
                     address: deposit?.address ?? usdt.address,
                     uri: deposit?.uri ?? receiveUri,
                     network: networkName,
+                    isDefaultNetwork: network == nil,
                     error: error ?? usdt.errorMessage,
                     onEdit: { page = .amount },
                     onNetwork: { page = .networks }
@@ -141,7 +142,7 @@ struct UsdtReceiveView: View {
 
     private func feeEstimate(_ deposit: UsdtDepositAddress) -> some View {
         VStack(alignment: .leading, spacing: 24) {
-            UsdtAmountHeader(amount: usdtFormatAmount(amount: deposit.amount), network: networkName)
+            UsdtAmountHeader(amount: usdtFormatAmount(amount: deposit.amount))
             BodyMText(t("usdt__deposit_fee_note"), textColor: .textSecondary)
             VStack(alignment: .leading, spacing: 24) {
                 feeRow(
@@ -167,6 +168,7 @@ struct UsdtReceiveAddressContent: View {
     let address: String
     let uri: String
     let network: String
+    let isDefaultNetwork: Bool
     var error: String?
     let onEdit: () -> Void
     let onNetwork: () -> Void
@@ -190,10 +192,16 @@ struct UsdtReceiveAddressContent: View {
             } else if let error { BodySText(error, textColor: .brandAccent) }
             else { ProgressView() }
         }
-        CustomButton(title: t("usdt__receive_network", variables: ["network": network]), variant: .secondary, size: .small,
-                     icon: Image("usdt-network").resizable().frame(width: 16, height: 16), shouldExpand: true, action: onNetwork)
-            .padding(.bottom, 16)
-            .accessibilityIdentifier("UsdtReceiveNetwork")
+        CustomButton(
+            title: t("usdt__receive_network", variables: ["network": isDefaultNetwork ? t("common__default") : network]),
+            variant: .secondary,
+            size: .small,
+            icon: Image("usdt-network").resizable().frame(width: 16, height: 16),
+            shouldExpand: true,
+            action: onNetwork
+        )
+        .padding(.bottom, 16)
+        .accessibilityIdentifier("UsdtReceiveNetwork")
         CustomButton(title: t(showDetails ? "wallet__receive_show_qr" : "common__show_details"),
                      icon: showDetails ? Image("qr").resizable().frame(width: 16, height: 16) : nil, shouldExpand: true)
         { showDetails.toggle() }.accessibilityIdentifier("UsdtReceiveDetails")
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 8c0428bd6..fa15bf806 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -7,10 +7,12 @@ struct UsdtSendView: View {
     var initialRecipient = ""
     var initialAmount = ""
     var embedded = false
+    var paymentContext: ContactPaymentContext?
     var sendPayment: ((UsdtQuote) async throws -> Void)?
     var onBack: (() -> Void)?
     var onClose: (() -> Void)?
     @Environment(UsdtWalletManager.self) private var usdt
+    @EnvironmentObject private var contactsManager: ContactsManager
     @EnvironmentObject private var currency: CurrencyViewModel
     @EnvironmentObject private var settings: SettingsViewModel
     @Environment(\.dismiss) private var dismiss
@@ -37,6 +39,7 @@ struct UsdtSendView: View {
         initialRecipient: String = "",
         initialAmount: String = "",
         embedded: Bool = false,
+        paymentContext: ContactPaymentContext? = nil,
         sendPayment: ((UsdtQuote) async throws -> Void)? = nil,
         onBack: (() -> Void)? = nil,
         onClose: (() -> Void)? = nil
@@ -45,6 +48,7 @@ struct UsdtSendView: View {
         self.initialRecipient = initialRecipient
         self.initialAmount = initialAmount
         self.embedded = embedded
+        self.paymentContext = paymentContext
         self.sendPayment = sendPayment
         self.onBack = onBack
         self.onClose = onClose
@@ -53,6 +57,24 @@ struct UsdtSendView: View {
         _editingAmount = State(initialValue: !initialRecipient.isEmpty)
     }
 
+    private var paymentRequest: PaykitPaymentRequest? {
+        paymentContext?.incomingPaymentRequest
+    }
+
+    private var requestNote: String? {
+        guard let note = paymentRequest?.note?.trimmingCharacters(in: .whitespacesAndNewlines), !note.isEmpty else { return nil }
+        return note
+    }
+
+    private var contact: PubkyContact? {
+        guard let key = paymentContext?.publicKey else { return nil }
+        return contactsManager.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }
+    }
+
+    private var contactName: String {
+        contact?.displayName ?? PubkyPublicKeyFormat.displayTruncated(paymentContext?.publicKey ?? "")
+    }
+
     private var submittedStatus: UsdtTransferStatus? {
         usdt.transfers.first { $0.id == quote?.id }?.status
     }
@@ -72,7 +94,7 @@ struct UsdtSendView: View {
             if bridgeNeedsAttention { return t("usdt__bridge_attention") }
             return t(submissionFailed ? "wallet__send_error_tx_failed" : "usdt__submitted")
         }
-        if quote != nil { return t("wallet__send_review") }
+        if quote != nil { return t(paymentRequest == nil ? "wallet__send_review" : "wallet__payment_request") }
         return t(editingAmount ? "usdt__amount" : "usdt__send_title")
     }
 
@@ -96,7 +118,9 @@ struct UsdtSendView: View {
 
     private var content: some View {
         VStack(alignment: .leading, spacing: 0) {
-            SheetHeader(title: title, showBackButton: !submitted, onBack: goBack).disabled(busy)
+            SheetHeader(title: title, showBackButton: !submitted,
+                        action: paymentContext == nil ? nil : AnyView(SendContactHeaderAvatar(publicKey: paymentContext?.publicKey)), onBack: goBack)
+                .disabled(busy)
             if submitted, !busy { submittedContent }
             else if let quote { confirmation(quote) }
             else if editingAmount { amountContent }
@@ -258,23 +282,36 @@ struct UsdtSendView: View {
         VStack(alignment: .leading, spacing: 0) {
             ScrollView(showsIndicators: false) {
                 VStack(alignment: .leading, spacing: 0) {
-                    UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), network: quote.destination.label)
+                    UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount))
                         .contentShape(Rectangle()).onTapGesture { if !busy { goBack() } }
-                        .padding(.bottom, 44)
+                        .padding(.bottom, paymentRequest == nil ? 44 : 24)
                     if showDetails {
                         VStack(alignment: .leading, spacing: 16) {
                             HStack(alignment: .top, spacing: 16) {
                                 SendSectionView(t("wallet__send_from")) {
                                     NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
                                 }
-                                SendSectionView(t("usdt__destination")) { BodySSBText(quote.destination.label).frame(height: 28) }
+                                if paymentContext != nil {
+                                    SendSectionView(t("wallet__payment_request_contact")) {
+                                        HStack(spacing: 4) {
+                                            if let contact { PubkyContactAvatar(contact: contact, size: 20) }
+                                            BodySSBText(contactName).lineLimit(1)
+                                        }.frame(height: 28)
+                                    }
+                                } else {
+                                    SendSectionView(t("usdt__destination")) { BodySSBText(quote.destination.label).frame(height: 28) }
+                                }
                             }
                             SendSectionView(t("wallet__send_to")) { BodySSBText(quote.recipient).textSelection(.enabled) }
                             if let provider = quote.bridgeProvider {
                                 SendSectionView(t("usdt__bridge_provider")) { BodySSBText(provider == .orchestra ? "Orchestra" : "USDT0") }
                             }
                         }
+                        if let requestNote { PaymentRequestInvoiceNote(note: requestNote).padding(.top, 16) }
                     } else {
+                        if paymentRequest != nil {
+                            PaymentRequestSummary(contactName: contactName, note: requestNote).padding(.bottom, 16)
+                        }
                         PaymentReviewIllustration(swipeProgress: swipeProgress, maximumHeight: 220)
                     }
                     if quote.destination != .arbitrum {
@@ -323,7 +360,7 @@ struct UsdtSendView: View {
     private var submittedContent: some View {
         VStack(alignment: .leading, spacing: 0) {
             if let quote {
-                UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), network: quote.destination.label).padding(.bottom, 32)
+                UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount)).padding(.bottom, 32)
             }
             if submittedStatus == .bridgeRefunded {
                 BodyMText(t("usdt__bridge_refunded_description"), textColor: .textSecondary)
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index dd751b2b5..5e25116e1 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -18,8 +18,7 @@ struct UsdtWalletScreen: View {
             ScrollView(showsIndicators: false) {
                 VStack(alignment: .leading, spacing: 32) {
                     UsdtAmountHeader(
-                        amount: usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—",
-                        network: usdt.networkName, hideBalance: settings.hideBalance
+                        amount: usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—", hideBalance: settings.hideBalance
                     )
                     .balanceVisibilityToggle()
                     .accessibilityIdentifier("UsdtBalance")
@@ -108,7 +107,6 @@ struct UsdtCoinIllustration: View {
 
 struct UsdtAmountHeader: View {
     let amount: String
-    let network: String
     var prefix = ""
     var hideBalance = false
 
@@ -120,7 +118,7 @@ struct UsdtAmountHeader: View {
                 MoneyText(sats: sats, forceUnit: .bitcoin, size: .caption, symbol: true,
                           enableHide: hideBalance, color: .textSecondary)
             } else {
-                CaptionMText("USDT · " + network, textColor: .textSecondary)
+                CaptionMText("USDT", textColor: .textSecondary)
             }
             DisplayText(
                 "<accent>\(prefix)$</accent> " + (hideBalance ? " • • • • •" : amount),
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index f9c4f6f00..8f616f212 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -3,7 +3,7 @@
   <actions>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
-    <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing.</action>
+    <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Continue to USDT review. Verify Payment Request, the requester avatar, From and For summary, exact dollar amount and additional fee. Open details and verify Contact, recipient address and the invoice note. Close without swiping to pay.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
     <action>With a linked test payer, open a quoted request for 1000 USD requiring 1 BTC while Bitkit's BTC/USD rate is 2000. Verify the request details label 1000 USD as Requested amount. On payment review, verify 1 BTC and Bitkit's approximately 2000 USD valuation. Close without paying.</action>
     <action>Open a BTC request with different quoted prices for Bitcoin and Lightning. Switch Savings and Spending and verify the payable BTC amount changes to the selected method's quoted amount. Verify the confirmation uses Bitkit's own fiat valuation and requires approval. Close without paying.</action>
diff --git a/journeys/pubky-auth/share-receiving-details.xml b/journeys/pubky-auth/share-receiving-details.xml
index 020d32437..bba5a4605 100644
--- a/journeys/pubky-auth/share-receiving-details.xml
+++ b/journeys/pubky-auth/share-receiving-details.xml
@@ -10,7 +10,9 @@
     <action>Repeat with x-bitkit-claim=watch-only-account-v1; verify only Bitcoin is requested, then cancel</action>
     <action>With USDT unavailable, verify sharing is off and authorization remains enabled; turn USDT sharing on and verify authorization is disabled until Retry loads the address</action>
     <action>Open the setup fixture with x-bitkit-claim=paykit-access-v1.watch-only-account-v1.usdt-address-v1</action>
-    <action>Continue to authorization; verify the Bitcoin account, Paykit access, and optional USDT sharing toggle are shown</action>
+    <action>Continue to authorization; verify the named requester, exact requested permission paths and access, Bitcoin account, Paykit Details explanation, and optional USDT sharing toggle are shown</action>
+    <action>Verify Before You Continue explains trusting the service, browser, and device. Verify the compact horizontal profile card (id "PubkyAuthProfile") shows the correct identity and name, with Cancel and Authorize reachable without overlap.</action>
     <action>Turn off PubkyAuthShareUsdt; verify authorization remains enabled, then cancel</action>
+    <action>Open the auth fixture with only x-bitkit-claim=paykit-access-v1; verify Paykit permissions and Details are shown without an empty Payment Details to Share section, then cancel.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-receive-amount-and-units.xml b/journeys/usdt-receive-amount-and-units.xml
index ce25c5905..0e390d973 100644
--- a/journeys/usdt-receive-amount-and-units.xml
+++ b/journeys/usdt-receive-amount-and-units.xml
@@ -2,11 +2,10 @@
   <description>Use an onboarded wallet with USDT configured and a fresh BTC/USD rate. No payment is submitted. Cross-network estimates require a live enabled provider and are covered by the manual USDT checks.</description>
   <actions>
     <action>Open USDT from Home. Verify the USDT balance, teal Tether icon and existing activity rows.</action>
-    <action>Open Receive. Verify Receive Dollars, the USDT tab and Network: Arbitrum One.</action>
-    <action>Tap Edit. Enter 3.5 in USD mode. Verify the dollar amount and BTC equivalent are displayed. Check that the unit toggle stays near the amount, the keypad follows the divider, and Continue stays at the bottom without overlap.</action>
-    <action>Tap the unit toggle (id "ReceiveNumberPadUnit"). Verify BTC input and the USD equivalent. Toggle back and verify the USD amount is still exactly 3.5.</action>
+    <action>Open Receive. Verify Receive Dollars, the USDT tab and Network: Default.</action>
+    <action>Tap Edit. Enter 3.5. Verify the dollar amount and BTC equivalent are displayed, there is no input-unit toggle, the keypad follows the divider, and Continue stays at the bottom without overlap.</action>
     <action>Continue to the QR. Verify it requests the Arbitrum USDT token, the wallet address and uint256=3500000, never Bitcoin.</action>
-    <action>Open Show Details. Verify the same Arbitrum address and teal Copy control. Return to the QR.</action>
+    <action>Open Show Details. Verify the same Arbitrum address and teal Copy control. Open Network and verify Arbitrum is marked Default and all enabled bridge networks remain available. Return to the QR.</action>
     <action>Select Savings. Verify Receive Bitcoin and a Bitcoin QR. Select USDT and verify Receive Dollars and the Arbitrum USDT QR.</action>
     <action>Close Receive and return Home. Open a USDT activity row, then Show All. Verify USDT details and mixed activity remain reachable.</action>
   </actions>

From 4c21984a9c71b60902f9955f6d7ed0aebe61ebbb Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Thu, 8 Oct 2026 15:48:12 -0500
Subject: [PATCH 09/62] chore: update bitkit core to 0.8.0-rc2

---
 Bitkit.xcodeproj/project.pbxproj                              | 2 +-
 .../project.xcworkspace/xcshareddata/swiftpm/Package.resolved | 4 ++--
 Docs/USDT.md                                                  | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Bitkit.xcodeproj/project.pbxproj b/Bitkit.xcodeproj/project.pbxproj
index 8d81cf8c0..df6967870 100644
--- a/Bitkit.xcodeproj/project.pbxproj
+++ b/Bitkit.xcodeproj/project.pbxproj
@@ -1226,7 +1226,7 @@
 			repositoryURL = "https://github.com/synonymdev/bitkit-core";
 			requirement = {
 				kind = exactVersion;
-				version = "0.8.0-rc1";
+				version = "0.8.0-rc2";
 			};
 		};
 		96E493A22C942FD1000E8BC2 /* XCRemoteSwiftPackageReference "swift-secp256k1" */ = {
diff --git a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
index cd0686b45..3489dad26 100644
--- a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
+++ b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -6,8 +6,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/synonymdev/bitkit-core",
       "state" : {
-        "revision" : "d0cbbf957ea7b00b4bc8e09cfe44aa0c7766a2ef",
-        "version" : "0.8.0-rc1"
+        "revision" : "bdce512c9d1025ba6cd71baa8c2df1a39dcb3d02",
+        "version" : "0.8.0-rc2"
       }
     },
     {
diff --git a/Docs/USDT.md b/Docs/USDT.md
index 3d4e65b10..02f6105fe 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -1,6 +1,6 @@
 # USDT configuration
 
-Normal builds use published bitkit-core `0.8.0-rc1`, including its matching native libraries and generated bindings.
+Normal builds use published bitkit-core `0.8.0-rc2`, including its matching native libraries and generated bindings.
 
 USDT uses Arbitrum One regardless of the Bitcoin network setting. `USDT_RPC_URL` and `USDT_BUNDLER_URL` must point to the controlled service's credential-free HTTPS chain and bundler routes. Info.plist/build settings provide release configuration; local runs can supply process environment overrides. Missing endpoints hide the wallet entry.
 

From 8dd9198be99a201d73ae5147b8745e93528e22d5 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Thu, 8 Oct 2026 16:59:42 -0500
Subject: [PATCH 10/62] docs: remove stale paykit version from usdt guide

---
 Docs/USDT.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Docs/USDT.md b/Docs/USDT.md
index 02f6105fe..8cf0d7699 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -16,7 +16,7 @@ History catch-up is deferred while the USDT send sheet is open. Balance and pend
 
 ## Paykit
 
-Paykit uses the rc66 SDK and a direct Arbitrum USDT0 endpoint (`usdt-arbitrum-address`). Existing public/private sharing settings control publication. The payload binds the address, chain 42161 and pinned token; bridge routes are excluded from Paykit choices.
+Paykit uses a direct Arbitrum USDT0 endpoint (`usdt-arbitrum-address`). Existing public/private sharing settings control publication. The payload binds the address, chain 42161 and pinned token; bridge routes are excluded from Paykit choices.
 
 Bitkit creates BTC or USD requests and also reads USDT-denominated requests from other wallets. The accepted methods are immutable request terms. Every accepted cross-asset currency has an explicit requester-supplied rate; the denominating asset needs no conversion. USD/USDT is exactly 1:1. Bitcoin rates come from the existing BTC/USD source when issuing terms, not when verifying received funds. External requests without rates allow only same-asset payment. A listed method without its required rate cannot be used.
 

From 016b72e70f16b54f14d92706406c9b28afcd3541 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Fri, 9 Oct 2026 07:10:50 -0500
Subject: [PATCH 11/62] fix: align usdt displays with design feedback

---
 Bitkit/Components/CopyAddressCard.swift       |  3 ++-
 Bitkit/Views/Wallets/Receive/QrArea.swift     |  3 ++-
 Bitkit/Views/Wallets/Sheets/ReceivedTx.swift  |  2 +-
 Bitkit/Views/Wallets/UsdtActivityDetail.swift |  2 +-
 Bitkit/Views/Wallets/UsdtReceiveView.swift    | 17 ++++++++++++-----
 Bitkit/Views/Wallets/UsdtSendView.swift       |  3 ++-
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   | 14 +++++++++-----
 BitkitTests/UsdtDisplayTests.swift            | 14 ++++++++++----
 Docs/USDT-QA.md                               |  2 +-
 journeys/usdt-receive-amount-and-units.xml    |  4 ++--
 journeys/usdt-wallet-navigation.xml           |  2 +-
 11 files changed, 43 insertions(+), 23 deletions(-)

diff --git a/Bitkit/Components/CopyAddressCard.swift b/Bitkit/Components/CopyAddressCard.swift
index 6938f936c..290fa1de8 100644
--- a/Bitkit/Components/CopyAddressCard.swift
+++ b/Bitkit/Components/CopyAddressCard.swift
@@ -9,6 +9,7 @@ struct CopyAddressPair {
     let title: String
     let address: String
     let type: AddressType
+    var shareText: String?
 }
 
 struct CopyAddressCard: View {
@@ -56,7 +57,7 @@ struct CopyAddressCard: View {
                             }
 
                             ShareLink(
-                                item: pair.address,
+                                item: pair.shareText ?? pair.address,
                                 preview: SharePreview(pair.address, image: Image("app-icon-orange"))
                             ) {
                                 CustomButton(
diff --git a/Bitkit/Views/Wallets/Receive/QrArea.swift b/Bitkit/Views/Wallets/Receive/QrArea.swift
index f4038297f..e2c0ecebd 100644
--- a/Bitkit/Views/Wallets/Receive/QrArea.swift
+++ b/Bitkit/Views/Wallets/Receive/QrArea.swift
@@ -6,6 +6,7 @@ struct QrArea: View {
     let imageAsset: String?
     let accentColor: Color
     var copyValue: String?
+    var shareText: String?
     var onEdit: (() -> Void)?
 
     @State private var showCopyTooltip = false
@@ -15,7 +16,7 @@ struct QrArea: View {
     private var shareItems: [Any] {
         // If image is not available, generate it on-demand
         let image = shareQRImage ?? generateShareQrImage()
-        return [uri, image ?? UIImage()]
+        return [shareText ?? uri, image ?? UIImage()]
     }
 
     var body: some View {
diff --git a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
index c7496fe60..cd28e5aea 100644
--- a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
+++ b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
@@ -43,7 +43,7 @@ struct ReceivedTx: View {
                 VStack(alignment: .leading, spacing: 0) {
                     SheetHeader(title: title)
                     if let amount = config.details.usdtAmount {
-                        UsdtAmountHeader(amount: usdtFormatAmount(amount: amount))
+                        UsdtAmountHeader(amount: usdtFormatAmount(amount: amount), displayAmount: usdtOverviewAmount(amount))
                             .accessibilityIdentifier("ReceivedTransaction")
                     } else {
                         MoneyStack(sats: Int(config.details.sats), showSymbol: true, testIdPrefix: "ReceivedTransaction")
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index cfa39d154..ed3f76768 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -22,7 +22,7 @@ struct UsdtActivityRow: View {
                 VStack(alignment: .trailing, spacing: 2) {
                     BodyMSBText(
                         "<accent>\(transfer.isIncoming ? "+" : "−")</accent> "
-                            + (hideBalance ? " • • • • •" : usdtFormatAmount(amount: transfer.activityAmount)),
+                            + (hideBalance ? " • • • • •" : usdtOverviewAmount(transfer.activityAmount)),
                         accentColor: .textSecondary
                     )
                     .lineLimit(1).minimumScaleFactor(0.7)
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index 7a1407286..e66d03c8e 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -55,7 +55,6 @@ struct UsdtReceiveView: View {
                     address: deposit?.address ?? usdt.address,
                     uri: deposit?.uri ?? receiveUri,
                     network: networkName,
-                    isDefaultNetwork: network == nil,
                     error: error ?? usdt.errorMessage,
                     onEdit: { page = .amount },
                     onNetwork: { page = .networks }
@@ -168,18 +167,26 @@ struct UsdtReceiveAddressContent: View {
     let address: String
     let uri: String
     let network: String
-    let isDefaultNetwork: Bool
     var error: String?
     let onEdit: () -> Void
     let onNetwork: () -> Void
     @State private var showDetails = false
 
+    private var networkTitle: String {
+        t("usdt__receive_network", variables: ["network": network])
+    }
+
+    private var shareText: String {
+        networkTitle + "\n" + uri
+    }
+
     var body: some View {
         ScrollView(showsIndicators: false) {
             if !uri.isEmpty {
                 if showDetails {
                     CopyAddressCard(
-                        addresses: [CopyAddressPair(title: network + " " + t("wallet__activity_address"), address: address, type: .onchain)],
+                        addresses: [CopyAddressPair(title: network + " " + t("wallet__activity_address"), address: address, type: .onchain,
+                                                    shareText: shareText)],
                         navigationPath: .constant([]),
                         editRoute: nil,
                         accentColor: .usdtAccent
@@ -187,13 +194,13 @@ struct UsdtReceiveAddressContent: View {
                     .accessibilityIdentifier("UsdtReceiveAddress")
                 } else {
                     QrArea(uri: uri, imageAsset: "tether-circle", accentColor: .usdtAccent,
-                           copyValue: address, onEdit: onEdit)
+                           copyValue: address, shareText: shareText, onEdit: onEdit)
                 }
             } else if let error { BodySText(error, textColor: .brandAccent) }
             else { ProgressView() }
         }
         CustomButton(
-            title: t("usdt__receive_network", variables: ["network": isDefaultNetwork ? t("common__default") : network]),
+            title: networkTitle,
             variant: .secondary,
             size: .small,
             icon: Image("usdt-network").resizable().frame(width: 16, height: 16),
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index fa15bf806..c733c893f 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -360,7 +360,8 @@ struct UsdtSendView: View {
     private var submittedContent: some View {
         VStack(alignment: .leading, spacing: 0) {
             if let quote {
-                UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount)).padding(.bottom, 32)
+                UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), displayAmount: usdtOverviewAmount(quote.amount))
+                    .padding(.bottom, 32)
             }
             if submittedStatus == .bridgeRefunded {
                 BodyMText(t("usdt__bridge_refunded_description"), textColor: .textSecondary)
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index 5e25116e1..34ebb2b17 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -18,7 +18,8 @@ struct UsdtWalletScreen: View {
             ScrollView(showsIndicators: false) {
                 VStack(alignment: .leading, spacing: 32) {
                     UsdtAmountHeader(
-                        amount: usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—", hideBalance: settings.hideBalance
+                        amount: usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—",
+                        displayAmount: usdt.balance.map { usdtOverviewAmount($0) }, hideBalance: settings.hideBalance
                     )
                     .balanceVisibilityToggle()
                     .accessibilityIdentifier("UsdtBalance")
@@ -107,6 +108,7 @@ struct UsdtCoinIllustration: View {
 
 struct UsdtAmountHeader: View {
     let amount: String
+    var displayAmount: String?
     var prefix = ""
     var hideBalance = false
 
@@ -121,7 +123,7 @@ struct UsdtAmountHeader: View {
                 CaptionMText("USDT", textColor: .textSecondary)
             }
             DisplayText(
-                "<accent>\(prefix)$</accent> " + (hideBalance ? " • • • • •" : amount),
+                "<accent>\(prefix)$</accent> " + (hideBalance ? " • • • • •" : displayAmount ?? amount),
                 accentColor: .textSecondary, accentFont: Fonts.extraBold
             )
             .lineLimit(1).minimumScaleFactor(0.5)
@@ -171,7 +173,9 @@ func usdtDisplaySats(amount: String, rate: PaykitExchangeRate?, now: Date = Date
     return NSDecimalNumber(decimal: rounded).intValue
 }
 
-func usdtOverviewAmount(_ amount: UInt64) -> String {
-    if amount > 0, amount < 10000 { return "<0.01" }
-    return (Decimal(amount) / 1_000_000).formatted(.number.precision(.fractionLength(0 ... 2)))
+func usdtOverviewAmount(_ amount: UInt64, locale: Locale = .current) -> String {
+    let format = Decimal.FormatStyle.number.precision(.fractionLength(0 ... 2))
+        .rounded(rule: .toNearestOrAwayFromZero).locale(locale)
+    if amount > 0, amount < 10000 { return "<" + (Decimal(1) / 100).formatted(format) }
+    return (Decimal(amount) / 1_000_000).formatted(format)
 }
diff --git a/BitkitTests/UsdtDisplayTests.swift b/BitkitTests/UsdtDisplayTests.swift
index 97191cb6d..2f8e407e4 100644
--- a/BitkitTests/UsdtDisplayTests.swift
+++ b/BitkitTests/UsdtDisplayTests.swift
@@ -14,9 +14,15 @@ final class UsdtDisplayTests: XCTestCase {
         XCTAssertNil(usdtDisplaySats(amount: "999999999999999999999999", rate: rate, now: now))
     }
 
-    func testSmallNonzeroBalancesRemainVisible() {
-        XCTAssertEqual(usdtOverviewAmount(0), "0")
-        XCTAssertEqual(usdtOverviewAmount(1), "<0.01")
-        XCTAssertEqual(usdtOverviewAmount(9999), "<0.01")
+    func testOverviewAmountsRoundToCentsWithoutHidingSmallBalances() {
+        let locale = Locale(identifier: "en_US")
+        for (amount, expected): (UInt64, String) in [
+            (0, "0"), (1, "<0.01"), (9999, "<0.01"), (10000, "0.01"),
+            (123_456_789, "123.46"), (1_025_000, "1.03"), (1_234_567_890, "1,234.57"),
+        ] {
+            XCTAssertEqual(usdtOverviewAmount(amount, locale: locale), expected, "amount: \(amount)")
+        }
+        XCTAssertEqual(usdtOverviewAmount(1, locale: Locale(identifier: "de_DE")), "<0,01")
+        XCTAssertEqual(usdtOverviewAmount(1_234_567_890, locale: Locale(identifier: "de_DE")), "1.234,57")
     }
 }
diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index 83290690c..263ab9c9f 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -75,7 +75,7 @@ Reference: [USDT designs](https://www.figma.com/design/ltqvnKiejWj0JQiqtDf2JJ/Bi
 
 - [ ] Check funded and empty Home and USDT wallet layouts; the USDT accent is #009393 throughout receive, send, Paykit, sharing and celebrations.
 - [ ] In Receive, open Network and select an enabled source. Verify the minimum-amount error is compact and clears on editing.
-- [ ] Enter an accepted amount, switch BTC/USD twice and verify the amount is preserved. Continue and verify Estimated Fees shows the expected deduction and received amount, then continues to the QR for that network.
+- [ ] Enter an accepted dollar amount and verify its BTC equivalent. Continue and verify Estimated Fees shows the expected deduction and received amount, then continues to the QR for that network.
 - [ ] Open address details, verify Copy and QR target the same address, and return to the QR.
 - [ ] Back out of an unprepared network and verify the displayed network always matches the QR. Return to Arbitrum and verify its original wallet address.
 - [ ] With an authorized incoming transfer or an explicitly identified fixture, verify teal receive confetti, Details and OK; Details opens that transfer.
diff --git a/journeys/usdt-receive-amount-and-units.xml b/journeys/usdt-receive-amount-and-units.xml
index 0e390d973..d6fbad9fd 100644
--- a/journeys/usdt-receive-amount-and-units.xml
+++ b/journeys/usdt-receive-amount-and-units.xml
@@ -2,10 +2,10 @@
   <description>Use an onboarded wallet with USDT configured and a fresh BTC/USD rate. No payment is submitted. Cross-network estimates require a live enabled provider and are covered by the manual USDT checks.</description>
   <actions>
     <action>Open USDT from Home. Verify the USDT balance, teal Tether icon and existing activity rows.</action>
-    <action>Open Receive. Verify Receive Dollars, the USDT tab and Network: Default.</action>
+    <action>Open Receive. Verify Receive Dollars, the USDT tab and Network: Arbitrum One on the QR screen.</action>
     <action>Tap Edit. Enter 3.5. Verify the dollar amount and BTC equivalent are displayed, there is no input-unit toggle, the keypad follows the divider, and Continue stays at the bottom without overlap.</action>
     <action>Continue to the QR. Verify it requests the Arbitrum USDT token, the wallet address and uint256=3500000, never Bitcoin.</action>
-    <action>Open Show Details. Verify the same Arbitrum address and teal Copy control. Open Network and verify Arbitrum is marked Default and all enabled bridge networks remain available. Return to the QR.</action>
+    <action>Open Share and verify the shared text includes Network: Arbitrum One and the exact payment URI. Cancel sharing. Open Show Details. Verify Network: Arbitrum One, the same Arbitrum address and teal Copy control. Verify Share includes the same network and payment URI, while Copy contains only the address. Open Network and verify Arbitrum is marked Default and all enabled bridge networks remain available. Return to the QR.</action>
     <action>Select Savings. Verify Receive Bitcoin and a Bitcoin QR. Select USDT and verify Receive Dollars and the Arbitrum USDT QR.</action>
     <action>Close Receive and return Home. Open a USDT activity row, then Show All. Verify USDT details and mixed activity remain reachable.</action>
   </actions>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index a6511a552..e4d918932 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -2,7 +2,7 @@
   <description>Use an onboarded wallet in an E2E build with USDT RPC and bundler URLs configured. No chain funding or live provider is required. A network error may be visible when services are offline; no payment is submitted.</description>
   <actions>
     <action>On Home, verify the Savings/Spending and USDT balance dividers align vertically, including any hardware wallet rows.</action>
-    <action>Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet, with its Tether coin illustration anchored at the upper right.</action>
+    <action>Verify USDT balances and activity amounts show at most two decimals; a nonzero amount below one cent shows &lt;0.01. Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet, with its Tether coin illustration anchored at the upper right.</action>
     <action>Open Receive. Verify the address starts with 0x and the network is Arbitrum One. Open details and verify Copy and the QR show the same address.</action>
     <action>Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing.</action>
     <action>Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote.</action>

From 377ee54341362ba2769d5603eedfd153cda9cf85 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Sun, 11 Oct 2026 21:21:16 -0500
Subject: [PATCH 12/62] Preserve quoted payment terms and recovery across
 request flows

---
 Bitkit/Models/PaykitRequestPricing.swift      |   2 +-
 Bitkit/Services/BackupService.swift           |  14 +-
 .../Services/PaykitPaymentProofService.swift  |  35 +++-
 .../PaykitPaymentRequestService.swift         |  32 ++--
 Bitkit/Services/PaykitSubscription.swift      |   1 -
 .../Services/PaykitUsdtPaymentService.swift   |   2 +-
 .../PrivatePaykitService+Payments.swift       |   2 +-
 .../Utilities/PaymentNavigationHelper.swift   |   4 +-
 Bitkit/ViewModels/AppViewModel.swift          |   9 +-
 .../Wallets/Send/SendConfirmationView.swift   |   2 +-
 Bitkit/Views/Wallets/Send/SendSheet.swift     |  68 ++++---
 .../PaykitPaymentProofServiceTests.swift      | 180 ++++++++++--------
 .../PaykitPaymentRequestServiceTests.swift    | 104 +++++-----
 13 files changed, 265 insertions(+), 190 deletions(-)

diff --git a/Bitkit/Models/PaykitRequestPricing.swift b/Bitkit/Models/PaykitRequestPricing.swift
index a67d2a2a1..0838af7d7 100644
--- a/Bitkit/Models/PaykitRequestPricing.swift
+++ b/Bitkit/Models/PaykitRequestPricing.swift
@@ -34,7 +34,7 @@ struct PaykitRequestPricing: Hashable {
         var selected: Paykit.PaymentConversionQuoteRecord?
         switch conversion {
         case let .fixed(values):
-            guard quoteId == nil else { throw PaykitAmountError.invalidAmount }
+            guard quoteId == nil, !values.isEmpty, Set(values.map(\.asset)).count == values.count else { throw PaykitAmountError.invalidAmount }
             rates = values
         case .perPeriod:
             if requested.asset != asset || quoteId != nil {
diff --git a/Bitkit/Services/BackupService.swift b/Bitkit/Services/BackupService.swift
index 332a9d26a..78fccefba 100644
--- a/Bitkit/Services/BackupService.swift
+++ b/Bitkit/Services/BackupService.swift
@@ -360,6 +360,7 @@ class BackupService {
                     // VssBackupClient's existing custom backup namespace is explicitly wallet index 0.
                     let backupWallet = try await PaykitPaymentStateBackup.ActiveOnchainAttempt.Wallet.backupNamespace(index: 0)
                     try await PaykitPaymentProofService.shared.restoreBackup(paymentState, wallet: backupWallet)
+                    if let usdt = paymentState.usdt { try await PaykitUsdtPaymentService.shared.restoreBackup(usdt) }
                 }
                 try TransferStorage.shared.upsertList(payload.transfers)
                 await PrivatePaykitAddressReservationStore.shared.restoreBackup(payload.privatePaykitHighestReservedReceiveIndexByAddressType)
@@ -551,6 +552,8 @@ class BackupService {
             .merge(with: PaykitPaymentRequestIdStore.walletBackupDataChangedPublisher)
             .merge(with: PaykitPaymentProofService.proofStateChangedPublisher)
             .merge(with: OnchainSendAttemptStore.walletBackupDataChangedPublisher)
+            .merge(with: UsdtWalletManager.walletBackupDataChangedPublisher)
+            .merge(with: PaykitUsdtPaymentService.walletBackupDataChangedPublisher)
             .debounce(for: .milliseconds(500), scheduler: DispatchQueue.main)
             .sink { [weak self] _ in
                 guard let self, !self.shouldSkipBackup() else { return }
@@ -922,7 +925,11 @@ class BackupService {
                 guard !Env.isUsdtEnabled else { throw UsdtError.BackupUnavailable }
                 usdtSnapshot = nil
             }
-            let payload = try await WalletBackupV1(
+            var paymentState = try await PaykitPaymentProofService.shared.backupSnapshot(
+                wallet: PaykitPaymentStateBackup.ActiveOnchainAttempt.Wallet.backupNamespace(index: 0)
+            )
+            paymentState.usdt = try await PaykitUsdtPaymentService.shared.backupSnapshot()
+            let payload = WalletBackupV1(
                 version: 1,
                 createdAt: UInt64(Date().timeIntervalSince1970 * 1000),
                 transfers: transfers,
@@ -930,9 +937,8 @@ class BackupService {
                 paykitSdkBackupState: paykitSdkBackupState,
                 watchOnlyAccounts: watchOnlyAccountSnapshot.accounts,
                 watchOnlyAccountAllocationState: watchOnlyAccountSnapshot.allocationState,
-                paykitPaymentState: PaykitPaymentProofService.shared.backupSnapshot(
-                    wallet: PaykitPaymentStateBackup.ActiveOnchainAttempt.Wallet.backupNamespace(index: 0)
-                )
+                usdtWallet: usdtSnapshot,
+                paykitPaymentState: paymentState
             )
             return try JSONEncoder().encode(payload)
 
diff --git a/Bitkit/Services/PaykitPaymentProofService.swift b/Bitkit/Services/PaykitPaymentProofService.swift
index fac915aa1..d7003e58d 100644
--- a/Bitkit/Services/PaykitPaymentProofService.swift
+++ b/Bitkit/Services/PaykitPaymentProofService.swift
@@ -343,7 +343,8 @@ actor PaykitPaymentProofService {
         request: PaykitPaymentRequest,
         paymentAppId: String,
         paymentEndpointIdentifier: String,
-        kind: PaykitPaymentProofKind
+        kind: PaykitPaymentProofKind,
+        paymentTerms: PaykitRequestPricing.Payment? = nil
     ) async throws {
         if try await attemptService.hasAttempt(for: request.id) {
             if kind == .onchain,
@@ -353,12 +354,21 @@ actor PaykitPaymentProofService {
             }
             throw PaykitPaymentRequestError.operationInProgress
         }
-        let proof = try await pendingProof(
+        var proof = try await pendingProof(
             request: request,
             paymentAppId: paymentAppId,
             paymentEndpointIdentifier: paymentEndpointIdentifier,
             kind: kind
         )
+        guard let method = PublicPaykitService.MethodId(rawValue: paymentEndpointIdentifier) else {
+            throw PaykitPaymentRequestError.requestUnavailable
+        }
+        let payment = try request.payment(using: method, quoteId: paymentTerms?.quoteId)
+        guard payment.isValid(at: Date()), paymentTerms == nil || payment == paymentTerms else {
+            throw PaykitPaymentRequestError.amountMismatch
+        }
+        proof.conversionQuoteId = payment.quoteId
+        if kind == .onchain { proof.onchainAmountSats = payment.amount.atomic }
         try await mutationLock.withLock { try await prepareLocked(request: request, proof: proof) }
     }
 
@@ -493,7 +503,7 @@ actor PaykitPaymentProofService {
         let request: PaykitPaymentRequest
         if let period = proof.billingPeriod {
             guard let subscription = PaykitSubscription(record: record), subscription.isPayer,
-                  subscription.isActive(at: now), !subscription.hasPaymentDeadline,
+                  subscription.isActive(at: now),
                   subscription.recurrence.unit.isSupported, subscription.recurrence.canMaterializePeriods,
                   period.startsAt <= now, subscription.recurrence.contains(period)
             else { throw PaykitPaymentRequestError.requestUnavailable }
@@ -504,7 +514,7 @@ actor PaykitPaymentProofService {
             }
             request = original
         }
-        guard request.id == requestId, request.amountSats == attempt.amountSats, !request.requiresAcceptance,
+        guard request.id == requestId, request.matchesOnchainPayment(proof, amountSats: attempt.amountSats), !request.requiresAcceptance,
               request.acceptedPaymentEndpointIdentifiers.contains(proof.paymentEndpointIdentifier),
               !request.isExpired(at: Date()), record.state != .proofSubmitted,
               !record.paymentProofs.contains(where: { Self.billingPeriod($0.billingPeriod, matches: proof.billingPeriod) })
@@ -625,7 +635,7 @@ actor PaykitPaymentProofService {
         }
         pendingProofs[index].paymentStarted = true
         pendingProofs[index].onchainAddress = address
-        pendingProofs[index].onchainAmountSats = request.amountSats
+        guard request.matchesOnchainPayment(pendingProofs[index]) else { throw PaykitPaymentRequestError.amountMismatch }
         pendingProofs[index].onchainWalletId = hardwareWalletId
         pendingProofs[index].paymentIdentifier = signedTxid
         pendingProofs[index].hardwareSignedTransaction = serializedTx
@@ -1109,7 +1119,11 @@ actor PaykitPaymentProofService {
                 }) else { return }
                 // Only an exact, definitely unsent receipt authorizes releasing its consumed version.
                 if let version = original.privatePaymentListVersion {
-                    try await privatePaykitService.releaseUnsentPaymentListVersion(publicKey: request.counterparty, version: version, previousVersion: original.previousPrivatePaymentListVersion)
+                    try await privatePaykitService.releaseUnsentPaymentListVersion(
+                        publicKey: request.counterparty,
+                        version: version,
+                        previousVersion: original.previousPrivatePaymentListVersion
+                    )
                 }
                 do {
                     try await persist(proofs.filter { $0 != original })
@@ -1341,7 +1355,7 @@ actor PaykitPaymentProofService {
     func retainedHardwarePaymentForRetry(request: PaykitPaymentRequest) async throws -> PendingPaykitPaymentProof? {
         let identity = try await currentIdentity()
         let proof = await retainedHardwarePaymentsForRetry(identity: identity)[request.id]
-        guard let proof, proof.onchainAmountSats == request.amountSats, proof.billingPeriod == request.billingPeriod,
+        guard let proof, request.matchesOnchainPayment(proof), proof.billingPeriod == request.billingPeriod,
               request.acceptedPaymentEndpointIdentifiers.contains(proof.paymentEndpointIdentifier)
         else { return nil }
         return proof
@@ -1401,7 +1415,7 @@ actor PaykitPaymentProofService {
     func consumeOnchainPaymentResolution(_ resolution: PaykitOnchainPaymentResolution, activeIdentity: String?) async {
         if resolution.walletId != WalletScope.default {
             guard PubkyPublicKeyFormat.matches(activeIdentity, resolution.identity),
-                  PubkyPublicKeyFormat.matches((try? await sdk.identityStatus())?.publicKey, resolution.identity)
+                  await PubkyPublicKeyFormat.matches((try? sdk.identityStatus())?.publicKey, resolution.identity)
             else {
                 if Self.onchainPaymentResolutionSubject.value == resolution {
                     Self.onchainPaymentResolutionSubject.send(nil)
@@ -1441,6 +1455,11 @@ actor PaykitPaymentProofService {
         return identity
     }
 
+    func submitUsdtProof(_ proof: PendingPaykitPaymentProof) async -> Bool {
+        guard proof.kind == .usdt else { return false }
+        return await submit(proof)
+    }
+
     @discardableResult
     private func submit(_ pendingProof: PendingPaykitPaymentProof) async -> Bool {
         guard !pendingProof.hasUnsupportedOnchainWallet ||
diff --git a/Bitkit/Services/PaykitPaymentRequestService.swift b/Bitkit/Services/PaykitPaymentRequestService.swift
index 7a1437862..6758485e8 100644
--- a/Bitkit/Services/PaykitPaymentRequestService.swift
+++ b/Bitkit/Services/PaykitPaymentRequestService.swift
@@ -161,23 +161,14 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         } else {
             paymentDeadline = nil
         }
-        var acceptedPaymentEndpointIdentifiers = PaykitIssuerInterop.supportedEndpointIdentifiers(
+        guard let asset = PaykitAsset(rawValue: terms.amount.asset) else { return .failure(.unsupportedAsset) }
+        guard let amount = try? PaykitAmount(asset: asset, value: terms.amount.value) else { return .failure(.invalidAmount) }
+        guard asset != .btc || amount.atomic <= UInt64.max / 1000 else { return .failure(.amountOutOfRange) }
+
+        let acceptedPaymentEndpointIdentifiers = PaykitIssuerInterop.supportedEndpointIdentifiers(
             terms.acceptedPaymentEndpointIdentifiers,
             network: network
         )
-        let amountSats: UInt64
-        if terms.conversion != nil {
-            guard let payment = PaykitBitcoinRequestPricing.bitcoinPayment(terms: terms, endpoints: acceptedPaymentEndpointIdentifiers) else {
-                return .failure(.unsupportedPricing)
-            }
-            amountSats = payment.amountSats
-            acceptedPaymentEndpointIdentifiers = payment.endpointIdentifiers
-        } else {
-            guard terms.amount.asset == PaykitIssuerInterop.bitcoinAsset else { return .failure(.unsupportedAsset) }
-            guard let sats = Self.sats(fromBitcoinAmount: terms.amount.value) else { return .failure(.invalidAmount) }
-            guard sats <= UInt64.max / 1000 else { return .failure(.amountOutOfRange) }
-            amountSats = sats
-        }
         if requiresActionableRequest, acceptedPaymentEndpointIdentifiers.isEmpty {
             return .failure(.noSupportedEndpoint)
         }
@@ -368,6 +359,15 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         try pricing.payment(requested: amount, endpoint: method.rawValue, period: billingPeriod, at: date, quoteId: quoteId)
     }
 
+    func matchesOnchainPayment(_ proof: PendingPaykitPaymentProof, amountSats: UInt64? = nil) -> Bool {
+        guard let method = PublicPaykitService.MethodId(rawValue: proof.paymentEndpointIdentifier),
+              let amount = amountSats ?? proof.onchainAmountSats,
+              let payment = try? payment(using: method, quoteId: proof.conversionQuoteId),
+              payment.amount.asset == .btc, payment.isValid(at: Date())
+        else { return false }
+        return payment.amount.atomic == amount
+    }
+
     func acceptsLightningInvoiceAmount(milliSatoshis: UInt64?, paymentTerms: PaykitRequestPricing.Payment? = nil, at date: Date = Date()) -> Bool {
         guard let milliSatoshis else { return true }
         guard let payment = try? payment(using: .bitcoinLightningBolt11, at: date, quoteId: paymentTerms?.quoteId),
@@ -2495,7 +2495,7 @@ final class PaykitPaymentRequestManager {
                 return (subscription, requests)
             }
             let retainedRetryRequests = snapshot.incoming + snapshot.history + recurringRequestsBySubscription
-                .filter { $0.0.lifecycleState == .activeRecurring && !$0.0.hasPaymentDeadline }
+                .filter { $0.0.lifecycleState == .activeRecurring }
                 .flatMap { $0.1.filter { $0.lifecycleState == .activeRecurring } }
             retainedHardwareRetries = retainedRetries.filter { id, proof in
                 guard id == proof.requestId, !locallyCompletedRequestIds.contains(id),
@@ -2504,7 +2504,7 @@ final class PaykitPaymentRequestManager {
                       let request = retainedRetryRequests.first(where: { $0.id == id }),
                       request.direction == .incoming,
                       [.accepted, .recoveryRequired, .activeRecurring].contains(request.lifecycleState),
-                      request.amountSats == proof.onchainAmountSats,
+                      request.matchesOnchainPayment(proof),
                       request.billingPeriod == proof.billingPeriod,
                       request.acceptedPaymentEndpointIdentifiers.contains(proof.paymentEndpointIdentifier)
                 else { return false }
diff --git a/Bitkit/Services/PaykitSubscription.swift b/Bitkit/Services/PaykitSubscription.swift
index 7afbecf1c..4f64e6f47 100644
--- a/Bitkit/Services/PaykitSubscription.swift
+++ b/Bitkit/Services/PaykitSubscription.swift
@@ -576,7 +576,6 @@ struct PaykitSubscription: Identifiable, Hashable {
         }
 
         guard let terms = record.terms,
-              terms.conversion == nil,
               let recurrence = terms.recurrence.flatMap(PaykitSubscriptionRecurrence.init),
               let asset = PaykitAsset(rawValue: terms.amount.asset),
               let amount = try? PaykitAmount(asset: asset, value: terms.amount.value),
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
index c06186a4a..de8741900 100644
--- a/Bitkit/Services/PaykitUsdtPaymentService.swift
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -348,7 +348,7 @@ final class PaykitUsdtPaymentService {
                                                         kind: .usdt, billingPeriod: attempt.billingPeriod,
                                                         paymentIdentifier: attempt.quoteId, proofData: data,
                                                         conversionQuoteId: binding.conversionQuoteId.isEmpty ? nil : binding.conversionQuoteId)
-                if await PaykitPaymentProofService.shared.submit(pending) {
+                if await PaykitPaymentProofService.shared.submitUsdtProof(pending) {
                     var current = try load()
                     if let index = current.attempts.firstIndex(where: { $0.quoteId == attempt.quoteId && $0.wallet == owner }) {
                         current.attempts[index].proofQueued = true
diff --git a/Bitkit/Services/PrivatePaykitService+Payments.swift b/Bitkit/Services/PrivatePaykitService+Payments.swift
index 7160274d7..8fe66857b 100644
--- a/Bitkit/Services/PrivatePaykitService+Payments.swift
+++ b/Bitkit/Services/PrivatePaykitService+Payments.swift
@@ -90,7 +90,7 @@ extension PrivatePaykitService {
         proof: PendingPaykitPaymentProof, request: PaykitPaymentRequest
     ) -> PublicPaykitPaymentLaunchResult? {
         guard proof.requestId == request.id, proof.retainedHardwareRetry != nil,
-              proof.onchainAmountSats == request.amountSats, proof.billingPeriod == request.billingPeriod,
+              request.matchesOnchainPayment(proof), proof.billingPeriod == request.billingPeriod,
               let address = proof.onchainAddress,
               request.acceptedPaymentEndpointIdentifiers.contains(proof.paymentEndpointIdentifier)
         else { return nil }
diff --git a/Bitkit/Utilities/PaymentNavigationHelper.swift b/Bitkit/Utilities/PaymentNavigationHelper.swift
index dc650331e..9e837a9fd 100644
--- a/Bitkit/Utilities/PaymentNavigationHelper.swift
+++ b/Bitkit/Utilities/PaymentNavigationHelper.swift
@@ -113,7 +113,7 @@ struct PaymentNavigationHelper {
         spendStore: QuickPaySpendStore = .shared,
         coordinator: QuickPayPaymentCoordinator? = nil
     ) -> SendRoute? {
-        if app.contactPaymentContext?.requiresAssetSelection == true { return .amount }
+        if app.contactPaymentContext?.requiresAssetSelection == true, app.paykitPaymentTerms == nil { return .amount }
         if let lnurlWithdrawData = app.lnurlWithdrawData {
             if lnurlWithdrawData.isFixedAmount {
                 return .lnurlWithdrawConfirm
@@ -202,7 +202,7 @@ struct PaymentNavigationHelper {
         spendStore: QuickPaySpendStore = .shared,
         coordinator: QuickPayPaymentCoordinator? = nil
     ) -> SendRoute? {
-        if app.contactPaymentContext?.requiresAssetSelection == true { return .amount }
+        if app.contactPaymentContext?.requiresAssetSelection == true, app.paykitPaymentTerms == nil { return .amount }
         guard let route = appropriateSendRoute(
             app: app,
             currency: currency,
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index 8db47411b..f61e688f6 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -1000,11 +1000,16 @@ extension AppViewModel {
         guard ownsContactPaymentContext(context), let request = context.incomingPaymentRequest,
               context.publicKey == request.counterparty,
               PrivatePaykitService.retainedHardwarePaymentLaunchResult(proof: proof, request: request) != nil,
-              let address = proof.onchainAddress
+              let address = proof.onchainAddress, let amount = proof.onchainAmountSats
         else { throw PaykitPaymentRequestError.requestUnavailable }
+        guard let method = PublicPaykitService.MethodId(rawValue: proof.paymentEndpointIdentifier) else {
+            throw PaykitPaymentRequestError.requestUnavailable
+        }
+        paykitPaymentTerms = try request.payment(using: method, quoteId: proof.conversionQuoteId)
+        paykitReviewedAmount = paykitPaymentTerms?.amount
         // This route submits an existing transaction, so it never admits fresh inputs against a balance.
         handleScannedOnchainInvoice(OnChainInvoice(
-            address: address, amountSatoshis: request.amountSats, label: nil, message: nil, params: nil
+            address: address, amountSatoshis: amount, label: nil, message: nil, params: nil
         ))
     }
 
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index 35913ba0b..af8a17967 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -1272,7 +1272,7 @@ struct SendConfirmationView: View {
                 }
 
                 // The accepted attempt owns the original amount and metadata during local resume.
-                wallet.sendAmountSats = savedActivity?.value ?? incomingPaymentRequest?.amountSats ?? amount
+                wallet.sendAmountSats = savedActivity?.value ?? amount
 
                 Logger.info("Onchain send result txid: \(txid)")
 
diff --git a/Bitkit/Views/Wallets/Send/SendSheet.swift b/Bitkit/Views/Wallets/Send/SendSheet.swift
index 666480fb6..0b14e8c29 100644
--- a/Bitkit/Views/Wallets/Send/SendSheet.swift
+++ b/Bitkit/Views/Wallets/Send/SendSheet.swift
@@ -188,7 +188,9 @@ struct SendSheet: View {
     /// If there are no channels at all, we should NOT wait behind the sync UI – that's a capacity issue, not a sync issue.
     /// For onchain: only need node running.
     private var shouldShowSyncOverlay: Bool {
-        if isPreparingRequest || hwSend.isActive || isResumingAcceptedOrdinarySend {
+        if isPreparingRequest || hwSend.isActive || isResumingAcceptedOrdinarySend || app.paykitUsesUsdt ||
+            (app.contactPaymentContext?.requiresAssetSelection == true && navigationPath.isEmpty)
+        {
             return false
         }
 
@@ -245,7 +247,14 @@ struct SendSheet: View {
         .sheet(isPresented: reconnectPairingBinding) {
             HardwarePairingSheet(config: HardwarePairingSheetItem())
         }
-        .offlineSheetOverlay(title: t("wallet__send_bitcoin"), forceShow: syncTimedOut, isEnabled: !isPreparingRequest && !isResumingAcceptedOrdinarySend)
+        .sheet(isPresented: Binding(get: { usdtDetails != nil }, set: { if !$0 { usdtDetails = nil } })) {
+            if let id = usdtDetails { UsdtActivityDetail(transferId: id) }
+        }
+        .offlineSheetOverlay(
+            title: t("wallet__send_bitcoin"),
+            forceShow: syncTimedOut,
+            isEnabled: !isPreparingRequest && !isResumingAcceptedOrdinarySend
+        )
         .onChange(of: shouldDismissUnavailableRequest) { _, shouldDismiss in
             guard shouldDismiss else { return }
             sheets.hideSheetIfActive(isEmbedded ? .subscription : .send, reason: "Incoming payment request is no longer available")
@@ -372,7 +381,10 @@ struct SendSheet: View {
             if PaykitSubscriptionNotificationTargetStore.load()?.matches(request) == true {
                 PaykitSubscriptionNotificationTargetStore.clear()
             }
-            wallet.sendAmountSats = try? request.payment(using: app.paykitPaymentMethod).amount.atomic
+            wallet.sendAmountSats = try? request.payment(
+                using: app.paykitPaymentMethod,
+                quoteId: app.paykitPaymentTerms?.quoteId
+            ).amount.atomic
             incomingPaymentRequest = request
         } else {
             tagManager.clearSelectedTags()
@@ -384,29 +396,29 @@ struct SendSheet: View {
         }
         setupTask?.cancel()
         setupTask = Task {
-                if incomingPaymentRequest == nil, config.hardwareWalletId == nil,
-                   currentRoot == .options || app.selectedWalletToPayFrom == .onchain
-                {
-                    do {
-                        if let attempt = try await OnchainSendAttemptService.shared.unresolvedAttempt(
-                            walletId: OnchainSendAttemptService.walletId(index: LightningService.shared.currentWalletIndex)
-                        ) {
-                            let context = OnchainSendPendingContext(attemptId: attempt.id, walletId: attempt.walletId, txid: attempt.txid)
-                            if attempt.requestId != nil || attempt.orderId != nil || attempt.status != .accepted {
-                                hasValidatedAfterSync = true
-                                replaceRootRoute(with: .onchainOperationPending(context, requestId: attempt.requestId))
-                                return
-                            }
-                            isResumingAcceptedOrdinarySend = true
+            if incomingPaymentRequest == nil, config.hardwareWalletId == nil,
+               currentRoot == .options || app.selectedWalletToPayFrom == .onchain
+            {
+                do {
+                    if let attempt = try await OnchainSendAttemptService.shared.unresolvedAttempt(
+                        walletId: OnchainSendAttemptService.walletId(index: LightningService.shared.currentWalletIndex)
+                    ) {
+                        let context = OnchainSendPendingContext(attemptId: attempt.id, walletId: attempt.walletId, txid: attempt.txid)
+                        if attempt.requestId != nil || attempt.orderId != nil || attempt.status != .accepted {
                             hasValidatedAfterSync = true
-                            app.selectedWalletToPayFrom = .onchain
-                            replaceRootRoute(with: Self.acceptedOrdinaryStartupRoute(attempt: attempt))
+                            replaceRootRoute(with: .onchainOperationPending(context, requestId: attempt.requestId))
                             return
                         }
-                    } catch {
-                        Logger.warn("Could not inspect retained on-chain follow-up", context: "SendSheet")
+                        isResumingAcceptedOrdinarySend = true
+                        hasValidatedAfterSync = true
+                        app.selectedWalletToPayFrom = .onchain
+                        replaceRootRoute(with: Self.acceptedOrdinaryStartupRoute(attempt: attempt))
+                        return
                     }
+                } catch {
+                    Logger.warn("Could not inspect retained on-chain follow-up", context: "SendSheet")
                 }
+            }
             do {
                 try await wallet.loadFeeRateWithRetry(speed: settings.defaultTransactionSpeed)
             } catch is CancellationError {
@@ -414,9 +426,9 @@ struct SendSheet: View {
             } catch {
                 Logger.error("Failed to set default fee rate: \(error)")
             }
-            if let request = incomingPaymentRequest, app.contactPaymentContext?.requiresAssetSelection != true {
+            if let request = incomingPaymentRequest, app.contactPaymentContext?.requiresAssetSelection != true || app.paykitPaymentTerms != nil {
                 guard isCurrentIncomingRequest(request.id) else { return }
-                guard let amount = try? request.payment(using: app.paykitPaymentMethod).amount.atomic,
+                guard let amount = try? request.payment(using: app.paykitPaymentMethod, quoteId: app.paykitPaymentTerms?.quoteId).amount.atomic,
                       await selectHardwareFundingSourceIfNeeded(amountSats: amount, requestId: request.id) else { return }
                 guard isCurrentIncomingRequest(request.id) else { return }
                 if !shouldShowSyncOverlay {
@@ -1011,14 +1023,20 @@ struct SendSheet: View {
             request: request,
             paymentAppId: privateContext.paymentAppId(for: endpointIdentifier),
             paymentEndpointIdentifier: endpointIdentifier,
-            kind: .onchain
+            kind: .onchain,
+            paymentTerms: paymentTerms
         )
         let previousVersion = await PrivatePaykitService.shared.consumedPaymentListVersion(publicKey: request.counterparty, attemptId: context?.id)
         do {
             try await prepareIncomingPaymentRequest(context: context)
             guard context.map(app.ownsContactPaymentContext) == true, !request.isExpired(at: Date()),
+                  signedTx.totalSpent >= signedTx.miningFeeSats,
                   paymentTerms != nil || request.amount.asset == .btc,
-                  request.acceptsPaymentAmount(signedTx.totalSpentSats - signedTx.miningFeeSats, method: PublicPaykitService.onchainMethodId(for: address), paymentTerms: paymentTerms)
+                  request.acceptsPaymentAmount(
+                      signedTx.totalSpent - signedTx.miningFeeSats,
+                      method: PublicPaykitService.onchainMethodId(for: address),
+                      paymentTerms: paymentTerms
+                  )
             else { throw PaykitPaymentRequestError.amountMismatch }
             try await PaykitPaymentProofService.shared.markOnchainPaymentStarted(
                 request, address: address, hardwareWalletId: walletId, paymentIdentity: paymentIdentity,
diff --git a/BitkitTests/PaykitPaymentProofServiceTests.swift b/BitkitTests/PaykitPaymentProofServiceTests.swift
index 2120918b5..5a433d242 100644
--- a/BitkitTests/PaykitPaymentProofServiceTests.swift
+++ b/BitkitTests/PaykitPaymentProofServiceTests.swift
@@ -22,8 +22,8 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             let attemptsStore = MemoryAttemptStore()
             let attempts = OnchainSendAttemptService(store: attemptsStore, localFollowup: FailingShopActivityFollowup())
             let sender = PreparedAttemptNodeMock()
-            sender.amount = request.amountSats
-            _ = try await attempts.send(using: sender, address: onchainAddress, amountSats: request.amountSats,
+            sender.amount = request.amount.atomic
+            _ = try await attempts.send(using: sender, address: onchainAddress, amountSats: request.amount.atomic,
                                         satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false,
                                         requestId: request.id, paymentIdentity: identity)
             let original = try XCTUnwrap(attemptsStore.snapshot().first)
@@ -37,7 +37,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
                     XCTAssertEqual(admitted.requestId, request.id)
                     XCTAssertEqual(admitted.recoveryContext?.paymentIdentity, self.identity)
                     XCTAssertEqual(admitted.address, self.onchainAddress)
-                    XCTAssertEqual(admitted.amountSats, request.amountSats)
+                    XCTAssertEqual(admitted.amountSats, request.amount.atomic)
                 }
             )
             let proof = PendingPaykitPaymentProof(
@@ -46,7 +46,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
                 paymentStarted: true, paymentIdentifier: mismatch == 2 ? String(repeating: "ef", count: 32) : originalId,
                 proofData: mismatch == 5 ? originalId : nil,
                 onchainAddress: mismatch == 3 ? "different-address" : onchainAddress,
-                onchainAmountSats: mismatch == 4 ? request.amountSats - 1 : request.amountSats,
+                onchainAmountSats: mismatch == 4 ? request.amount.atomic - 1 : request.amount.atomic,
                 onchainAcceptanceVerified: mismatch == 5
             )
             let store = PaymentProofMemoryStore()
@@ -105,8 +105,8 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             let attemptsStore = MemoryAttemptStore()
             let attempts = OnchainSendAttemptService(store: attemptsStore)
             let sender = PreparedAttemptNodeMock()
-            sender.amount = request.amountSats
-            _ = try await attempts.send(using: sender, address: onchainAddress, amountSats: request.amountSats,
+            sender.amount = request.amount.atomic
+            _ = try await attempts.send(using: sender, address: onchainAddress, amountSats: request.amount.atomic,
                                         satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false,
                                         requestId: request.id, paymentIdentity: identity)
             let original = try XCTUnwrap(attemptsStore.snapshot().first)
@@ -114,7 +114,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
                 identity: identity, requestId: request.id, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain,
                 paymentStarted: invalid < 4, paymentIdentifier: original.txid, proofData: nil,
                 onchainAddress: invalid % 4 == 2 ? "foreign-address" : onchainAddress,
-                onchainAmountSats: request.amountSats
+                onchainAmountSats: request.amount.atomic
             )
             let store = PaymentProofMemoryStore()
             await store.seed([proof])
@@ -124,7 +124,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
                 let authorized = try await service.authorizeOnchainRecovery(original, restoreStartedProof: false)
                 XCTAssertEqual(invalid % 4, 0)
                 XCTAssertEqual(authorized.id, request.id)
-                XCTAssertEqual(authorized.amountSats, request.amountSats)
+                XCTAssertEqual(authorized.amount.atomic, request.amount.atomic)
             } catch { XCTAssertNotEqual(invalid % 4, 0) }
             let saved = await store.snapshot()
             let submissions = await sdk.submissionCount()
@@ -147,15 +147,15 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let attemptsStore = MemoryAttemptStore()
         let attempts = OnchainSendAttemptService(store: attemptsStore)
         let sender = PreparedAttemptNodeMock()
-        sender.amount = request.amountSats
-        _ = try await attempts.send(using: sender, address: onchainAddress, amountSats: request.amountSats,
+        sender.amount = request.amount.atomic
+        _ = try await attempts.send(using: sender, address: onchainAddress, amountSats: request.amount.atomic,
                                     satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false,
                                     requestId: request.id, paymentIdentity: identity)
         let original = try XCTUnwrap(attemptsStore.snapshot().first)
         let proof = PendingPaykitPaymentProof(
             identity: identity, requestId: request.id, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint,
             kind: .onchain, billingPeriod: period, paymentStarted: true,
-            paymentIdentifier: original.txid, proofData: nil, onchainAddress: onchainAddress, onchainAmountSats: request.amountSats
+            paymentIdentifier: original.txid, proofData: nil, onchainAddress: onchainAddress, onchainAmountSats: request.amount.atomic
         )
         let store = PaymentProofMemoryStore()
         await store.seed([proof])
@@ -164,19 +164,19 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let authorized = try await service.authorizeOnchainRecovery(original, restoreStartedProof: false)
         XCTAssertEqual(authorized.id, request.id)
         XCTAssertEqual(authorized.billingPeriod, period)
-        XCTAssertEqual(authorized.amountSats, original.amountSats)
+        XCTAssertEqual(authorized.amount.atomic, original.amountSats)
         let saved = await store.snapshot()
         let submissions = await sdk.submissionCount()
         XCTAssertEqual(saved, [proof])
         XCTAssertEqual(submissions, 0)
         XCTAssertEqual(sender.broadcasts, 1)
         let settledProof = try paymentProofRecord(endpoint: endpoint, kind: .onchain,
-                                                 data: try XCTUnwrap(original.txid), billingPeriod: period.sdkValue)
-        let invalidRecords = [
-            try paymentRequestRecord(endpoints: [endpoint], paymentProofs: [settledProof], state: .activeRecurring, recurrence: recurrence),
-            try paymentRequestRecord(endpoints: [endpoint], state: .canceled, recurrence: recurrence),
-            try paymentRequestRecord(endpoints: [PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue],
-                                     state: .activeRecurring, recurrence: recurrence),
+                                                  data: XCTUnwrap(original.txid), billingPeriod: period.sdkValue)
+        let invalidRecords = try [
+            paymentRequestRecord(endpoints: [endpoint], paymentProofs: [settledProof], state: .activeRecurring, recurrence: recurrence),
+            paymentRequestRecord(endpoints: [endpoint], state: .canceled, recurrence: recurrence),
+            paymentRequestRecord(endpoints: [PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue],
+                                 state: .activeRecurring, recurrence: recurrence),
         ]
         for invalid in invalidRecords {
             let invalidSdk = PaymentProofSdkMock(identity: identity, records: [invalid])
@@ -204,9 +204,18 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         func proof(payer: String, wallet: String, txid: String? = nil, verified: Bool = false,
                    requestId: PaykitPaymentRequest.ID? = nil) -> PendingPaykitPaymentProof
         {
-            PendingPaykitPaymentProof(identity: payer, requestId: requestId ?? request.id, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint,
-                                      kind: .onchain, paymentStarted: true, paymentIdentifier: txid, proofData: verified ? txid : nil,
-                                      onchainWalletId: wallet, onchainAcceptanceVerified: verified)
+            PendingPaykitPaymentProof(
+                identity: payer,
+                requestId: requestId ?? request.id,
+                paymentAppId: "bitkit",
+                paymentEndpointIdentifier: endpoint,
+                kind: .onchain,
+                paymentStarted: true,
+                paymentIdentifier: txid,
+                proofData: verified ? txid : nil,
+                onchainWalletId: wallet,
+                onchainAcceptanceVerified: verified
+            )
         }
         let otherRequest = try XCTUnwrap(PaykitPaymentRequest(record: paymentRequestRecord(
             endpoints: [endpoint], paymentRequestId: UUID().uuidString
@@ -278,7 +287,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             identity: identity, requestId: request.id, transactionId: txid, walletId: hardwareWalletId
         )
         XCTAssertEqual(resolutions, [originalResolution])
-        await service.consumeOnchainPaymentResolution(originalResolution, activeIdentity: (try? await sdk.identityStatus())?.publicKey)
+        await service.consumeOnchainPaymentResolution(originalResolution, activeIdentity: (try? sdk.identityStatus())?.publicKey)
         // Recreate the service to discard every process-local replay marker.
         let reopened = paymentProofService(sdk: sdk, store: store, hardwareLookup: lookup)
         await sdk.setIdentity(identity)
@@ -292,7 +301,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let awaitingConsumption = await store.snapshot().first { PubkyPublicKeyFormat.matches($0.identity, identity) }
         XCTAssertEqual(awaitingConsumption?.onchainResolutionAwaitingConsumption, true,
                        "Proof delivery must retain the original local result until its payer consumes it")
-        await reopened.consumeOnchainPaymentResolution(originalResolution, activeIdentity: (try? await sdk.identityStatus())?.publicKey)
+        await reopened.consumeOnchainPaymentResolution(originalResolution, activeIdentity: (try? sdk.identityStatus())?.publicKey)
         await reopened.reconcile()
         XCTAssertEqual(resolutions, [originalResolution, originalResolution], "Returning-payer replay occurs once")
         let lookups = await lookup.calls()
@@ -380,7 +389,12 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         }
         observing = true
         defer { subscription.cancel() }
-        let first = Task { await service.completeHardwareOnchainPayment(request, paymentIdentity: self.identity, walletId: self.hardwareWalletId, txid: txid) }
+        let first = Task { await service.completeHardwareOnchainPayment(
+            request,
+            paymentIdentity: self.identity,
+            walletId: self.hardwareWalletId,
+            txid: txid
+        ) }
         await fulfillment(of: [began], timeout: 2)
         await service.reconcile()
         await followup.resume()
@@ -518,7 +532,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await service.markOnchainPaymentStarted(request, address: onchainAddress, hardwareWalletId: hardwareWalletId, paymentIdentity: identity)
         try await service.retainHardwareOnchainCandidate(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats, serializedTx: signed
+            address: onchainAddress, amountSats: request.amount.atomic, serializedTx: signed
         )
         await store.failNextSave()
         let failed = await service.clearHardwareCandidateBeforeDispatch(
@@ -547,7 +561,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let sdk = PaymentProofSdkMock(identity: identity, records: [record])
         let service = paymentProofService(sdk: sdk, store: store)
         let serializedTx = "02000000000101f7c5a048189164c6b05b07516b5dbb9c826c601d12dc4ed97f0069618b8b7c160100000000fdffffff024179010000000000160014f066a63663b0d464b31a7a88619beae011c3fb7be80300000000000016001483ea855bb508cb08ed9e8cf9152d8927871c19aa02473044022052c5a15ade616af16f314bcc2ae15bf4ef4996e0f2315794e647ba6c955745b602200f3095f4a7deb39a94716c0fd2001a2fbff1861a8ff0c2015739a40a62891c22012102cb13c86b55418d0e3bccf29115394e1fb6a9f209d3f59dc9bbb0805b253464cb724c0300"
-        let receipt = HwFundingSignedTx(serializedTx: serializedTx, miningFeeSats: 141, feeRate: 2, totalSpent: request.amountSats + 141)
+        let receipt = HwFundingSignedTx(serializedTx: serializedTx, miningFeeSats: 141, feeRate: 2, totalSpent: request.amount.atomic + 141)
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
         await store.failNextSave()
         do {
@@ -579,13 +593,13 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         XCTAssertEqual(restored?.paymentIdentifier, started?.paymentIdentifier)
         let retained = try await reopened.retainedHardwareOnchainPayment(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats
+            address: onchainAddress, amountSats: request.amount.atomic
         )
         XCTAssertEqual(retained?.signedTx, receipt)
         XCTAssertEqual(retained?.hasAttemptedBroadcast, false)
         let wrongAmount = try await reopened.retainedHardwareOnchainPayment(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats + 1
+            address: onchainAddress, amountSats: request.amount.atomic + 1
         )
         XCTAssertNil(wrongAmount)
         await reopened.cancelHardwarePaymentBeforeDispatch(request, paymentIdentity: identity, walletId: hardwareWalletId)
@@ -594,7 +608,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await reopened.restoreBackup(JSONDecoder().decode([PaykitPaymentStateBackup.Proof].self, from: encoded))
         try await reopened.retainHardwareOnchainCandidate(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats, serializedTx: serializedTx
+            address: onchainAddress, amountSats: request.amount.atomic, serializedTx: serializedTx
         )
         let attemptedBackup = try await reopened.backupSnapshot()
         let attemptedEncoded = try JSONEncoder().encode(attemptedBackup)
@@ -602,7 +616,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await reopened.restoreBackup(JSONDecoder().decode([PaykitPaymentStateBackup.Proof].self, from: attemptedEncoded))
         let attempted = try await reopened.retainedHardwareOnchainPayment(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats
+            address: onchainAddress, amountSats: request.amount.atomic
         )
         XCTAssertEqual(attempted?.hasAttemptedBroadcast, true)
         try await reopened.markHardwareCandidateRefused(
@@ -616,7 +630,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let localReopened = paymentProofService(sdk: sdk, store: store)
         let refused = try await localReopened.retainedHardwareOnchainPayment(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats
+            address: onchainAddress, amountSats: request.amount.atomic
         )
         XCTAssertEqual(refused?.isRefusedForNavigation, true)
         XCTAssertEqual(refused?.signedTx, receipt)
@@ -628,7 +642,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         XCTAssertTrue(foreignRetries.isEmpty)
         try await localReopened.retainHardwareOnchainCandidate(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats, serializedTx: serializedTx
+            address: onchainAddress, amountSats: request.amount.atomic, serializedTx: serializedTx
         )
         let retainedSnapshot = await store.snapshot()
         XCTAssertEqual(retainedSnapshot.first?.hardwareRefusedForNavigation, true, "Retention is not dispatch")
@@ -647,7 +661,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await localReopened.restoreBackup(JSONDecoder().decode([PaykitPaymentStateBackup.Proof].self, from: refusedEncoded))
         let conservative = try await localReopened.retainedHardwareOnchainPayment(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats
+            address: onchainAddress, amountSats: request.amount.atomic
         )
         XCTAssertEqual(conservative?.hasAttemptedBroadcast, true)
         XCTAssertEqual(conservative?.isRefusedForNavigation, false)
@@ -681,7 +695,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
         let serializedTx = "02000000000101f7c5a048189164c6b05b07516b5dbb9c826c601d12dc4ed97f0069618b8b7c160100000000fdffffff024179010000000000160014f066a63663b0d464b31a7a88619beae011c3fb7be80300000000000016001483ea855bb508cb08ed9e8cf9152d8927871c19aa02473044022052c5a15ade616af16f314bcc2ae15bf4ef4996e0f2315794e647ba6c955745b602200f3095f4a7deb39a94716c0fd2001a2fbff1861a8ff0c2015739a40a62891c22012102cb13c86b55418d0e3bccf29115394e1fb6a9f209d3f59dc9bbb0805b253464cb724c0300"
         // The first-broadcast coordinator persists the full signed receipt before dispatch.
-        let signedTx = HwFundingSignedTx(serializedTx: serializedTx, miningFeeSats: 120, feeRate: 2, totalSpent: request.amountSats + 120)
+        let signedTx = HwFundingSignedTx(serializedTx: serializedTx, miningFeeSats: 120, feeRate: 2, totalSpent: request.amount.atomic + 120)
         try await service.markOnchainPaymentStarted(
             request, address: onchainAddress, hardwareWalletId: hardwareWalletId,
             paymentIdentity: identity, signedTx: signedTx
@@ -690,7 +704,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         do {
             try await service.retainHardwareOnchainCandidate(
                 requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-                address: onchainAddress, amountSats: request.amountSats, serializedTx: serializedTx
+                address: onchainAddress, amountSats: request.amount.atomic, serializedTx: serializedTx
             )
             XCTFail("Failed receipt persistence must stop dispatch")
         } catch {}
@@ -699,7 +713,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         XCTAssertEqual(unsaved?.hardwareDispatchAttempted, false)
         try await service.retainHardwareOnchainCandidate(
             requestId: request.id, paymentIdentity: identity, walletId: hardwareWalletId,
-            address: onchainAddress, amountSats: request.amountSats, serializedTx: serializedTx
+            address: onchainAddress, amountSats: request.amount.atomic, serializedTx: serializedTx
         )
         let retained = await store.snapshot().first
         XCTAssertEqual(retained?.paymentIdentifier, txid)
@@ -708,7 +722,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         do {
             try await service.retainHardwareOnchainCandidate(
                 requestId: request.id, paymentIdentity: identity, walletId: "trezor:other-wallet",
-                address: onchainAddress, amountSats: request.amountSats, serializedTx: serializedTx
+                address: onchainAddress, amountSats: request.amount.atomic, serializedTx: serializedTx
             )
             XCTFail("Another wallet cannot replace the original hardware receipt")
         } catch {}
@@ -770,7 +784,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let request = try XCTUnwrap(PaykitPaymentRequest(record: record, now: Date()))
         let started = PendingPaykitPaymentProof(
             identity: identity, requestId: request.id, paymentAppId: "bitkit", paymentEndpointIdentifier: onchainEndpoint,
-            kind: .onchain, paymentIdentifier: nil, proofData: nil
+            kind: .onchain, paymentIdentifier: nil, proofData: nil, onchainAmountSats: request.amount.atomic
         )
         let lightningId = PaykitPaymentRequest.ID(
             paymentRequestId: UUID().uuidString, counterparty: counterparty, billingPeriodStartsAt: nil
@@ -860,13 +874,11 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         await sdk.setSubmissionFailure(true)
 
         let service = paymentProofService(sdk: sdk, store: store)
-        try await service.prepare(
-            request: request,
-            paymentAppId: "bitkit",
+        try await store.save([PendingPaykitPaymentProof(
+            identity: identity, requestId: request.id, paymentAppId: "bitkit",
             paymentEndpointIdentifier: PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue,
-            kind: .lightning
-        )
-        try await service.associateLightningPayment(request, paymentHash: paymentHash)
+            kind: .lightning, paymentStarted: true, paymentIdentifier: paymentHash, proofData: nil
+        )])
         await service.completeLightningPayment(paymentHash: paymentHash, preimage: preimage)
 
         let failedSubmissionCount = await sdk.submissionCount()
@@ -1120,7 +1132,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             store: store
         )
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
 
         let protectedRequestIds = try await service.protectedRequestIdsForSubscriptionCancellation(
             identity: identity,
@@ -1178,7 +1190,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let txid = String(repeating: "ab", count: 32)
 
         try await service.prepare(request: request, paymentAppId: "paykit-server", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         let inFlightRequestIds = await service.inFlightRequestIds(identity: identity)
         XCTAssertEqual(inFlightRequestIds, [request.id])
         try await recordAcceptedAttempt(service: service, request: request, txid: String(repeating: "ab", count: 32))
@@ -1268,7 +1280,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let service = paymentProofService(sdk: PaymentProofSdkMock(identity: identity, records: [record]), store: store)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         await service.cancelPreparation(request)
 
         let storedProofs = await store.snapshot()
@@ -1305,7 +1317,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let service = paymentProofService(sdk: sdk, store: store)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         await service.reconcile()
 
         let submissionCount = await sdk.submissionCount()
@@ -1330,7 +1342,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         let attemptId = try await attempts.admit(
             walletId: "node-0", requestId: request.id, orderId: nil,
-            address: onchainAddress, amountSats: request.amountSats, isMaxAmount: false
+            address: onchainAddress, amountSats: request.amount.atomic, isMaxAmount: false
         )
         try await attempts.record(.accepted(txid: txid), attemptId: attemptId)
         await service.reconcile()
@@ -1358,7 +1370,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         let id = try await attempts.admit(
             walletId: "node-0", requestId: request.id, orderId: nil,
-            address: onchainAddress, amountSats: request.amountSats, isMaxAmount: false
+            address: onchainAddress, amountSats: request.amount.atomic, isMaxAmount: false
         )
         try await attempts.record(.accepted(txid: txid), attemptId: id)
         await sdk.setSubmissionFailure(true)
@@ -1401,7 +1413,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             try await service.markOnchainPaymentStarted(request, address: onchainAddress)
             let id = try await attempts.admit(
                 walletId: "node-0", requestId: request.id, orderId: nil,
-                address: onchainAddress, amountSats: request.amountSats, isMaxAmount: false
+                address: onchainAddress, amountSats: request.amount.atomic, isMaxAmount: false
             )
             try await attempts.record(result, attemptId: id)
             let completed = await service.completeOnchainPayment(request, txid: txid, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint)
@@ -1429,7 +1441,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             let attempts = OnchainSendAttemptService(store: MemoryAttemptStore())
             let id = try await attempts.admit(
                 walletId: "node-0", requestId: request.id, orderId: nil,
-                address: onchainAddress, amountSats: request.amountSats, isMaxAmount: false
+                address: onchainAddress, amountSats: request.amount.atomic, isMaxAmount: false
             )
             try await attempts.record(observed ? .unknown(txid: txid) : .accepted(txid: txid), attemptId: id)
             let sdk = PaymentProofSdkMock(identity: identity, records: [record])
@@ -1474,7 +1486,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let node = AttemptNodeMock(result: .accepted(txid: txid))
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
         _ = try await attempts.send(
-            using: node, address: onchainAddress, amountSats: request.amountSats,
+            using: node, address: onchainAddress, amountSats: request.amount.atomic,
             satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false, requestId: request.id,
             followupContext: OnchainSendFollowupContext(feeSats: 123, feeRate: 2, tags: ["original"], contact: nil, createdAt: 100)
         ) { try await service.markOnchainPaymentStarted(request, address: self.onchainAddress) }
@@ -1510,7 +1522,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         await restarted.reconcile()
         XCTAssertEqual(resolutions.count, 1)
         let saved = try await Bitkit.CoreService.shared.activity.getOnchainActivityByTxId(txid: txid)
-        XCTAssertEqual(saved?.value, request.amountSats)
+        XCTAssertEqual(saved?.value, request.amount.atomic)
         XCTAssertEqual(saved?.address, onchainAddress)
         XCTAssertEqual(saved?.fee, 123)
         XCTAssertEqual(node.calls, 1)
@@ -1532,7 +1544,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         let id = try await attempts.admit(
             walletId: XCTUnwrap(wallet.originalWalletId), requestId: request.id, orderId: nil,
-            address: onchainAddress, amountSats: request.amountSats, isMaxAmount: false
+            address: onchainAddress, amountSats: request.amount.atomic, isMaxAmount: false
         )
         let captured = expectation(description: "Backup captured the original started proof")
         await store.pauseNextLoad { captured.fulfill() }
@@ -1566,7 +1578,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let attempts = OnchainSendAttemptService(store: attemptStore, localFollowup: followup)
         _ = try await attempts.send(
             using: AttemptNodeMock(result: .accepted(txid: txid)), address: onchainAddress,
-            amountSats: request.amountSats, satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false, requestId: request.id,
+            amountSats: request.amount.atomic, satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false, requestId: request.id,
             followupContext: .init(feeSats: 123, feeRate: 2, tags: [], contact: nil, createdAt: 100)
         )
         let service = paymentProofService(
@@ -1606,7 +1618,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let txid = String(repeating: "ab", count: 32)
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
         _ = try await attempts.send(
-            using: AttemptNodeMock(result: .accepted(txid: txid)), address: onchainAddress, amountSats: request.amountSats,
+            using: AttemptNodeMock(result: .accepted(txid: txid)), address: onchainAddress, amountSats: request.amount.atomic,
             satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false, requestId: request.id,
             followupContext: OnchainSendFollowupContext(feeSats: 123, feeRate: 2, tags: [], contact: nil, createdAt: 100)
         ) { try await service.markOnchainPaymentStarted(request, address: self.onchainAddress) }
@@ -1638,7 +1650,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let node = AttemptNodeMock(result: .accepted(txid: txid))
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
         _ = try await attempts.send(
-            using: node, address: onchainAddress, amountSats: request.amountSats,
+            using: node, address: onchainAddress, amountSats: request.amount.atomic,
             satsPerVbyte: 1, utxosToSpend: nil, isMaxAmount: false, requestId: request.id
         ) {
             try await service.markOnchainPaymentStarted(request, address: self.onchainAddress)
@@ -1657,7 +1669,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         XCTAssertNil(knownAfterRestart)
         do {
             _ = try await restarted.send(
-                using: node, address: onchainAddress, amountSats: request.amountSats,
+                using: node, address: onchainAddress, amountSats: request.amount.atomic,
                 satsPerVbyte: 1, utxosToSpend: nil, isMaxAmount: false, requestId: request.id
             )
             XCTFail("Restart repaid accepted request after result save failure")
@@ -1678,7 +1690,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let node = AttemptNodeMock(result: .accepted(txid: txid))
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
         _ = try await attempts.send(
-            using: node, address: onchainAddress, amountSats: request.amountSats,
+            using: node, address: onchainAddress, amountSats: request.amount.atomic,
             satsPerVbyte: 1, utxosToSpend: nil, isMaxAmount: true, requestId: request.id
         ) { try await service.markOnchainPaymentStarted(request, address: self.onchainAddress) }
         await store.failNextSave()
@@ -1688,7 +1700,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         XCTAssertEqual(attemptStore.snapshot().first?.localFollowupComplete, false)
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
         let resumed = try await attempts.send(
-            using: node, address: onchainAddress, amountSats: request.amountSats,
+            using: node, address: onchainAddress, amountSats: request.amount.atomic,
             satsPerVbyte: 1, utxosToSpend: nil, isMaxAmount: true, requestId: request.id
         )
         XCTAssertEqual(resumed, .accepted(txid: txid))
@@ -1724,7 +1736,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             requestId: request.id,
             orderId: nil,
             address: onchainAddress,
-            amountSats: request.amountSats,
+            amountSats: request.amount.atomic,
             isMaxAmount: false
         )
         try await attempts.record(.accepted(txid: txid), attemptId: id)
@@ -1810,7 +1822,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             paymentIdentifier: txid,
             proofData: txid,
             onchainAddress: onchainAddress,
-            onchainAmountSats: request.amountSats,
+            onchainAmountSats: request.amount.atomic,
             onchainMatchingTransactionIdsBeforeAttempt: []
         )
         let store = PaymentProofMemoryStore()
@@ -1843,7 +1855,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: onchainEndpoint, kind: .onchain)
         _ = try await attempts.admit(
             walletId: "node-0", requestId: request.id, orderId: nil,
-            address: onchainAddress, amountSats: request.amountSats, isMaxAmount: false
+            address: onchainAddress, amountSats: request.amount.atomic, isMaxAmount: false
         )
         do {
             try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: lightningEndpoint, kind: .lightning)
@@ -2287,7 +2299,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             let attemptsStore = MemoryAttemptStore()
             let attempts = OnchainSendAttemptService(store: attemptsStore)
             let sender = PreparedAttemptNodeMock()
-            sender.amount = request.amountSats
+            sender.amount = request.amount.atomic
             let service = paymentProofService(
                 sdk: PaymentProofSdkMock(identity: identity, records: [record]), store: store, attemptService: attempts
             )
@@ -2297,7 +2309,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             sender.onNativeQueueDispatch = { sender.deadlineClock = { deadline.addingTimeInterval(1) } }
             do {
                 _ = try await attempts.send(
-                    using: sender, address: onchainAddress, amountSats: request.amountSats,
+                    using: sender, address: onchainAddress, amountSats: request.amount.atomic,
                     satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false,
                     requestId: request.id, paymentIdentity: identity,
                     paymentDeadline: PaykitPreciseInstant(date: deadline),
@@ -2336,7 +2348,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let attemptsStore = MemoryAttemptStore()
         let attempts = OnchainSendAttemptService(store: attemptsStore)
         let sender = PreparedAttemptNodeMock()
-        sender.amount = request.amountSats
+        sender.amount = request.amount.atomic
         let service = paymentProofService(
             sdk: PaymentProofSdkMock(identity: identity, records: [record]), store: store, attemptService: attempts
         )
@@ -2359,7 +2371,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
                 onAuthorized: { _ in },
                 send: { beforeBroadcast in
                     try await attempts.send(
-                        using: sender, address: self.onchainAddress, amountSats: request.amountSats,
+                        using: sender, address: self.onchainAddress, amountSats: request.amount.atomic,
                         satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false,
                         requestId: request.id, paymentIdentity: self.identity, beforeBroadcastAttempt: beforeBroadcast
                     )
@@ -2387,7 +2399,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let service = paymentProofService(sdk: PaymentProofSdkMock(identity: identity, records: [record]), store: store)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         await service.failOnchainPayment(request)
 
         let storedProofs = await store.snapshot()
@@ -2402,7 +2414,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let sdk = PaymentProofSdkMock(identity: identity, records: [record])
         let service = paymentProofService(sdk: sdk, store: store)
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         await sdk.setIdentityAvailable(false)
 
         await service.failOnchainPayment(request)
@@ -2580,7 +2592,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let service = paymentProofService(sdk: sdk, store: store)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         await store.failNextSave()
         try await recordAcceptedAttempt(service: service, request: request, txid: String(repeating: "ab", count: 32))
         await service.completeOnchainPayment(
@@ -2606,7 +2618,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let txid = String(repeating: "ab", count: 32)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         await store.failNextSave()
         try await recordAcceptedAttempt(service: service, request: request, txid: String(repeating: "ab", count: 32))
         await service.completeOnchainPayment(request, txid: txid, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint)
@@ -2627,7 +2639,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let txid = String(repeating: "ab", count: 32)
 
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
-        try await service.markOnchainPaymentStarted(request, address: onchainAddress, amountSats: request.amount.atomic)
+        try await service.markOnchainPaymentStarted(request, address: onchainAddress)
         await store.failNextLoad()
         try await recordAcceptedAttempt(service: service, request: request, txid: String(repeating: "ab", count: 32))
         await service.completeOnchainPayment(request, txid: txid, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint)
@@ -2655,7 +2667,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let attempts = try XCTUnwrap(serviceAttempts[ObjectIdentifier(service)])
         let id = try await attempts.admit(
             walletId: "node-0", requestId: request.id, orderId: nil,
-            address: onchainAddress, amountSats: request.amountSats, isMaxAmount: false
+            address: onchainAddress, amountSats: request.amount.atomic, isMaxAmount: false
         )
         try await attempts.record(.accepted(txid: txid), attemptId: id)
     }
@@ -2762,7 +2774,9 @@ private actor SuspendedShopActivityFollowup: OnchainSendLocalFollowupHandling {
     private var saves = 0
     private var firstContinuation: CheckedContinuation<Void, Never>?
 
-    init(onFirstSave: @escaping @Sendable () -> Void) { self.onFirstSave = onFirstSave }
+    init(onFirstSave: @escaping @Sendable () -> Void) {
+        self.onFirstSave = onFirstSave
+    }
 
     func save(_ attempt: OnchainSendAttempt) async throws -> OnchainActivity {
         saves += 1
@@ -2780,7 +2794,9 @@ private actor SuspendedShopActivityFollowup: OnchainSendLocalFollowupHandling {
         firstContinuation = nil
     }
 
-    func saveCount() -> Int { saves }
+    func saveCount() -> Int {
+        saves
+    }
 }
 
 private struct FailingShopActivityFollowup: OnchainSendLocalFollowupHandling {
@@ -2817,7 +2833,9 @@ actor PaymentProofMemoryStore: PaykitPaymentProofStoring {
         return snapshot
     }
 
-    func pauseNextLoad(onCaptured: @escaping @Sendable () -> Void) { onPausedLoad = onCaptured }
+    func pauseNextLoad(onCaptured: @escaping @Sendable () -> Void) {
+        onPausedLoad = onCaptured
+    }
 
     func resumePausedLoad() {
         pausedLoad?.resume()
@@ -3103,7 +3121,9 @@ private actor SuspendedHardwareShopFollowup {
     private var saves = 0
     private var continuation: CheckedContinuation<Void, Never>?
 
-    init(onFirstSave: @escaping @Sendable () -> Void) { self.onFirstSave = onFirstSave }
+    init(onFirstSave: @escaping @Sendable () -> Void) {
+        self.onFirstSave = onFirstSave
+    }
 
     func save() async {
         saves += 1
@@ -3120,5 +3140,7 @@ private actor SuspendedHardwareShopFollowup {
         continuation = nil
     }
 
-    func saveCount() -> Int { saves }
+    func saveCount() -> Int {
+        saves
+    }
 }
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index c17cbc24d..da9605215 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -28,39 +28,32 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         for (asset, amount, rates, endpoints, expected) in cases {
             let record = try paymentRequestRecord(amount: amount, asset: asset, conversion: .fixed(rates: rates), endpoints: endpoints)
             let request = try PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest).get()
-            XCTAssertEqual(request.amountSats, expected, "\(asset) \(amount) \(endpoints)")
             XCTAssertEqual(request.amountValue, amount)
             XCTAssertEqual(record.terms?.amount.asset, asset)
             XCTAssertEqual(record.terms?.conversion, .fixed(rates: rates))
-            XCTAssertTrue(request.acceptsPaymentAmount(expected))
-            XCTAssertFalse(request.acceptsPaymentAmount(expected + 1))
-            XCTAssertTrue(request.acceptsLightningInvoiceAmount(milliSatoshis: expected * 1000))
-            XCTAssertFalse(request.acceptsLightningInvoiceAmount(milliSatoshis: expected * 1000 + 1))
+            for endpoint in request.acceptedPaymentEndpointIdentifiers {
+                let method = try XCTUnwrap(PublicPaykitService.MethodId(rawValue: endpoint))
+                XCTAssertEqual(try request.payment(using: method).amount.atomic, expected)
+                XCTAssertTrue(request.acceptsPaymentAmount(expected, method: method))
+                XCTAssertFalse(request.acceptsPaymentAmount(expected + 1, method: method))
+                if method == .bitcoinLightningBolt11 || method == .bitcoinLightningLnurl {
+                    XCTAssertTrue(request.acceptsLightningInvoiceAmount(milliSatoshis: expected * 1000))
+                    XCTAssertFalse(request.acceptsLightningInvoiceAmount(milliSatoshis: expected * 1000 + 1))
+                }
+            }
         }
     }
 
-    func testFixedPricingRejectsProductsBeyondExactDecimalPrecision() throws {
-        let cases: [(String, String, UInt64?)] = [
-            ("9." + String(repeating: "0", count: 35) + "1", "0.00004", 36001),
-            ("9." + String(repeating: "0", count: 36) + "1", "0.00004", nil),
-            ("9." + String(repeating: "0", count: 36) + "1", "1", nil),
-            ("0009." + String(repeating: "0", count: 35) + "10", "0.0000400", 36001),
-        ]
-        for (amount, rate, expected) in cases {
+    func testFixedPricingRejectsRequestedAmountsBeyondCurrencyPrecision() throws {
+        for amount in ["9.001", "9." + String(repeating: "0", count: 35) + "1"] {
             let record = try paymentRequestRecord(
-                amount: amount, asset: "usd", conversion: .fixed(rates: [.init(asset: "btc", value: rate)]),
+                amount: amount, asset: "usd", conversion: .fixed(rates: [.init(asset: "btc", value: "0.00004")]),
                 endpoints: ["btc-regtest-p2wpkh"]
             )
-            let result = PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest)
-            if let expected {
-                XCTAssertEqual(try result.get().amountSats, expected, "\(amount) * \(rate)")
-            } else {
-                guard case let .failure(reason) = result else {
-                    XCTFail("Unsupported product precision was accepted: \(amount) * \(rate)")
-                    continue
-                }
-                XCTAssertEqual(reason, .unsupportedPricing)
+            guard case let .failure(reason) = PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest) else {
+                return XCTFail("Unsupported currency precision was accepted")
             }
+            XCTAssertEqual(reason, .invalidAmount)
         }
     }
 
@@ -70,8 +63,11 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             endpoints: ["btc-lightning-bolt11", "btc-regtest-p2wpkh", "btc-regtest-p2tr"]
         )
         let request = try PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest).get()
-        XCTAssertEqual(request.amountSats, 21000)
-        XCTAssertEqual(request.acceptedPaymentEndpointIdentifiers, ["btc-regtest-p2wpkh", "btc-regtest-p2tr"])
+        for endpoint in ["btc-regtest-p2wpkh", "btc-regtest-p2tr"] {
+            let method = try XCTUnwrap(PublicPaykitService.MethodId(rawValue: endpoint))
+            XCTAssertEqual(try request.payment(using: method).amount.atomic, 21000)
+        }
+        XCTAssertThrowsError(try request.payment(using: .bitcoinLightningBolt11))
     }
 
     func testUnsupportedFixedPricingCannotBecomePayable() throws {
@@ -80,29 +76,28 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             [.init(asset: "btc", value: "0")], [.init(asset: "btc", value: "-1")],
             [.init(asset: "btc", value: "1e-3")], [.init(asset: "btc", value: " 1")],
             [.init(asset: "btc", value: "1\n")], [.init(asset: "btc", value: "184467440738")],
-            [.init(asset: "btc", value: "0.000000011")],
             [.init(asset: "btc", value: "0.123456789012345678901234567890123456789")],
             [.init(asset: "btc", value: "1"), .init(asset: "btc", value: "2")],
-            [.init(asset: "btc", value: "1"), .init(asset: "btc-lightning", value: "2")],
         ]
         for conversion in rates.map({ PaymentConversion.fixed(rates: $0) }) + [.perPeriod] {
             let record = try paymentRequestRecord(
                 amount: "1", asset: "usd", conversion: conversion,
                 endpoints: ["btc-regtest-p2wpkh", "btc-lightning-bolt11"]
             )
-            guard case let .failure(reason) = PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest) else {
-                return XCTFail("Unsupported pricing was accepted")
-            }
-            XCTAssertEqual(reason, .unsupportedPricing)
+            let request = try PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest).get()
+            let method = try XCTUnwrap(PublicPaykitService.MethodId(rawValue: "btc-regtest-p2wpkh"))
+            XCTAssertThrowsError(try request.payment(using: method))
+            XCTAssertThrowsError(try request.payment(using: .bitcoinLightningBolt11))
         }
     }
 
-    func testConversionSubscriptionsRemainUnsupported() throws {
+    func testConversionSubscriptionsPreservePricingTerms() throws {
         let record = try paymentRequestRecord(
             conversion: .fixed(rates: [.init(asset: "btc", value: "0.5")]),
             recurrence: .init(every: 1, unit: "month", startsAt: "2027-01-01T00:00:00Z", anchor: "2027-01-01T00:00:00Z", endsAt: nil)
         )
-        XCTAssertNil(PaykitSubscription(record: record))
+        let subscription = try XCTUnwrap(PaykitSubscription(record: record))
+        XCTAssertEqual(subscription.pricing.conversion, record.terms?.conversion)
     }
 
     func testRefreshModesLoadStoredRequestsAndControlPrivateMessageSync() async throws {
@@ -4134,19 +4129,24 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
 
     func testRefusedHardwareReceiptReopensAcceptedRequestFromListAfterRestart() async throws {
         let endpoint = PublicPaykitService.MethodId.regtestOnchainP2wpkh.rawValue
-        let record = try paymentRequestRecord(state: .accepted, endpoints: [endpoint], acceptedEventId: "accepted")
+        let record = try paymentRequestRecord(
+            state: .accepted, amount: "50", asset: "usd",
+            conversion: .fixed(rates: [.init(asset: "btc", value: "0.00002")]),
+            endpoints: [endpoint], acceptedEventId: "accepted"
+        )
         let request = try XCTUnwrap(PaykitPaymentRequest(record: record, now: Date()))
+        let payment = try request.payment(using: .regtestOnchainP2wpkh)
         let raw = "02000000000101f7c5a048189164c6b05b07516b5dbb9c826c601d12dc4ed97f0069618b8b7c160100000000fdffffff024179010000000000160014f066a63663b0d464b31a7a88619beae011c3fb7be80300000000000016001483ea855bb508cb08ed9e8cf9152d8927871c19aa02473044022052c5a15ade616af16f314bcc2ae15bf4ef4996e0f2315794e647ba6c955745b602200f3095f4a7deb39a94716c0fd2001a2fbff1861a8ff0c2015739a40a62891c22012102cb13c86b55418d0e3bccf29115394e1fb6a9f209d3f59dc9bbb0805b253464cb724c0300"
         var proof = try PendingPaykitPaymentProof(
             identity: "pubky" + String(repeating: "z", count: 52), requestId: request.id,
             paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain,
             paymentStarted: true, paymentIdentifier: SignedTransactionId.fromHex(raw), proofData: nil,
-            onchainAddress: "original-address", onchainAmountSats: request.amountSats, onchainWalletId: "jade:wallet"
+            onchainAddress: "original-address", onchainAmountSats: payment.amount.atomic, onchainWalletId: "jade:wallet"
         )
         proof.hardwareSignedTransaction = raw
         proof.hardwareMiningFeeSats = 120
         proof.hardwareFeeRate = 2
-        proof.hardwareTotalSpent = request.amountSats + 120
+        proof.hardwareTotalSpent = payment.amount.atomic + 120
         proof.hardwareDispatchAttempted = true
         proof.hardwareRefusedForNavigation = true
         let sdk = PaymentRequestSdkMock(records: [record])
@@ -4188,10 +4188,16 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertTrue(app.claimContactPaymentContext(contact))
         try app.handleRetainedHardwarePayment(proof, context: contact)
         XCTAssertEqual(app.scannedOnchainInvoice?.address, proof.onchainAddress)
-        XCTAssertEqual(app.scannedOnchainInvoice?.amountSatoshis, request.amountSats)
+        XCTAssertEqual(app.scannedOnchainInvoice?.amountSatoshis, payment.amount.atomic)
         XCTAssertEqual(app.selectedWalletToPayFrom, .onchain)
+        XCTAssertEqual(app.paykitPaymentTerms, payment)
+        XCTAssertEqual(app.paykitReviewedAmount, payment.amount)
+        XCTAssertEqual(
+            PaymentNavigationHelper.contactPaymentRoute(app: app, currency: CurrencyViewModel(), settings: .shared),
+            .confirm
+        )
         let launch = try XCTUnwrap(PrivatePaykitService.retainedHardwarePaymentLaunchResult(proof: proof, request: request))
-        guard case let .opened(target, context) = launch else { return XCTFail("Original receipt must reopen") }
+        guard case let .opened(target, context, _) = launch else { return XCTFail("Original receipt must reopen") }
         XCTAssertEqual(target, "bitcoin:original-address")
         XCTAssertEqual(try XCTUnwrap(context).paymentAppId(for: endpoint), proof.paymentAppId)
         try await manager.prepareForPayment(request)
@@ -4218,8 +4224,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             changed.hardwareDispatchAttempted = true
             changed.hardwareRefusedForNavigation = true
             if invalid == "amount" {
-                changed.onchainAmountSats = request.amountSats + 1
-                changed.hardwareTotalSpent = request.amountSats + 121
+                changed.onchainAmountSats = payment.amount.atomic + 1
+                changed.hardwareTotalSpent = payment.amount.atomic + 121
             } else if invalid == "unknown" {
                 changed.hardwareRefusedForNavigation = false
             } else if invalid == "completed" {
@@ -4270,7 +4276,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 paymentAppId: "bitkit", paymentEndpointIdentifier: invalid == "endpoint" ? "other" : endpoint,
                 kind: .onchain, billingPeriod: alteredPeriod, paymentStarted: true,
                 paymentIdentifier: SignedTransactionId.fromHex(raw), proofData: invalid == "completed" ? "proof" : nil,
-                onchainAddress: "original-recurring-address", onchainAmountSats: request.amountSats + (invalid == "amount" ? 1 : 0),
+                onchainAddress: "original-recurring-address", onchainAmountSats: request.amount.atomic + (invalid == "amount" ? 1 : 0),
                 onchainWalletId: "jade:wallet"
             )
             proof.hardwareSignedTransaction = raw
@@ -4308,7 +4314,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertFalse(restored.dismissSubscriptionPayment(request), "Alternate recurring dismissal must retain the original retry")
         XCTAssertEqual(restored.pendingRequests, [request])
         let launch = try XCTUnwrap(PrivatePaykitService.retainedHardwarePaymentLaunchResult(proof: proof, request: request))
-        guard case let .opened(target, context) = launch else { return XCTFail("Original retained receipt must reopen") }
+        guard case let .opened(target, context, _) = launch else { return XCTFail("Original retained receipt must reopen") }
         XCTAssertEqual(target, "bitcoin:original-recurring-address")
         XCTAssertEqual(try XCTUnwrap(context).paymentAppId(for: endpoint), proof.paymentAppId)
         XCTAssertEqual(restored.retainedHardwareRetries[request.id]?.onchainWalletId, "jade:wallet")
@@ -5295,7 +5301,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             serializedTx: "02000000000101f7c5a048189164c6b05b07516b5dbb9c826c601d12dc4ed97f0069618b8b7c160100000000fdffffff024179010000000000160014f066a63663b0d464b31a7a88619beae011c3fb7be80300000000000016001483ea855bb508cb08ed9e8cf9152d8927871c19aa02473044022052c5a15ade616af16f314bcc2ae15bf4ef4996e0f2315794e647ba6c955745b602200f3095f4a7deb39a94716c0fd2001a2fbff1861a8ff0c2015739a40a62891c22012102cb13c86b55418d0e3bccf29115394e1fb6a9f209d3f59dc9bbb0805b253464cb724c0300",
             miningFeeSats: 141,
             feeRate: 2,
-            totalSpent: request.amountSats + 141
+            totalSpent: request.amount.atomic + 141
         )
         try await proofService.markOnchainPaymentStarted(
             request,
@@ -5376,7 +5382,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             serializedTx: "02000000000101f7c5a048189164c6b05b07516b5dbb9c826c601d12dc4ed97f0069618b8b7c160100000000fdffffff024179010000000000160014f066a63663b0d464b31a7a88619beae011c3fb7be80300000000000016001483ea855bb508cb08ed9e8cf9152d8927871c19aa02473044022052c5a15ade616af16f314bcc2ae15bf4ef4996e0f2315794e647ba6c955745b602200f3095f4a7deb39a94716c0fd2001a2fbff1861a8ff0c2015739a40a62891c22012102cb13c86b55418d0e3bccf29115394e1fb6a9f209d3f59dc9bbb0805b253464cb724c0300",
             miningFeeSats: 141,
             feeRate: 2,
-            totalSpent: request.amountSats + 141
+            totalSpent: request.amount.atomic + 141
         )
         try await proofService.markOnchainPaymentStarted(
             request,
@@ -5413,7 +5419,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let recoveredPrivateService = PrivatePaykitService()
         let recoveredReceipt = try await proofService.retainedHardwareOnchainPayment(
             requestId: request.id, paymentIdentity: identity, walletId: walletId,
-            address: "bcrt1qhardwarecleanup", amountSats: request.amountSats,
+            address: "bcrt1qhardwarecleanup", amountSats: request.amount.atomic,
             privatePaykitService: recoveredPrivateService
         )
         XCTAssertEqual(recoveredReceipt?.signedTx, signed)
@@ -5476,7 +5482,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 try await privateService.consumePrivatePaymentList(publicKey: counterparty, context: privateContext, attemptId: context.id)
             }
             if testCase.started {
-                try await proofService.markOnchainPaymentStarted(request, address: "bcrt1qhardwarecleanup", amountSats: request.amount.atomic)
+                try await proofService.markOnchainPaymentStarted(request, address: "bcrt1qhardwarecleanup")
             }
             let preparedProofs = try await proofStore.load()
             XCTAssertEqual(preparedProofs.count, 1)
@@ -8160,14 +8166,14 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let attemptsStore = MemoryAttemptStore()
         let attempts = OnchainSendAttemptService(store: attemptsStore)
         let sender = PreparedAttemptNodeMock()
-        sender.amount = request.amountSats
+        sender.amount = request.amount.atomic
         let service = PaykitPaymentProofService(
             sdk: PaymentProofSdkMock(identity: identity, records: [record]), store: store, attemptService: attempts, logInfo: { _ in },
             logWarning: { _ in }
         )
         try await service.prepare(request: request, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint, kind: .onchain)
         _ = try await attempts.send(
-            using: sender, address: onchainAddress, amountSats: request.amountSats, satsPerVbyte: 2,
+            using: sender, address: onchainAddress, amountSats: request.amount.atomic, satsPerVbyte: 2,
             utxosToSpend: nil, isMaxAmount: false, requestId: request.id, paymentIdentity: identity,
             beforeBroadcastAttempt: {
                 try await service.markOnchainPaymentStarted(request, address: onchainAddress, paymentIdentity: identity)
@@ -8180,7 +8186,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let beforeProofs = await store.snapshot()
         let authorized = try await manager.ensureOnchainRecoveryAllowed(attempt, proofService: service)
         XCTAssertEqual(authorized.id, request.id)
-        XCTAssertEqual(authorized.amountSats, attempt.amountSats)
+        XCTAssertEqual(authorized.amount.atomic, attempt.amountSats)
         let afterProofs = await store.snapshot()
         XCTAssertEqual(afterProofs, beforeProofs)
         XCTAssertFalse(manager.isApprovedForPayment(request), "Recovery must not grant approval for a new payment")

From 82743cea1a2cb106bd46fdfa12002d6d007d8de9 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Sun, 11 Oct 2026 22:01:01 -0500
Subject: [PATCH 13/62] fix: preserve quote deadlines through payment retries

---
 .../Services/PaykitPaymentProofService.swift  |  6 ++--
 .../PaykitPaymentRequestService.swift         | 17 +++++++--
 .../Views/Wallets/Send/HwSendSignView.swift   |  5 +--
 .../Views/Wallets/Send/LnurlPayConfirm.swift  |  2 +-
 .../Wallets/Send/SendConfirmationView.swift   |  4 +--
 .../Wallets/Send/SendPendingScreen.swift      |  4 +--
 Bitkit/Views/Wallets/Send/SendSheet.swift     |  1 -
 .../PaykitPaymentProofServiceTests.swift      | 22 ++++++++----
 .../PaykitPaymentRequestServiceTests.swift    | 35 ++++++++++++++++++-
 .../PaykitPaymentStateBackupTests.swift       |  5 +--
 Docs/USDT-QA.md                               |  1 +
 11 files changed, 80 insertions(+), 22 deletions(-)

diff --git a/Bitkit/Services/PaykitPaymentProofService.swift b/Bitkit/Services/PaykitPaymentProofService.swift
index d7003e58d..460991afb 100644
--- a/Bitkit/Services/PaykitPaymentProofService.swift
+++ b/Bitkit/Services/PaykitPaymentProofService.swift
@@ -481,7 +481,9 @@ actor PaykitPaymentProofService {
         return identity
     }
 
-    func authorizeOnchainRecovery(_ attempt: OnchainSendAttempt, restoreStartedProof: Bool = true) async throws -> PaykitPaymentRequest {
+    func authorizeOnchainRecovery(
+        _ attempt: OnchainSendAttempt, restoreStartedProof: Bool = true
+    ) async throws -> (request: PaykitPaymentRequest, paymentDeadline: PaykitPreciseInstant?) {
         guard let requestId = attempt.requestId, let payer = attempt.recoveryContext?.paymentIdentity else {
             throw PaykitPaymentRequestError.requestUnavailable
         }
@@ -532,7 +534,7 @@ actor PaykitPaymentProofService {
                 try await persist(proofs)
             }
         }
-        return request
+        return try (request, request.submissionDeadline(quoteId: proof.conversionQuoteId))
     }
 
     func resolvedOnchainPayment(requestId: PaykitPaymentRequest.ID, identity: String,
diff --git a/Bitkit/Services/PaykitPaymentRequestService.swift b/Bitkit/Services/PaykitPaymentRequestService.swift
index 6758485e8..3c8c622fc 100644
--- a/Bitkit/Services/PaykitPaymentRequestService.swift
+++ b/Bitkit/Services/PaykitPaymentRequestService.swift
@@ -359,6 +359,15 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         try pricing.payment(requested: amount, endpoint: method.rawValue, period: billingPeriod, at: date, quoteId: quoteId)
     }
 
+    func submissionDeadline(quoteId: String?) throws -> PaykitPreciseInstant? {
+        guard let quoteId else { return paymentDeadline }
+        guard let quote = pricing.quotes.first(where: { $0.eventId == quoteId }),
+              let period = PaykitBillingPeriod(sdkPeriod: quote.billingPeriod), period == billingPeriod,
+              let quoteExpiry = PaykitPreciseInstant(timestamp: quote.expiresAt)
+        else { throw PaykitPaymentRequestError.requestUnavailable }
+        return min(paymentDeadline ?? quoteExpiry, quoteExpiry)
+    }
+
     func matchesOnchainPayment(_ proof: PendingPaykitPaymentProof, amountSats: UInt64? = nil) -> Bool {
         guard let method = PublicPaykitService.MethodId(rawValue: proof.paymentEndpointIdentifier),
               let amount = amountSats ?? proof.onchainAmountSats,
@@ -1863,19 +1872,21 @@ final class PaykitPaymentRequestManager {
 
     func ensureOnchainRecoveryAllowed(
         _ attempt: OnchainSendAttempt, proofService: PaykitPaymentProofService
-    ) async throws -> PaykitPaymentRequest {
+    ) async throws -> (request: PaykitPaymentRequest, paymentDeadline: PaykitPreciseInstant?) {
         let generation = stateGeneration
         guard let identity = activeIdentity,
               PubkyPublicKeyFormat.matches(identity, attempt.recoveryContext?.paymentIdentity)
         else { throw PaykitPaymentRequestError.requestUnavailable }
         // Durable original-payment authorization replaces only the lost process-local approval.
-        let request = try await proofService.authorizeOnchainRecovery(attempt)
+        let authorization = try await proofService.authorizeOnchainRecovery(attempt)
+        let request = authorization.request
         try await service.ensurePaymentAllowed(request)
         guard generation == stateGeneration, PubkyPublicKeyFormat.matches(activeIdentity, identity),
               !request.isPaymentDeadlineExpired(at: now())
         else { throw PaykitPaymentRequestError.requestUnavailable }
         try await proofService.requireRecoveryPayer(identity)
-        return request
+        try PaykitPaymentRequest.checkPaymentDeadline(authorization.paymentDeadline, at: now())
+        return authorization
     }
 
     func prepareForPayment(
diff --git a/Bitkit/Views/Wallets/Send/HwSendSignView.swift b/Bitkit/Views/Wallets/Send/HwSendSignView.swift
index 613f3f16a..94d6240fc 100644
--- a/Bitkit/Views/Wallets/Send/HwSendSignView.swift
+++ b/Bitkit/Views/Wallets/Send/HwSendSignView.swift
@@ -12,7 +12,6 @@ struct HwSendSignView: View {
     let hwSend: HwSendCoordinator
     let contactPaymentRequestId: PaykitPaymentRequest.ID?
     let contactPaymentIdentity: String?
-    let contactPaymentDeadline: PaykitPreciseInstant?
     let prepareContactPayment: (HwFundingSignedTx) async throws -> Void
     let authorizeContactPayment: () async throws -> Void
     let completeContactPayment: (String) async -> Bool
@@ -165,6 +164,8 @@ struct HwSendSignView: View {
                 if let request = app.contactPaymentContext?.incomingPaymentRequest {
                     retained = try await PaykitPaymentProofService.shared.retainedHardwarePaymentForRetry(request: request)
                 }
+                let quoteId = retained.map(\.conversionQuoteId) ?? app.paykitPaymentTerms?.quoteId
+                let deadline = try app.contactPaymentContext?.incomingPaymentRequest?.submissionDeadline(quoteId: quoteId)
                 guard let feeRate = SendConfirmationView.confirmationFeeRate(
                     retained: retained?.retainedHardwareRetry?.signedTx, selected: wallet.selectedFeeRateSatsPerVByte
                 ) else { throw PaykitPaymentRequestError.requestUnavailable }
@@ -175,7 +176,7 @@ struct HwSendSignView: View {
                         address: invoice.address,
                         sats: amount,
                         satsPerVByte: UInt64(feeRate),
-                        paymentDeadline: contactPaymentDeadline,
+                        paymentDeadline: deadline,
                         paymentRequestId: requestId,
                         loadSignedPayment: {
                             guard let requestId else { return nil }
diff --git a/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift b/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
index f956e46b4..bb3845e26 100644
--- a/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
+++ b/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
@@ -332,7 +332,7 @@ struct LnurlPayConfirm: View {
                 try await wallet.sendWithTimeout(
                     bolt11: bolt11,
                     sats: nil,
-                    paymentDeadline: incomingPaymentRequest?.paymentDeadline,
+                    paymentDeadline: incomingPaymentRequest?.submissionDeadline(quoteId: app.paykitPaymentTerms?.quoteId),
                     afterListening: { _ in lightningPaymentSubmitted = true },
                     onTimeout: { timedOutHash in
                         app.addPendingPaymentHash(timedOutHash, contactPaymentContext: contactPaymentContext)
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index af8a17967..c8f74ae81 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -1122,7 +1122,7 @@ struct SendConfirmationView: View {
                         try await wallet.sendWithTimeout(
                             bolt11: invoice.bolt11,
                             sats: paymentSats,
-                            paymentDeadline: incomingPaymentRequest?.paymentDeadline,
+                            paymentDeadline: incomingPaymentRequest?.submissionDeadline(quoteId: app.paykitPaymentTerms?.quoteId),
                             afterListening: { _ in lightningPaymentSubmitted = true },
                             onTimeout: { timedOutHash in
                                 app.addPendingPaymentHash(timedOutHash, contactPaymentContext: contactPaymentContext)
@@ -1203,7 +1203,7 @@ struct SendConfirmationView: View {
                                 tags: tagManager.selectedTagsArray, contact: contactPublicKey,
                                 createdAt: UInt64(Date().timeIntervalSince1970)
                             ),
-                            paymentDeadline: incomingPaymentRequest?.paymentDeadline,
+                            paymentDeadline: incomingPaymentRequest?.submissionDeadline(quoteId: app.paykitPaymentTerms?.quoteId),
                             beforeBroadcastAttempt: beforeBroadcastAttempt,
                             onPreDispatchFailure: { _ in
                                 guard let incomingPaymentRequest else { return }
diff --git a/Bitkit/Views/Wallets/Send/SendPendingScreen.swift b/Bitkit/Views/Wallets/Send/SendPendingScreen.swift
index f1f93163c..83b7c818e 100644
--- a/Bitkit/Views/Wallets/Send/SendPendingScreen.swift
+++ b/Bitkit/Views/Wallets/Send/SendPendingScreen.swift
@@ -303,8 +303,8 @@ struct SendPendingScreen: View {
                         }
                     }
                     if attempt.requestId != nil {
-                        let request = try await paymentRequests.ensureOnchainRecoveryAllowed(attempt, proofService: proofService)
-                        guard request.paymentDeadline == paymentDeadline else { throw PaykitPaymentRequestError.requestUnavailable }
+                        let authorization = try await paymentRequests.ensureOnchainRecoveryAllowed(attempt, proofService: proofService)
+                        guard authorization.paymentDeadline == paymentDeadline else { throw PaykitPaymentRequestError.requestUnavailable }
                         guard let payer = attempt.recoveryContext?.paymentIdentity else { throw PaykitPaymentRequestError.requestUnavailable }
                         try await proofService.requireRecoveryPayer(payer)
                     } else if let orderId = attempt.orderId {
diff --git a/Bitkit/Views/Wallets/Send/SendSheet.swift b/Bitkit/Views/Wallets/Send/SendSheet.swift
index 0b14e8c29..25cb7470b 100644
--- a/Bitkit/Views/Wallets/Send/SendSheet.swift
+++ b/Bitkit/Views/Wallets/Send/SendSheet.swift
@@ -857,7 +857,6 @@ struct SendSheet: View {
                 hwSend: hwSend,
                 contactPaymentRequestId: contactContext?.incomingPaymentRequest?.id,
                 contactPaymentIdentity: paymentIdentity,
-                contactPaymentDeadline: contactContext?.incomingPaymentRequest?.paymentDeadline,
                 prepareContactPayment: { signedTx in
                     try await prepareHardwareContactPayment(
                         context: contactContext,
diff --git a/BitkitTests/PaykitPaymentProofServiceTests.swift b/BitkitTests/PaykitPaymentProofServiceTests.swift
index 5a433d242..047f50450 100644
--- a/BitkitTests/PaykitPaymentProofServiceTests.swift
+++ b/BitkitTests/PaykitPaymentProofServiceTests.swift
@@ -121,7 +121,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             let sdk = PaymentProofSdkMock(identity: invalid % 4 == 1 ? counterparty : identity, records: invalid % 4 == 3 ? [] : [record])
             let service = paymentProofService(sdk: sdk, store: store, attemptService: attempts)
             do {
-                let authorized = try await service.authorizeOnchainRecovery(original, restoreStartedProof: false)
+                let authorized = try await service.authorizeOnchainRecovery(original, restoreStartedProof: false).request
                 XCTAssertEqual(invalid % 4, 0)
                 XCTAssertEqual(authorized.id, request.id)
                 XCTAssertEqual(authorized.amount.atomic, request.amount.atomic)
@@ -140,7 +140,14 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             every: 1, unit: "month", startsAt: "2026-10-01T08:00:00.123456789Z",
             anchor: "2026-10-01T08:00:00.123456789Z", endsAt: nil
         )
-        let record = try paymentRequestRecord(endpoints: [endpoint], state: .activeRecurring, recurrence: recurrence)
+        var record = try paymentRequestRecord(endpoints: [endpoint], state: .activeRecurring, recurrence: recurrence)
+        let quoteExpiry = PaykitPreciseInstant(date: Date().addingTimeInterval(3600))
+        record.terms?.conversion = .perPeriod
+        record.conversionQuotes = [PaymentConversionQuoteRecord(
+            eventId: "original", billingPeriod: BillingPeriod(startsAt: recurrence.startsAt, endsAt: "2026-11-01T08:00:00.123456789Z"),
+            rates: [ConversionRate(asset: "usdt", value: "100000")], validFrom: recurrence.startsAt,
+            expiresAt: quoteExpiry.timestamp, outboundStatus: nil
+        )]
         let subscription = try XCTUnwrap(PaykitSubscription(record: record))
         let request = try XCTUnwrap(subscription.requests(through: Date(), acceptedAt: PaykitPreciseInstant(date: Date())).first)
         let period = try XCTUnwrap(request.billingPeriod)
@@ -152,16 +159,19 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
                                     satsPerVbyte: 2, utxosToSpend: nil, isMaxAmount: false,
                                     requestId: request.id, paymentIdentity: identity)
         let original = try XCTUnwrap(attemptsStore.snapshot().first)
-        let proof = PendingPaykitPaymentProof(
+        var proof = PendingPaykitPaymentProof(
             identity: identity, requestId: request.id, paymentAppId: "bitkit", paymentEndpointIdentifier: endpoint,
             kind: .onchain, billingPeriod: period, paymentStarted: true,
             paymentIdentifier: original.txid, proofData: nil, onchainAddress: onchainAddress, onchainAmountSats: request.amount.atomic
         )
+        proof.conversionQuoteId = "original"
         let store = PaymentProofMemoryStore()
         await store.seed([proof])
         let sdk = PaymentProofSdkMock(identity: identity, records: [record])
         let service = paymentProofService(sdk: sdk, store: store, attemptService: attempts)
-        let authorized = try await service.authorizeOnchainRecovery(original, restoreStartedProof: false)
+        let authorization = try await service.authorizeOnchainRecovery(original, restoreStartedProof: false)
+        XCTAssertEqual(authorization.paymentDeadline, quoteExpiry)
+        let authorized = authorization.request
         XCTAssertEqual(authorized.id, request.id)
         XCTAssertEqual(authorized.billingPeriod, period)
         XCTAssertEqual(authorized.amount.atomic, original.amountSats)
@@ -287,7 +297,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
             identity: identity, requestId: request.id, transactionId: txid, walletId: hardwareWalletId
         )
         XCTAssertEqual(resolutions, [originalResolution])
-        await service.consumeOnchainPaymentResolution(originalResolution, activeIdentity: (try? sdk.identityStatus())?.publicKey)
+        await service.consumeOnchainPaymentResolution(originalResolution, activeIdentity: sdk.identityStatus()?.publicKey)
         // Recreate the service to discard every process-local replay marker.
         let reopened = paymentProofService(sdk: sdk, store: store, hardwareLookup: lookup)
         await sdk.setIdentity(identity)
@@ -301,7 +311,7 @@ final class PaykitPaymentProofServiceTests: XCTestCase {
         let awaitingConsumption = await store.snapshot().first { PubkyPublicKeyFormat.matches($0.identity, identity) }
         XCTAssertEqual(awaitingConsumption?.onchainResolutionAwaitingConsumption, true,
                        "Proof delivery must retain the original local result until its payer consumes it")
-        await reopened.consumeOnchainPaymentResolution(originalResolution, activeIdentity: (try? sdk.identityStatus())?.publicKey)
+        await reopened.consumeOnchainPaymentResolution(originalResolution, activeIdentity: sdk.identityStatus()?.publicKey)
         await reopened.reconcile()
         XCTAssertEqual(resolutions, [originalResolution, originalResolution], "Returning-payer replay occurs once")
         let lookups = await lookup.calls()
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index da9605215..d54909771 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -1450,6 +1450,39 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertFalse(accepted.requiresAcceptance)
     }
 
+    func testSubmissionDeadlineUsesTheSelectedQuoteAndRequestLimits() throws {
+        let start = "2027-01-01T08:00:00.123456789Z"
+        let now = try XCTUnwrap(PaykitPaymentRequest.parseDate(start))
+        let period = try XCTUnwrap(PaykitBillingPeriod(sdkPeriod: BillingPeriod(
+            startsAt: start, endsAt: "2027-02-01T08:00:00.123456789Z"
+        )))
+        let quoteExpiry = try XCTUnwrap(PaykitPreciseInstant(timestamp: "2027-01-01T08:01:00.123456789Z"))
+        let quote = PaymentConversionQuoteRecord(
+            eventId: "original", billingPeriod: period.sdkValue, rates: [.init(asset: "btc", value: "0.00002")],
+            validFrom: start, expiresAt: quoteExpiry.timestamp, outboundStatus: nil
+        )
+        var later = quote
+        later.eventId = "later"
+        later.expiresAt = "2027-01-01T08:02:00Z"
+        for seconds in [UInt64(30), 120] {
+            var record = try paymentRequestRecord(
+                state: .activeRecurring, amount: "1", asset: "usd", conversion: .perPeriod,
+                paymentDeadline: .periodStart(seconds: seconds),
+                recurrence: PaymentRequestRecurrence(every: 1, unit: "month", startsAt: start, anchor: start, endsAt: nil)
+            )
+            record.conversionQuotes = [quote, later]
+            let subscription = try XCTUnwrap(PaykitSubscription(record: record))
+            let request = PaykitPaymentRequest(subscription: subscription, billingPeriod: period, lifecycleState: .activeRecurring)
+            let deadline = try XCTUnwrap(request.submissionDeadline(quoteId: quote.eventId))
+            XCTAssertEqual(deadline, try min(XCTUnwrap(request.paymentDeadline), quoteExpiry))
+            XCTAssertEqual(deadline.nanoseconds, 123_456_789)
+            XCTAssertEqual(try request.submissionDeadline(quoteId: nil), request.paymentDeadline)
+            XCTAssertNoThrow(try PaykitPaymentRequest.checkPaymentDeadline(deadline, at: now))
+            XCTAssertThrowsError(try PaykitPaymentRequest.checkPaymentDeadline(deadline, at: deadline.date.addingTimeInterval(1)))
+            XCTAssertThrowsError(try request.submissionDeadline(quoteId: "unknown"))
+        }
+    }
+
     func testRecoveryRequiredIncomingRequestRejectsTerminalOrExpiredEvidence() throws {
         let now = Date(timeIntervalSince1970: 1_800_000_000)
         let cases: [(PaymentRequestRecord, PaykitPaymentRequest.ParseFailure)] = try [
@@ -8184,7 +8217,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         manager.activate(identity: identity)
         XCTAssertFalse(manager.isApprovedForPayment(request))
         let beforeProofs = await store.snapshot()
-        let authorized = try await manager.ensureOnchainRecoveryAllowed(attempt, proofService: service)
+        let authorized = try await manager.ensureOnchainRecoveryAllowed(attempt, proofService: service).request
         XCTAssertEqual(authorized.id, request.id)
         XCTAssertEqual(authorized.amount.atomic, attempt.amountSats)
         let afterProofs = await store.snapshot()
diff --git a/BitkitTests/PaykitPaymentStateBackupTests.swift b/BitkitTests/PaykitPaymentStateBackupTests.swift
index f608a3722..256a1423e 100644
--- a/BitkitTests/PaykitPaymentStateBackupTests.swift
+++ b/BitkitTests/PaykitPaymentStateBackupTests.swift
@@ -347,7 +347,8 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         for status in ["pending", "unknown", "rejected", "accepted"] {
             object["status"] = status
             for rates: [String: String]? in [nil, [:], [successor: "4"], [later: "5"],
-                                           [original: "3", successor: "4", later: "5"]] {
+                                             [original: "3", successor: "4", later: "5"]]
+            {
                 object["candidateFeeRates"] = rates
                 XCTAssertThrowsError(try restored(object))
             }
@@ -370,7 +371,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         object["amountSats"] = "1000"
         var understated = object
         understated["transfer"] = ["txTotalSats": "1", "preTransferOnchainSats": "3000",
-                                    "originalOrderClientBalanceSats": "900", "originalOrderFeeSats": "1000"]
+                                   "originalOrderClientBalanceSats": "900", "originalOrderFeeSats": "1000"]
         XCTAssertThrowsError(try restored(understated))
         let attempt = try restored(object)
         XCTAssertEqual(attempt.amountSats, 1000)
diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index 263ab9c9f..28dcb96e4 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -67,6 +67,7 @@ Requires funded Arbitrum accounts, controlled billing time, and controlled recei
 - [ ] Create a BTC request accepting Bitcoin and USDT. Switch the payer between Savings, Spending when enabled, and USDT; verify the requested value is preserved and the quoted amount and fee appear before approval.
 - [ ] Using a controlled billing clock, advance to the next installment with the requester offline. Verify its USD amount still maps exactly to USDT, the fee remains additional, and earlier paid periods remain unchanged.
 - [ ] Using controlled payment evidence, verify underpayment and payment after expiry show actual received funds and the corresponding status, without reporting the transfer as failed.
+- [ ] In the local test setup, prepare a recurring request whose conversion quote expires before the request deadline. Wait for quote expiry before submitting through Savings, Spending and a prepared hardware-wallet retry. Verify no new payment is dispatched; any previously attempted transaction remains recoverable under its original quote.
 - [ ] Pay a contact directly without a request and verify the normal asset selector, send review and activity attribution still work. Verify selecting USDT does not request camera access for an already resolved recipient.
 
 ## USDT design and receive estimates

From a0cec0f1d0641d5b123c86da7ab46478577d64f7 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Sun, 11 Oct 2026 23:40:35 -0500
Subject: [PATCH 14/62] fix: use usdt colors for paid payment requests

---
 Bitkit/Components/LabeledDetailCell.swift          |  3 ++-
 .../PaymentRequests/PaymentRequestsView.swift      | 14 +++++++++-----
 journeys/paykit-quoted-usdt.xml                    |  1 +
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/Bitkit/Components/LabeledDetailCell.swift b/Bitkit/Components/LabeledDetailCell.swift
index b70ba1950..013d6b036 100644
--- a/Bitkit/Components/LabeledDetailCell.swift
+++ b/Bitkit/Components/LabeledDetailCell.swift
@@ -4,6 +4,7 @@ struct LabeledDetailCell: View {
     let title: String
     let value: String
     let icon: String
+    var iconColor: Color = .purpleAccent
 
     var body: some View {
         VStack(alignment: .leading, spacing: 8) {
@@ -11,7 +12,7 @@ struct LabeledDetailCell: View {
             HStack(spacing: 4) {
                 Image(icon)
                     .resizable()
-                    .foregroundColor(.purpleAccent)
+                    .foregroundColor(iconColor)
                     .frame(width: 16, height: 16)
                 BodySSBText(value)
                     .lineLimit(2)
diff --git a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
index 5887735f1..f09fabbcd 100644
--- a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
+++ b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
@@ -624,12 +624,14 @@ struct PaymentRequestDetailView: View {
             LabeledDetailCell(
                 title: t("wallet__payment_request_date"),
                 value: request.createdAt.map(Self.dateFormatter.string) ?? "–",
-                icon: "calendar"
+                icon: "calendar",
+                iconColor: request.paymentProofKind == .usdt ? .usdtAccent : .purpleAccent
             )
             LabeledDetailCell(
                 title: t("wallet__payment_request_time"),
                 value: request.createdAt.map(Self.timeFormatter.string) ?? "–",
-                icon: "clock"
+                icon: "clock",
+                iconColor: request.paymentProofKind == .usdt ? .usdtAccent : .purpleAccent
             )
         }
     }
@@ -721,9 +723,11 @@ struct PaymentRequestDetailView: View {
 
 private extension PaykitPaymentRequest {
     var paymentRailColors: (icon: Color, background: Color) {
-        paymentProofKind == .lightning
-            ? (.purpleAccent, .purple16)
-            : (.brandAccent, .brand16)
+        switch paymentProofKind {
+        case .usdt: (.usdtAccent, .usdtAccent.opacity(0.16))
+        case .lightning: (.purpleAccent, .purple16)
+        default: (.brandAccent, .brand16)
+        }
     }
 }
 
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index 8f616f212..9ed93db49 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -9,5 +9,6 @@
     <action>Open a BTC request with different quoted prices for Bitcoin and Lightning. Switch Savings and Spending and verify the payable BTC amount changes to the selected method's quoted amount. Verify the confirmation uses Bitkit's own fiat valuation and requires approval. Close without paying.</action>
     <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method; close before subscribing.</action>
     <action>Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing.</action>
+    <action>With an existing request paid in USDT, open its history entry on the payer and requester. Verify the sent or received arrow and its background use the USDT teal in the list and details, and the date and time icons in details use the same teal. The color follows the payment method even when the request is denominated in BTC or USD.</action>
   </actions>
 </journey>

From 6d1dade2b7302642eabba97a6fc24d544b84960c Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 00:33:59 -0500
Subject: [PATCH 15/62] test: cover backing out of prepared usdt requests

---
 journeys/paykit-quoted-usdt.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index 9ed93db49..a21825c8a 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -4,6 +4,7 @@
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
     <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Continue to USDT review. Verify Payment Request, the requester avatar, From and For summary, exact dollar amount and additional fee. Open details and verify Contact, recipient address and the invoice note. Close without swiping to pay.</action>
+    <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
     <action>With a linked test payer, open a quoted request for 1000 USD requiring 1 BTC while Bitkit's BTC/USD rate is 2000. Verify the request details label 1000 USD as Requested amount. On payment review, verify 1 BTC and Bitkit's approximately 2000 USD valuation. Close without paying.</action>
     <action>Open a BTC request with different quoted prices for Bitcoin and Lightning. Switch Savings and Spending and verify the payable BTC amount changes to the selected method's quoted amount. Verify the confirmation uses Bitkit's own fiat valuation and requires approval. Close without paying.</action>

From c9313f209ec68d2e33590f8bbd2215522b577b59 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 02:16:59 -0500
Subject: [PATCH 16/62] fix: route USDT payment links to send flow

---
 Bitkit/Info.plist                           |  1 +
 Bitkit/MainNavView.swift                    | 23 ++++++++++++-
 Bitkit/Managers/ScannerManager.swift        | 17 ++++++++++
 Bitkit/ViewModels/AppViewModel.swift        |  2 +-
 Bitkit/ViewModels/NavigationViewModel.swift | 16 +++++++++
 Bitkit/Views/Wallets/UsdtSendView.swift     |  6 ++--
 Bitkit/Views/Wallets/UsdtWalletScreen.swift | 20 +++++++++---
 BitkitTests/PubkyAuthURLSchemeTests.swift   | 12 +++++++
 BitkitTests/UsdtPaymentLinkTests.swift      | 36 +++++++++++++++++++++
 journeys/usdt-payment-links-and-scans.xml   | 13 ++++++++
 10 files changed, 137 insertions(+), 9 deletions(-)
 create mode 100644 BitkitTests/UsdtPaymentLinkTests.swift
 create mode 100644 journeys/usdt-payment-links-and-scans.xml

diff --git a/Bitkit/Info.plist b/Bitkit/Info.plist
index e59e3a2e0..3ef85706e 100644
--- a/Bitkit/Info.plist
+++ b/Bitkit/Info.plist
@@ -21,6 +21,7 @@
 			<array>
 				<string>bitkit</string>
 				<string>bitcoin</string>
+				<string>ethereum</string>
 				<string>BITCOIN</string>
 				<string>lightning</string>
 				<string>LIGHTNING</string>
diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index dd6e744b2..1ba2a445c 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -296,7 +296,8 @@ struct MainNavView: View {
             }
         }
         .onReceive(usdt.receivedTxPublisher) { tx in
-            guard navigation.currentRoute != .usdtWallet, !wallet.isRestoringWallet, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
+            guard navigation.currentRoute?.isUsdtWalletRoute != true,
+                  !wallet.isRestoringWallet, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
             sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount, usdtTransferId: tx.id))
         }
         .onReceive(hwWalletManager.receivedTxPublisher) { tx in
@@ -463,6 +464,7 @@ struct MainNavView: View {
                 case .spendingWallet: SpendingWalletScreen()
                 case let .hardwareWallet(walletId): HardwareWalletScreen(walletId: walletId)
                 case .usdtWallet: UsdtWalletScreen()
+                case let .usdtPayment(recipient, amount): UsdtWalletScreen(initialRecipient: recipient, initialAmount: amount)
                 case let .usdtActivity(transferId): UsdtActivityDetail(transferId: transferId)
                 case .scanner: ScannerScreen()
 
@@ -742,6 +744,16 @@ struct MainNavView: View {
 
         Task { @MainActor in
             do {
+                if let route = try resolveUsdtPaymentRoute(input: uri) {
+                    guard !usdt.isSendPresented else { return }
+                    let path = navigation.path
+                    sheets.hideSheetBeforePerforming(reason: "Clipboard routed USDT payment") {
+                        guard !usdt.isSendPresented, navigation.path == path else { return }
+                        navigation.navigate(route)
+                    }
+                    clipboardUri = nil
+                    return
+                }
                 if let route = resolvePastedPubkyRoute(
                     input: uri,
                     ownPublicKey: pubkyProfile.publicKey,
@@ -835,6 +847,15 @@ struct MainNavView: View {
         }
 
         do {
+            if let route = try resolveUsdtPaymentRoute(input: url.absoluteString) {
+                guard !usdt.isSendPresented else { return }
+                let path = navigation.path
+                sheets.hideSheetBeforePerforming(reason: "Deeplink routed USDT payment") {
+                    guard !usdt.isSendPresented, navigation.path == path else { return }
+                    navigation.navigate(route)
+                }
+                return
+            }
             if PubkyContactLink.matches(url) {
                 guard let publicKey = try pubkyContactPublicKeyForRouting(from: url, isPaykitUIActive: isPaykitUIActive) else { return }
                 guard pubkyProfile.initializationErrorMessage == nil,
diff --git a/Bitkit/Managers/ScannerManager.swift b/Bitkit/Managers/ScannerManager.swift
index a3f2561df..0b0a38e24 100644
--- a/Bitkit/Managers/ScannerManager.swift
+++ b/Bitkit/Managers/ScannerManager.swift
@@ -91,6 +91,14 @@ class ScannerManager: ObservableObject {
         guard let app else { return }
 
         do {
+            if let route = try resolveUsdtPaymentRoute(input: uri) {
+                let path = navigation?.path
+                sheets?.hideSheetBeforePerforming(reason: "Scanner routed USDT payment") { [weak self] in
+                    guard let self, wallet?.usdtWallet.isSendPresented == false, navigation?.path == path else { return }
+                    navigation?.navigate(route)
+                }
+                return
+            }
             if handlePubkyRouteIfNeeded(uri) {
                 return
             }
@@ -180,6 +188,15 @@ class ScannerManager: ObservableObject {
         }
 
         do {
+            if scope == .unrestricted, let route = try resolveUsdtPaymentRoute(input: uri) {
+                let path = navigation?.path
+                sheets?.hideSheetBeforePerforming(reason: "Send scanner routed USDT payment") { [weak self] in
+                    guard let self, wallet?.usdtWallet.isSendPresented == false, navigation?.path == path else { return }
+                    navigation?.navigate(route)
+                }
+                completion(nil)
+                return
+            }
             if handlePubkyRouteIfNeeded(uri, hiding: .send, reason: "Send scanner routed pubky key") {
                 completion(nil)
                 return
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index f61e688f6..725fb4537 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -240,7 +240,7 @@ class AppViewModel: ObservableObject {
         if SamRockSetupRequest.isProtocolURL(url.absoluteString) {
             return false
         }
-        if url.scheme?.lowercased() == "bitcoin" {
+        if let scheme = url.scheme?.lowercased(), scheme == "bitcoin" || scheme == "ethereum" {
             return false
         }
         if isBolt11Invoice(url) {
diff --git a/Bitkit/ViewModels/NavigationViewModel.swift b/Bitkit/ViewModels/NavigationViewModel.swift
index 81741e3d5..a8e15e6ed 100644
--- a/Bitkit/ViewModels/NavigationViewModel.swift
+++ b/Bitkit/ViewModels/NavigationViewModel.swift
@@ -11,6 +11,7 @@ enum Route: Hashable {
     case spendingWallet
     case hardwareWallet(walletId: String)
     case usdtWallet
+    case usdtPayment(recipient: String, amount: String)
     case usdtActivity(transferId: String)
     case activityList
     case activityDetail(Activity)
@@ -147,6 +148,13 @@ extension Route {
             return false
         }
     }
+
+    var isUsdtWalletRoute: Bool {
+        switch self {
+        case .usdtWallet, .usdtPayment: true
+        default: false
+        }
+    }
 }
 
 func shouldDiscardPendingImport(currentRoute: Route?, destination: Route?) -> Bool {
@@ -185,6 +193,14 @@ func resolvePastedPubkyRoute(input: String, ownPublicKey: String?, contacts: [Pu
     resolvePubkyRoute(input: input, ownPublicKey: ownPublicKey, contacts: contacts)
 }
 
+func resolveUsdtPaymentRoute(input: String, isEnabled: Bool = Env.isUsdtEnabled) throws -> Route? {
+    let input = input.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard input.lowercased().hasPrefix("ethereum:") else { return nil }
+    guard isEnabled else { throw ScanHandlingError.unsupportedRequest }
+    let request = try usdtParsePaymentRequest(value: input)
+    return .usdtPayment(recipient: request.recipient, amount: request.amount.map { usdtFormatAmount(amount: $0) } ?? "")
+}
+
 @MainActor
 class NavigationViewModel: ObservableObject {
     @Published var path: [Route] = []
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index c733c893f..ff3789f9c 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -103,12 +103,14 @@ struct UsdtSendView: View {
             if embedded { content }
             else { NavigationStack { content } }
         }
+        .onAppear { usdt.isSendPresented = true }
+        .onDisappear { usdt.isSendPresented = false }
         .task {
             if !embedded {
                 do { destinations = try await usdt.sendDestinations() }
                 catch { Logger.warn("Could not load USDT bridge destinations", context: "UsdtSendView") }
             }
-            guard !initialRecipient.isEmpty, quote == nil else { return }
+            guard !initialRecipient.isEmpty, !initialAmount.isEmpty, quote == nil else { return }
             busy = true
             defer { busy = false }
             do { quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination) }
@@ -154,8 +156,6 @@ struct UsdtSendView: View {
             }
             await PaykitUsdtPaymentService.shared.reconcile(wallet: usdt)
         }
-        .onAppear { usdt.isSendPresented = true }
-        .onDisappear { usdt.isSendPresented = false }
         .interactiveDismissDisabled(busy || pin)
         .alert(t("common__are_you_sure"), isPresented: Binding(
             get: { warning != nil },
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index 34ebb2b17..912922b12 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -7,6 +7,14 @@ struct UsdtWalletScreen: View {
     @EnvironmentObject private var sheets: SheetViewModel
     @State private var showSend = false
     @State private var selectedTransferId: String?
+    @State private var sendRecipient: String
+    @State private var sendAmount: String
+
+    init(initialRecipient: String = "", initialAmount: String = "") {
+        _sendRecipient = State(initialValue: initialRecipient)
+        _sendAmount = State(initialValue: initialAmount)
+        _showSend = State(initialValue: !initialRecipient.isEmpty)
+    }
 
     var body: some View {
         ZStack(alignment: .top) {
@@ -44,8 +52,12 @@ struct UsdtWalletScreen: View {
             VStack {
                 Spacer()
                 HStack(spacing: 0) {
-                    TabBarButton(title: t("wallet__send"), icon: "arrow-up", variant: .left) { showSend = true }
-                        .accessibilityIdentifier("UsdtSend")
+                    TabBarButton(title: t("wallet__send"), icon: "arrow-up", variant: .left) {
+                        sendRecipient = ""
+                        sendAmount = ""
+                        showSend = true
+                    }
+                    .accessibilityIdentifier("UsdtSend")
                     TabBarButton(title: t("wallet__receive"), icon: "arrow-down", variant: .right) {
                         sheets.showSheet(.receive, data: ReceiveConfig(view: .usdt))
                     }
@@ -64,10 +76,10 @@ struct UsdtWalletScreen: View {
         }
         .sheet(isPresented: $showSend) {
             Sheet(id: .send, data: SendSheetItem()) {
-                UsdtSendView { id in
+                UsdtSendView(onDetails: { id in
                     showSend = false
                     selectedTransferId = id
-                }
+                }, initialRecipient: sendRecipient, initialAmount: sendAmount)
             }
         }
         .navigationDestination(isPresented: Binding(
diff --git a/BitkitTests/PubkyAuthURLSchemeTests.swift b/BitkitTests/PubkyAuthURLSchemeTests.swift
index 19b72a5e4..e405f2fd8 100644
--- a/BitkitTests/PubkyAuthURLSchemeTests.swift
+++ b/BitkitTests/PubkyAuthURLSchemeTests.swift
@@ -163,6 +163,18 @@ final class PubkyAuthURLSchemeTests: XCTestCase {
         }
         XCTAssertNil(app.pendingDeepLinkURL)
 
+        let usdtURL =
+            try XCTUnwrap(URL(string: "ethereum:\(PaykitUsdt.token)@42161/transfer?address=0x18503bD685aF84E6A7bC289898bAa1C3f5d8527E&uint256=10001"))
+        app.retainDeepLink(usdtURL)
+        await app.routePendingDeepLinkIfReady(false, nodeIsRunning: false) { _ in
+            XCTFail("USDT links must respect wallet startup gates")
+        }
+        XCTAssertEqual(app.pendingDeepLinkURL, usdtURL)
+        await app.routePendingDeepLinkIfReady(true, nodeIsRunning: false) { routedURL in
+            XCTAssertEqual(routedURL, usdtURL)
+        }
+        XCTAssertNil(app.pendingDeepLinkURL)
+
         app.retainDeepLink(bolt11URL)
         await app.routePendingDeepLinkIfReady(true, nodeIsRunning: false) { routedURL in
             XCTAssertEqual(routedURL, bolt11URL)
diff --git a/BitkitTests/UsdtPaymentLinkTests.swift b/BitkitTests/UsdtPaymentLinkTests.swift
new file mode 100644
index 000000000..604b7d023
--- /dev/null
+++ b/BitkitTests/UsdtPaymentLinkTests.swift
@@ -0,0 +1,36 @@
+@testable import Bitkit
+import XCTest
+
+final class UsdtPaymentLinkTests: XCTestCase {
+    private let recipient = "0x18503bD685aF84E6A7bC289898bAa1C3f5d8527E"
+    private var uri: String {
+        "ethereum:\(PaykitUsdt.token)@42161/transfer?address=\(recipient)"
+    }
+
+    func testPaymentLinkPreservesOptionalAtomicAmount() throws {
+        XCTAssertEqual(try resolveUsdtPaymentRoute(input: uri, isEnabled: true), .usdtPayment(recipient: recipient, amount: ""))
+        XCTAssertEqual(try resolveUsdtPaymentRoute(input: " \(uri)&uint256=10001\n", isEnabled: true),
+                       .usdtPayment(recipient: recipient, amount: "0.010001"))
+        XCTAssertEqual(try resolveUsdtPaymentRoute(input: uri.replacingOccurrences(of: "ethereum:", with: "ETHEREUM:"), isEnabled: true),
+                       .usdtPayment(recipient: recipient, amount: ""))
+    }
+
+    func testUnsupportedPaymentLinksCannotOpenTheWallet() {
+        for input in [
+            uri.replacingOccurrences(of: "@42161", with: "@1"),
+            uri.replacingOccurrences(of: PaykitUsdt.token, with: recipient),
+            uri + "&uint256=1&uint256=2",
+            uri + "&uint256=-1",
+            uri + "&unknown=1",
+        ] {
+            XCTAssertThrowsError(try resolveUsdtPaymentRoute(input: input, isEnabled: true), input)
+        }
+        XCTAssertThrowsError(try resolveUsdtPaymentRoute(input: uri, isEnabled: false))
+    }
+
+    func testOtherInputsRemainWithTheirExistingScanner() throws {
+        for input in [recipient, "bitcoin:bcrt1qexample", "lightning:lnbcrt1example", "pubkyexample", ""] {
+            XCTAssertNil(try resolveUsdtPaymentRoute(input: input, isEnabled: true), input)
+        }
+    }
+}
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
new file mode 100644
index 000000000..c96997851
--- /dev/null
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -0,0 +1,13 @@
+<journey name="usdt payment links and scans">
+  <description>Use an onboarded wallet with USDT configured and another owned wallet's Arbitrum receive URI. No payment is submitted. Hardware-wallet send remains Bitcoin-only.</description>
+  <actions>
+    <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount or review screen preserves recipient and 0.010001 USDT. Verify no payment occurs without approval.</action>
+    <action>Cancel the send, then reopen the identical URI. Verify the amount or review screen opens again. Cancel and open a different owned recipient and amount, verifying only the new values appear.</action>
+    <action>While a USDT contact payment or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
+    <action>Cancel the send. Open the same link without uint256. Verify the amount screen opens with no amount and accepts a new amount.</action>
+    <action>Cancel the send. From the main scanner, paste or import a QR containing the same amount-bearing URI. Verify it opens the USDT send flow with the same recipient and amount.</action>
+    <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
+    <action>Open or scan variants with the wrong chain, wrong token, duplicate amount and malformed recipient. Verify an error and no payable review. Check an ordinary Bitcoin or Lightning invoice still opens its existing send flow.</action>
+    <action>On iOS, open a USDT link while Lightning is stopped but the wallet is ready. Verify it routes without starting Lightning. Open two different USDT links while the main scanner sheet is dismissing; verify an older delayed link cannot replace the review that opened first.</action>
+  </actions>
+</journey>

From c01ea851f06df8963a965fa680bb09b13cdfbbff Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 05:40:50 -0500
Subject: [PATCH 17/62] test: add Lightning fee review journey

---
 journeys/send/lightning-fee-review.xml | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 journeys/send/lightning-fee-review.xml

diff --git a/journeys/send/lightning-fee-review.xml b/journeys/send/lightning-fee-review.xml
new file mode 100644
index 000000000..44c92cf77
--- /dev/null
+++ b/journeys/send/lightning-fee-review.xml
@@ -0,0 +1,19 @@
+<journey name="lightning fee review">
+  <description>
+    Verifies that fixed-amount Lightning invoices and Paykit requests show an available numeric
+    routing-fee estimate before payment approval. Preconditions: two owned regtest wallets linked
+    as contacts, usable Spending channels with a nonzero route fee, and QuickPay disabled on the
+    sending wallet. Keep both apps running. Review and cancel each payment without submitting it.
+  </description>
+  <actions>
+    <action>On the receiving wallet, create a fresh 1,000-sat Lightning invoice from Receive and copy its complete invoice</action>
+    <action>Open that invoice on the sending wallet with a lightning: deep link</action>
+    <action>Verify confirmation shows 1,000 sats without requiring amount entry</action>
+    <action>Open Show Details and verify Spending, the recipient invoice and a numeric estimated fee</action>
+    <action>Dismiss the send review without swiping to pay and verify no outgoing payment was created</action>
+    <action>On the receiving wallet, create a fresh 1,000-sat payment request for the sending contact with Spending as its only accepted payment method</action>
+    <action>On the sending wallet, open the received payment request and tap Pay if it has not opened automatically</action>
+    <action>Open Show Details and verify confirmation shows 1,000 sats, Spending, the receiving contact and a numeric estimated fee</action>
+    <action>Dismiss the send review without swiping to pay and verify the request remains unpaid</action>
+  </actions>
+</journey>

From 964b5669492a6cb46953c0395d12f30bfc2c7491 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 08:14:37 -0500
Subject: [PATCH 18/62] fix: distinguish usdt proofs and explain fee failures

---
 Bitkit/Managers/UsdtWalletManager.swift       |  3 ++-
 .../Localization/en.lproj/Localizable.strings |  1 +
 .../PaymentRequests/PaymentRequestsView.swift |  2 +-
 .../PaykitPaymentRequestServiceTests.swift    | 23 ++++++++++++++++++-
 BitkitTests/UsdtWalletManagerTests.swift      |  8 +++++++
 Docs/USDT.md                                  |  4 ++++
 journeys/paykit-quoted-usdt.xml               |  2 ++
 journeys/usdt-payment-links-and-scans.xml     |  1 +
 8 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index c2cba39b9..8096f1540 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -369,7 +369,8 @@ final class UsdtWalletManager {
         case .RateLimited: return t("usdt__error_rate_limit")
         case .LogRangeTooLarge: return t("usdt__error_response")
         case .InvalidPaymentProof, .InvalidResponse: return t("usdt__error_response")
-        case .TransactionRejected: return t("usdt__error_rejected")
+        case let .TransactionRejected(reason):
+            return t(reason == "Paymaster fee collection failed" ? "usdt__error_fee_collection" : "usdt__error_rejected")
         case .NetworkUnavailable: return t("usdt__error_network")
         }
     }
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 8cb4f88ca..12a2de851 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1823,6 +1823,7 @@
 "usdt__error_configuration" = "USDT is currently unavailable. Please try again later.";
 "usdt__error_delegation" = "This address uses another wallet’s smart account. Disable its smart account mode there before sending with Bitkit.";
 "usdt__error_expired" = "The fee quote expired. Review the payment again.";
+"usdt__error_fee_collection" = "Unable to pay the transaction fee in USDT. Try a smaller amount.";
 "usdt__error_network" = "Could not update USDT. Check your connection and try again.";
 "usdt__error_pending" = "A payment is still pending. Wait for confirmation before sending again.";
 "usdt__error_rate_limit" = "Too many requests. Please try again shortly.";
diff --git a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
index f09fabbcd..612707e3f 100644
--- a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
+++ b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
@@ -43,7 +43,7 @@ enum PaymentRequestDisplay {
         case .canceled:
             return "wallet__payment_request_status_canceled"
         case .proofSubmitted:
-            return "wallet__payment_request_status_paid"
+            return "wallet__payment_request_status_proof_submitted"
         case .recoveryRequired:
             return "wallet__payment_request_status_action_required"
         case .invalidConflict, .activeRecurring, .unknown:
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index d54909771..77c9d02d5 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -649,6 +649,27 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         }
     }
 
+    func testUsdtOnlyPrivateContactRetainsItsEndpointAndListVersion() async throws {
+        snapshotAppDefaultsDomain()
+        UserDefaults.standard.removeObject(forKey: PrivatePaykitService.cacheStateKey)
+        let service = PrivatePaykitService()
+        let publicKey = "pubky3rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg"
+        let endpoint = try PaykitUsdt.endpoint(address: "0x1111111111111111111111111111111111111111")
+        var resolution = try boundResolution(publicKey: publicKey, method: .usdtArbitrum, payload: endpoint.rawPayload)
+        resolution.privatePaymentListVersion = 7
+        let result = await service.privatePaymentResult(
+            publicKey: publicKey, paymentRequest: nil, resolution: resolution,
+            validateEndpoints: { endpoints, _ in
+                XCTAssertEqual(endpoints.map(\.methodId), [.usdtArbitrum])
+                return endpoints
+            }
+        )
+        guard case let .opened(target, context, endpoints) = result else { return XCTFail("Expected the private USDT endpoint") }
+        XCTAssertEqual(target, PaykitUsdt.paymentURI(address: endpoint.value))
+        XCTAssertEqual(context?.paymentListVersion, 7)
+        XCTAssertEqual(endpoints.map(\.value), [endpoint.value])
+    }
+
     func testRequestEndpointUsesOnlyPayableResolvedCandidates() async throws {
         snapshotAppDefaultsDomain()
         UserDefaults.standard.removeObject(forKey: PrivatePaykitService.cacheStateKey)
@@ -4436,7 +4457,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         XCTAssertEqual(PaymentRequestDisplay.paymentDirection(for: paidRequest), .incoming)
         XCTAssertEqual(
             PaymentRequestDisplay.statusKey(for: paidRequest, isActionable: false),
-            "wallet__payment_request_status_paid"
+            "wallet__payment_request_status_proof_submitted"
         )
     }
 
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 9fbbce9c6..2e0fc2e09 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -4,6 +4,14 @@ import XCTest
 
 @MainActor
 final class UsdtWalletManagerTests: XCTestCase {
+    func testFeeCollectionFailureIsActionableWithoutMisclassifyingOtherRejections() {
+        XCTAssertEqual(UsdtWalletManager.message(for: UsdtError.TransactionRejected(reason: "Paymaster fee collection failed")),
+                       t("usdt__error_fee_collection"))
+        XCTAssertEqual(UsdtWalletManager.message(for: UsdtError.TransactionRejected(reason: "Provider rejected the request")),
+                       t("usdt__error_rejected"))
+        XCTAssertEqual(UsdtWalletManager.message(for: UsdtError.InsufficientBalance), t("usdt__error_balance"))
+    }
+
     func testOnlyNewConfirmedReceiptsCelebrateAfterInitialSync() {
         let old = transfer("old")
         let incoming = transfer("new")
diff --git a/Docs/USDT.md b/Docs/USDT.md
index 8cf0d7699..fb482c263 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -45,3 +45,7 @@ Orchestra routing costs are deducted from the entered USDT principal. Review sho
 ## Validation
 
 UI journeys cover unfunded wallet navigation, immutable request review and receiving-detail consent. [Manual integration checks](USDT-QA.md) cover funded settlement, provider behavior, restore faults and billing-clock changes that the journey environment does not supply.
+
+Direct contact sends retain the contact on the sending wallet. A direct incoming transfer to the shared USDT address has no authenticated Paykit contact identity and is displayed without a contact. Incoming request payments gain attribution only after the request-bound proof and on-chain transfer are verified; the address or an unverified sender claim is not sufficient.
+
+“Proof submitted” describes Paykit proof delivery, not independent payment verification. A matching verified USDT receipt supplies the received, underpaid or late-payment status.
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index a21825c8a..724cb7fc5 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -11,5 +11,7 @@
     <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method; close before subscribing.</action>
     <action>Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing.</action>
     <action>With an existing request paid in USDT, open its history entry on the payer and requester. Verify the sent or received arrow and its background use the USDT teal in the list and details, and the date and time icons in details use the same teal. The color follows the payment method even when the request is denominated in BTC or USD.</action>
+    <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01 and continue to review. Verify the owned recipient address and fee, then close without paying.</action>
+    <action>Open request history on both wallets. A delivered proof without independent receipt verification says Proof submitted, not Paid. A received USDT request shows Pending until its matching proof is verified, then Payment verified, Received underpaid or Received after expiry with the actual USDT amount, without a second conflicting proof-delivery label.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index c96997851..34e346ac0 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -9,5 +9,6 @@
     <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
     <action>Open or scan variants with the wrong chain, wrong token, duplicate amount and malformed recipient. Verify an error and no payable review. Check an ordinary Bitcoin or Lightning invoice still opens its existing send flow.</action>
     <action>On iOS, open a USDT link while Lightning is stopped but the wallet is ready. Verify it routes without starting Lightning. Open two different USDT links while the main scanner sheet is dismissing; verify an older delayed link cannot replace the review that opened first.</action>
+    <action>Enter the entire available USDT balance and continue. Verify the fee-collection error explains that the transaction fee could not be paid in USDT and suggests a smaller amount. Reduce the amount, reach review and close without signing.</action>
   </actions>
 </journey>

From bc9700ffb7f7a2f71f2be8edcc4406ea6057efed Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 08:45:33 -0500
Subject: [PATCH 19/62] chore: use the public usdt gateway

---
 Bitkit.xcodeproj/project.pbxproj |  8 ++++++++
 Docs/USDT.md                     | 13 +++++++++++--
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/Bitkit.xcodeproj/project.pbxproj b/Bitkit.xcodeproj/project.pbxproj
index df6967870..2bd3ae1ae 100644
--- a/Bitkit.xcodeproj/project.pbxproj
+++ b/Bitkit.xcodeproj/project.pbxproj
@@ -990,6 +990,10 @@
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = 1;
+				USDT_BRIDGES_URL = "https://bitkit.to/v1/usdt/bridges";
+				USDT_BUNDLER_URL = "https://bitkit.to/v1/usdt/rpc";
+				USDT_DEPOSITS_URL = "https://bitkit.to/v1/usdt/deposits";
+				USDT_RPC_URL = "https://bitkit.to/v1/usdt/chain-rpc";
 			};
 			name = Debug;
 		};
@@ -1039,6 +1043,10 @@
 				SWIFT_EMIT_LOC_STRINGS = YES;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = 1;
+				USDT_BRIDGES_URL = "https://bitkit.to/v1/usdt/bridges";
+				USDT_BUNDLER_URL = "https://bitkit.to/v1/usdt/rpc";
+				USDT_DEPOSITS_URL = "https://bitkit.to/v1/usdt/deposits";
+				USDT_RPC_URL = "https://bitkit.to/v1/usdt/chain-rpc";
 			};
 			name = Release;
 		};
diff --git a/Docs/USDT.md b/Docs/USDT.md
index fb482c263..97d3d5117 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -2,9 +2,18 @@
 
 Normal builds use published bitkit-core `0.8.0-rc2`, including its matching native libraries and generated bindings.
 
-USDT uses Arbitrum One regardless of the Bitcoin network setting. `USDT_RPC_URL` and `USDT_BUNDLER_URL` must point to the controlled service's credential-free HTTPS chain and bundler routes. Info.plist/build settings provide release configuration; local runs can supply process environment overrides. Missing endpoints hide the wallet entry.
+USDT uses Arbitrum One regardless of the Bitcoin network setting. Builds use the credential-free Bitkit gateway by default:
 
-Optional `USDT_DEPOSITS_URL` enables wallet-signed Orchestra deposits. Provider keys remain on the service. Source support covers Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain, subject to explicit service enablement and live route availability. Each source requires funded acceptance before release. Users approve a source-network refund address when requesting an eligible refund; unconverted Tron refunds require provider support. History and addresses recover under the same provider partner account. Linked order amounts are batch totals. Outbound USDT0 destinations are enabled with `USDT_BRIDGE_NETWORKS`, a comma-separated subset of `ethereum,polygon,plasma,stable`, matching the service configuration. Empty configuration offers Arbitrum only. Paykit always uses direct Arbitrum payments.
+| Setting | Default |
+| --- | --- |
+| `USDT_BRIDGES_URL` | `https://bitkit.to/v1/usdt/bridges` |
+| `USDT_BUNDLER_URL` | `https://bitkit.to/v1/usdt/rpc` |
+| `USDT_DEPOSITS_URL` | `https://bitkit.to/v1/usdt/deposits` |
+| `USDT_RPC_URL` | `https://bitkit.to/v1/usdt/chain-rpc` |
+
+Xcode build settings override these defaults. Local runs also accept process environment and launch-argument overrides. For local E2E testing, override all four URLs with the matching local service routes. Clearing the RPC or bundler build setting disables USDT; clearing the deposits or bridges setting disables that provider API.
+
+Optional `USDT_DEPOSITS_URL` enables wallet-signed Orchestra deposits. Provider keys remain on the service. Source support covers Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain, subject to explicit service enablement and live route availability. Each source requires funded acceptance before release. Users approve a source-network refund address when requesting an eligible refund; unconverted Tron refunds require provider support. History and addresses recover under the same provider partner account. Linked order amounts are batch totals. Outbound USDT0 destinations are enabled with `USDT_BRIDGE_NETWORKS`, a comma-separated subset of `ethereum,polygon,plasma,stable`, matching the service configuration. An empty USDT0 network list disables USDT0 bridging; Orchestra destinations are discovered separately through `USDT_BRIDGES_URL`. Paykit always uses direct Arbitrum payments.
 
 `scripts/build-usdt-local.sh` accepts a core checkout followed by xcodebuild arguments and selects the local package through `BITKIT_CORE_LOCAL`. Bindings and native libraries must come from the same core build.
 

From c18a8cc4c6dbeb31b4320b82034e4aa151c5adcf Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 10:20:24 -0500
Subject: [PATCH 20/62] fix: preserve reviewed payment terms

---
 Bitkit.xcodeproj/project.pbxproj              |  2 +-
 .../xcshareddata/swiftpm/Package.resolved     |  4 +-
 Bitkit/MainNavView.swift                      |  8 ++--
 Bitkit/Managers/ScannerManager.swift          | 11 ++++-
 Bitkit/Managers/UsdtWalletManager.swift       | 11 ++++-
 .../Services/PaykitUsdtPaymentService.swift   |  3 +-
 Bitkit/ViewModels/AppViewModel.swift          |  7 +++
 .../PaymentRequests/PaymentRequestsView.swift |  1 -
 .../Subscriptions/SubscriptionsView.swift     |  1 -
 Bitkit/Views/Wallets/Receive/ReceiveQr.swift  | 17 ++++++-
 .../Views/Wallets/Send/SendAmountView.swift   | 21 ++++++--
 .../Wallets/Send/SendConfirmationView.swift   | 23 ++++++---
 .../Wallets/UsdtDepositHistoryView.swift      |  7 ++-
 Bitkit/Views/Wallets/UsdtReceiveView.swift    | 18 ++++---
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |  1 +
 .../PaykitPaymentRequestServiceTests.swift    |  3 ++
 .../PaymentNavigationHelperTests.swift        | 19 ++++++++
 .../SendConfirmationLifecycleTests.swift      | 21 ++++++++
 BitkitTests/SendConfirmationViewTests.swift   | 20 ++++++++
 BitkitTests/UsdtWalletManagerTests.swift      | 30 ++++++++++++
 BitkitUITests/UsdtWalletUITests.swift         | 48 ++++++++++++++-----
 Docs/USDT-QA.md                               | 12 +++++
 Docs/USDT.md                                  |  4 +-
 journeys/paykit-quoted-usdt.xml               | 10 ++--
 journeys/send/lightning-fee-review.xml        |  4 ++
 journeys/usdt-payment-links-and-scans.xml     |  2 +-
 journeys/usdt-receive-amount-and-units.xml    |  2 +
 journeys/usdt-wallet-navigation.xml           |  2 +-
 28 files changed, 256 insertions(+), 56 deletions(-)

diff --git a/Bitkit.xcodeproj/project.pbxproj b/Bitkit.xcodeproj/project.pbxproj
index 2bd3ae1ae..1c2328a65 100644
--- a/Bitkit.xcodeproj/project.pbxproj
+++ b/Bitkit.xcodeproj/project.pbxproj
@@ -1234,7 +1234,7 @@
 			repositoryURL = "https://github.com/synonymdev/bitkit-core";
 			requirement = {
 				kind = exactVersion;
-				version = "0.8.0-rc2";
+				version = "0.8.0-rc3";
 			};
 		};
 		96E493A22C942FD1000E8BC2 /* XCRemoteSwiftPackageReference "swift-secp256k1" */ = {
diff --git a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
index 3489dad26..2e7726992 100644
--- a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
+++ b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -6,8 +6,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/synonymdev/bitkit-core",
       "state" : {
-        "revision" : "bdce512c9d1025ba6cd71baa8c2df1a39dcb3d02",
-        "version" : "0.8.0-rc2"
+        "revision" : "98bf9c666a9342fb498cc99cd1676ed2195eb910",
+        "version" : "0.8.0-rc3"
       }
     },
     {
diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 1ba2a445c..9712038ef 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -745,10 +745,10 @@ struct MainNavView: View {
         Task { @MainActor in
             do {
                 if let route = try resolveUsdtPaymentRoute(input: uri) {
-                    guard !usdt.isSendPresented else { return }
+                    guard !usdt.isSendPresented, app.contactPaymentContext == nil else { return }
                     let path = navigation.path
                     sheets.hideSheetBeforePerforming(reason: "Clipboard routed USDT payment") {
-                        guard !usdt.isSendPresented, navigation.path == path else { return }
+                        guard !usdt.isSendPresented, app.contactPaymentContext == nil, navigation.path == path else { return }
                         navigation.navigate(route)
                     }
                     clipboardUri = nil
@@ -848,10 +848,10 @@ struct MainNavView: View {
 
         do {
             if let route = try resolveUsdtPaymentRoute(input: url.absoluteString) {
-                guard !usdt.isSendPresented else { return }
+                guard !usdt.isSendPresented, app.contactPaymentContext == nil else { return }
                 let path = navigation.path
                 sheets.hideSheetBeforePerforming(reason: "Deeplink routed USDT payment") {
-                    guard !usdt.isSendPresented, navigation.path == path else { return }
+                    guard !usdt.isSendPresented, app.contactPaymentContext == nil, navigation.path == path else { return }
                     navigation.navigate(route)
                 }
                 return
diff --git a/Bitkit/Managers/ScannerManager.swift b/Bitkit/Managers/ScannerManager.swift
index 0b0a38e24..5f3a1f277 100644
--- a/Bitkit/Managers/ScannerManager.swift
+++ b/Bitkit/Managers/ScannerManager.swift
@@ -92,9 +92,11 @@ class ScannerManager: ObservableObject {
 
         do {
             if let route = try resolveUsdtPaymentRoute(input: uri) {
+                guard app.contactPaymentContext == nil, wallet?.usdtWallet.isSendPresented == false else { return }
                 let path = navigation?.path
                 sheets?.hideSheetBeforePerforming(reason: "Scanner routed USDT payment") { [weak self] in
-                    guard let self, wallet?.usdtWallet.isSendPresented == false, navigation?.path == path else { return }
+                    guard let self, app.contactPaymentContext == nil, wallet?.usdtWallet.isSendPresented == false,
+                          navigation?.path == path else { return }
                     navigation?.navigate(route)
                 }
                 return
@@ -189,9 +191,14 @@ class ScannerManager: ObservableObject {
 
         do {
             if scope == .unrestricted, let route = try resolveUsdtPaymentRoute(input: uri) {
+                guard app.contactPaymentContext == nil, wallet?.usdtWallet.isSendPresented == false else {
+                    completion(nil)
+                    return
+                }
                 let path = navigation?.path
                 sheets?.hideSheetBeforePerforming(reason: "Send scanner routed USDT payment") { [weak self] in
-                    guard let self, wallet?.usdtWallet.isSendPresented == false, navigation?.path == path else { return }
+                    guard let self, app.contactPaymentContext == nil, wallet?.usdtWallet.isSendPresented == false,
+                          navigation?.path == path else { return }
                     navigation?.navigate(route)
                 }
                 completion(nil)
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index 8096f1540..473a21122 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -132,7 +132,9 @@ final class UsdtWalletManager {
         return try PaykitUsdt.endpoint(address: wallet.receiveAddress())
     }
 
-    func send(_ quote: UsdtQuote, beforeSubmission: @escaping @MainActor () async throws -> Void = {}) async throws {
+    func send(_ quote: UsdtQuote, submissionDeadline: PaykitPreciseInstant? = nil,
+              beforeSubmission: @escaping @MainActor () async throws -> Void = {}) async throws
+    {
         try beginOperation()
         defer { finishOperation() }
         let wallet = try await wallet()
@@ -140,7 +142,10 @@ final class UsdtWalletManager {
             guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
             let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
             try await beforeSubmission()
-            return try await wallet.send(quoteId: quote.id, mnemonic: mnemonic, passphrase: passphrase)
+            return try await wallet.sendWithDeadline(
+                quoteId: quote.id, mnemonic: mnemonic, passphrase: passphrase,
+                submissionDeadline: submissionDeadline?.timestamp
+            )
         }
         transfers.removeAll { $0.id == transfer.id }
         transfers.insert(transfer, at: 0)
@@ -350,6 +355,8 @@ final class UsdtWalletManager {
         case .InvalidAddress, .WrongNetwork: return t("usdt__error_address")
         case .InsufficientBalance: return t("usdt__error_balance")
         case .QuoteExpired: return t("usdt__error_expired")
+        case .SubmissionDeadlineExpired: return t("wallet__payment_request_expired")
+        case .InvalidSubmissionDeadline: return t("wallet__payment_request_unavailable")
         case .PendingTransfer: return t("usdt__error_pending")
         case .DepositNeedsAttention: return t("usdt__deposit_attention")
         case .DepositNotFound: return t("usdt__deposit_not_found")
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
index de8741900..c5e039c52 100644
--- a/Bitkit/Services/PaykitUsdtPaymentService.swift
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -115,9 +115,10 @@ final class PaykitUsdtPaymentService {
     func send(_ quote: UsdtQuote, context: ContactPaymentContext, paymentTerms: PaykitRequestPricing.Payment?,
               wallet: UsdtWalletManager, authorize: @escaping @MainActor () async throws -> Void) async throws
     {
+        let submissionDeadline = try context.incomingPaymentRequest?.submissionDeadline(quoteId: paymentTerms?.quoteId)
         try setPaymentStarted(quoteId: quote.id, started: true)
         do {
-            try await wallet.send(quote) {
+            try await wallet.send(quote, submissionDeadline: submissionDeadline) {
                 do {
                     try await authorize()
                     try Task.checkCancellation()
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index 725fb4537..f6326583d 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -134,6 +134,13 @@ class AppViewModel: ObservableObject {
     @Published var paykitReviewedAmount: PaykitAmount?
     @Published var paykitPaymentTerms: PaykitRequestPricing.Payment?
 
+    var fixedLightningAmountSats: UInt64? {
+        guard !paykitUsesUsdt, selectedWalletToPayFrom == .lightning,
+              let amount = scannedLightningInvoice?.amountSatoshis, amount > 0
+        else { return nil }
+        return amount
+    }
+
     // LNURL
     @Published var lnurlPayData: LnurlPayData?
     @Published var lnurlWithdrawData: LnurlWithdrawData?
diff --git a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
index 612707e3f..f33a1e38c 100644
--- a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
+++ b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
@@ -66,7 +66,6 @@ struct PaymentRequestCard: View {
     var status: String?
     var isHighlighted = true
     var isActionDisabled = false
-    var showsAmountSymbol = true
     var paymentDirection: PaykitPaymentRequest.Direction?
     var amountStatus: String?
     var onOpen: (() -> Void)?
diff --git a/Bitkit/Views/Subscriptions/SubscriptionsView.swift b/Bitkit/Views/Subscriptions/SubscriptionsView.swift
index cc275303d..bf02b70b4 100644
--- a/Bitkit/Views/Subscriptions/SubscriptionsView.swift
+++ b/Bitkit/Views/Subscriptions/SubscriptionsView.swift
@@ -502,7 +502,6 @@ struct SubscriptionDetailView: View {
                         titleOverride: subscription.note ?? t("subscriptions__subscription"),
                         subtitleOverride: payment.createdAt.map(Self.dateFormatter.string),
                         isHighlighted: false,
-                        showsAmountSymbol: false,
                         paymentDirection: payment.direction
                     )
                 }
diff --git a/Bitkit/Views/Wallets/Receive/ReceiveQr.swift b/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
index 3ea64838f..9beeeaa04 100644
--- a/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
+++ b/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
@@ -15,6 +15,7 @@ struct ReceiveQr: View {
     let hardwareWalletId: String?
 
     @State private var needsInvoiceRefresh: Bool
+    @State private var invoiceRefreshFailed = false
     @State private var selectedTab: ReceiveTab
     @State private var showDetails = false
     @State private var hasAppliedDefaultTab = false
@@ -324,7 +325,19 @@ struct ReceiveQr: View {
     func tabContent(for tab: ReceiveTab) -> some View {
         VStack(spacing: 0) {
             if needsInvoiceRefresh && tab != .hardware {
-                ProgressView()
+                if invoiceRefreshFailed {
+                    VStack(spacing: 16) {
+                        BodyMText(t("wallet__refresh_error_msg"), textColor: .textSecondary)
+                            .multilineTextAlignment(.center)
+                        CustomButton(title: t("common__try_again"), variant: .tertiary) {
+                            await refreshBip21()
+                        }
+                        .accessibilityIdentifier("ReceiveInvoiceRetry")
+                    }
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else {
+                    ProgressView()
+                }
             } else if tab == .spending && !wallet.canCreateReceiveLightningInvoice && cjitInvoice == nil {
                 cjitOnboarding
             } else if showDetails {
@@ -547,6 +560,7 @@ struct ReceiveQr: View {
 
     func refreshBip21() async {
         guard wallet.nodeLifecycleState == .running else { return }
+        invoiceRefreshFailed = false
         do {
             if needsInvoiceRefresh, let paymentId = await wallet.paymentId(), !paymentId.isEmpty {
                 try? await CoreService.shared.activity.resetPreActivityMetadataTags(paymentId: paymentId)
@@ -554,6 +568,7 @@ struct ReceiveQr: View {
             try await wallet.refreshBip21(forceRefreshBolt11: needsInvoiceRefresh)
             needsInvoiceRefresh = false
         } catch {
+            invoiceRefreshFailed = true
             app.toast(error)
         }
     }
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index 73c57e8e8..983dd512e 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -30,6 +30,10 @@ struct SendAmountView: View {
         amountViewModel.amountSats
     }
 
+    private var canEditAmount: Bool {
+        app.contactPaymentContext?.incomingPaymentRequest == nil && app.fixedLightningAmountSats == nil
+    }
+
     private var fundingSources: [SendFundingSource] {
         if let request = app.contactPaymentContext?.incomingPaymentRequest,
            PaykitUsdtPaymentService.shared.hasBinding(for: request.id) { return [.usdt] }
@@ -161,7 +165,7 @@ struct SendAmountView: View {
                             testIdentifier: "AvailableAmount"
                         )
                         .onTapGesture {
-                            guard app.contactPaymentContext?.incomingPaymentRequest == nil else { return }
+                            guard canEditAmount else { return }
                             amountViewModel.updateFromSats(availableAmount, currency: currency)
 
                             if app.selectedWalletToPayFrom == .lightning {
@@ -207,7 +211,7 @@ struct SendAmountView: View {
                 NumberPad(
                     type: app.paykitUsesUsdt ? .decimal : amountViewModel.getNumberPadType(currency: currency),
                     errorKey: amountViewModel.errorKey,
-                    isDisabled: app.contactPaymentContext?.incomingPaymentRequest != nil
+                    isDisabled: !canEditAmount
                 ) { key in
                     if app.paykitUsesUsdt { usdtAmount = NumberPadInputHandler.handleInput(
                         key: key,
@@ -252,6 +256,7 @@ struct SendAmountView: View {
             }
 
             updateRequestAmount()
+            updateFixedLightningAmount()
 
             // Calculate max sendable amount for onchain transactions
             if hwSend.isActive || app.selectedWalletToPayFrom == .onchain {
@@ -413,7 +418,8 @@ struct SendAmountView: View {
 
     private func selectFundingSource(_ source: SendFundingSource) {
         let target: PaykitAsset = source == .usdt ? .usdt : .btc
-        if app.contactPaymentContext?.incomingPaymentRequest != nil || app.paykitUsesUsdt != (source == .usdt) {
+        let selectsFixedLightning = source == .spending && (app.scannedLightningInvoice?.amountSatoshis ?? 0) > 0
+        if app.contactPaymentContext?.incomingPaymentRequest != nil || (!selectsFixedLightning && app.paykitUsesUsdt != (source == .usdt)) {
             do {
                 let value = app.contactPaymentContext?.incomingPaymentRequest?.amount ??
                     (app.paykitUsesUsdt ? (try? PaykitAmount(asset: .usdt, value: usdtAmount)) : PaykitAmount(asset: .btc, atomic: amountSats))
@@ -428,9 +434,9 @@ struct SendAmountView: View {
                     if target == .usdt { usdtAmount = converted.value }
                     else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
                 }
-                conversionError = nil
             } catch { conversionError = t("wallet__payment_request_rate_unavailable"); return }
         }
+        conversionError = nil
         app.paykitUsesUsdt = source == .usdt
         switch source {
         case .usdt:
@@ -454,6 +460,13 @@ struct SendAmountView: View {
             )
             app.selectedWalletToPayFrom = .onchain
         }
+        updateFixedLightningAmount()
+    }
+
+    private func updateFixedLightningAmount() {
+        guard app.contactPaymentContext?.incomingPaymentRequest == nil, let amount = app.fixedLightningAmountSats else { return }
+        amountViewModel.updateFromSats(amount, currency: currency)
+        wallet.sendAmountSats = amount
     }
 
     private func updateRequestAmount() {
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index c8f74ae81..b21e8d5b0 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -164,9 +164,12 @@ struct SendConfirmationView: View {
         transactionFee > 0 ? transactionFee : Int(hwSend.previewFeeSats)
     }
 
-    /// BIP21 flow can land on confirm with `sendAmountSats` unset; set it from the scanned invoices.
     @MainActor
     private func ensureSendAmountFromScannedInvoicesIfNeeded() {
+        if app.contactPaymentContext?.incomingPaymentRequest == nil, let amount = app.fixedLightningAmountSats {
+            wallet.sendAmountSats = amount
+            return
+        }
         guard wallet.sendAmountSats == nil || wallet.sendAmountSats == 0 else { return }
         if let invoice = app.scannedOnchainInvoice, invoice.amountSatoshis > 0 {
             wallet.sendAmountSats = invoice.amountSatoshis
@@ -396,6 +399,7 @@ struct SendConfirmationView: View {
         }
         .onChange(of: app.selectedWalletToPayFrom) {
             guard preparingRequest == nil, !returnToAmountReviewIfNeeded() else { return }
+            ensureSendAmountFromScannedInvoicesIfNeeded()
             walletSwitchContext = sendContext
         }
         .onChange(of: sendContext) { _, context in
@@ -877,18 +881,21 @@ struct SendConfirmationView: View {
     }
 
     static func sendLightningPayment<Result>(
+        invoiceAmountSats: UInt64,
+        reviewedAmountSats: UInt64,
         request: PaykitPaymentRequest?,
         authorize: (PaykitPaymentRequest) async throws -> Void,
         onAuthorizationFailure: (Error) async -> Void,
         send: () async throws -> Result
     ) async throws -> Result {
-        if let request {
-            do {
-                try await authorize(request)
-            } catch {
-                await onAuthorizationFailure(error)
-                throw error
+        do {
+            guard invoiceAmountSats == 0 || invoiceAmountSats == reviewedAmountSats else {
+                throw PaykitPaymentRequestError.amountMismatch
             }
+            if let request { try await authorize(request) }
+        } catch {
+            await onAuthorizationFailure(error)
+            throw error
         }
         return try await send()
     }
@@ -1111,6 +1118,8 @@ struct SendConfirmationView: View {
                 // native millisatoshi precision instead of our truncated satoshi value.
                 let paymentSats: UInt64? = invoice.amountSatoshis == 0 ? amount : nil
                 try await Self.sendLightningPayment(
+                    invoiceAmountSats: invoice.amountSatoshis,
+                    reviewedAmountSats: amount,
                     request: incomingPaymentRequest,
                     authorize: { try await paykitPaymentRequestManager.ensurePaymentAllowed($0) },
                     onAuthorizationFailure: { _ in
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index f9f21e879..b235fb1ee 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -85,8 +85,11 @@ struct UsdtDepositHistoryView: View {
                     }
                 }
             } message: {
-                Text((selected?.deposit.network.uppercased() ?? "") + "\n" + (selected?.deposit.id ?? "") + "\n" + amount(selected?.deposit.amount) +
-                    "\n" + refundAddress + "\n\n" + t("usdt__deposit_refund_note"))
+                let network: String = selected?.deposit.network.uppercased() ?? ""
+                let depositId: String = selected?.deposit.id ?? ""
+                let refundAmount: String = amount(selected?.deposit.amount)
+                let note: String = t("usdt__deposit_refund_note")
+                Text("\(network)\n\(depositId)\n\(refundAmount)\n\(refundAddress)\n\n\(note)")
             }
         }
         .task { await loadPage(0) }
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index e66d03c8e..0479918eb 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -13,6 +13,7 @@ struct UsdtReceiveView: View {
     @State private var page = Page.address
     @State private var historyBlocking = false
     @State private var amount = ""
+    @State private var draftAmount = ""
     @State private var deposit: UsdtDepositAddress?
     @State private var busy = false
     @State private var error: String?
@@ -42,6 +43,7 @@ struct UsdtReceiveView: View {
         VStack(spacing: 0) {
             SheetHeader(title: title, showBackButton: page != .address, action: page == .address ? contactAction : nil,
                         onBack: {
+                            if page == .amount { draftAmount = amount; error = nil }
                             if page == .fees { page = .amount }
                             else if page == .amount, network != nil, deposit == nil { page = .networks }
                             else { if deposit == nil { network = nil }; page = .address }
@@ -56,7 +58,7 @@ struct UsdtReceiveView: View {
                     uri: deposit?.uri ?? receiveUri,
                     network: networkName,
                     error: error ?? usdt.errorMessage,
-                    onEdit: { page = .amount },
+                    onEdit: { draftAmount = amount; page = .amount },
                     onNetwork: { page = .networks }
                 )
             case .networks:
@@ -106,7 +108,7 @@ struct UsdtReceiveView: View {
 
     private func networkRow(_ item: UsdtDepositNetwork?) -> some View {
         Button {
-            if network != item { deposit = nil; amount = ""; error = nil }
+            if network != item { deposit = nil; amount = ""; draftAmount = ""; error = nil }
             network = item
             page = item == nil || deposit != nil ? .address : .amount
         } label: {
@@ -124,19 +126,20 @@ struct UsdtReceiveView: View {
     }
 
     private var amountEntry: some View {
-        UsdtReceiveAmountView(amount: $amount, busy: busy, error: error, allowEmpty: network == nil) {
-            guard let network else { page = .address; return }
+        UsdtReceiveAmountView(amount: $draftAmount, busy: busy, error: error, allowEmpty: network == nil) {
+            guard let network else { amount = draftAmount; page = .address; return }
             busy = true
             error = nil
             defer { busy = false }
             do {
-                deposit = try await usdt.prepareDeposit(network: network, amount: amount)
+                deposit = try await usdt.prepareDeposit(network: network, amount: draftAmount)
+                amount = draftAmount
                 page = .fees
             } catch {
-                self.error = usdtDepositAmountMessage(error, amount: amount)
+                self.error = usdtDepositAmountMessage(error, amount: draftAmount)
             }
         }
-        .onChange(of: amount) { error = nil }
+        .onChange(of: draftAmount) { error = nil }
     }
 
     private func feeEstimate(_ deposit: UsdtDepositAddress) -> some View {
@@ -191,6 +194,7 @@ struct UsdtReceiveAddressContent: View {
                         editRoute: nil,
                         accentColor: .usdtAccent
                     )
+                    .accessibilityElement(children: .contain)
                     .accessibilityIdentifier("UsdtReceiveAddress")
                 } else {
                     QrArea(uri: uri, imageAsset: "tether-circle", accentColor: .usdtAccent,
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index 912922b12..c465dd0e7 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -30,6 +30,7 @@ struct UsdtWalletScreen: View {
                         displayAmount: usdt.balance.map { usdtOverviewAmount($0) }, hideBalance: settings.hideBalance
                     )
                     .balanceVisibilityToggle()
+                    .accessibilityElement(children: .contain)
                     .accessibilityIdentifier("UsdtBalance")
                     if let error = usdt.errorMessage { BodySText(error, textColor: .brandAccent) }
                     activityList
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index 77c9d02d5..3494c402a 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -1369,6 +1369,8 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         var authorizationFailureCalls = 0
         do {
             try await SendConfirmationView.sendLightningPayment(
+                invoiceAmountSats: 1000,
+                reviewedAmountSats: 1000,
                 request: request,
                 authorize: { try await manager.ensurePaymentAllowed($0) },
                 onAuthorizationFailure: { _ in authorizationFailureCalls += 1 }
@@ -1669,6 +1671,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                     switch route {
                     case "lightning":
                         try await SendConfirmationView.sendLightningPayment(
+                            invoiceAmountSats: 1000, reviewedAmountSats: 1000,
                             request: request, authorize: authorize, onAuthorizationFailure: onFailure
                         ) { sent = true }
                     case "lnurl":
diff --git a/BitkitTests/PaymentNavigationHelperTests.swift b/BitkitTests/PaymentNavigationHelperTests.swift
index 1f0ea24ac..0dfe59635 100644
--- a/BitkitTests/PaymentNavigationHelperTests.swift
+++ b/BitkitTests/PaymentNavigationHelperTests.swift
@@ -190,6 +190,25 @@ final class PaymentNavigationHelperTests: XCTestCase {
         XCTAssertEqual(contactPaymentRoute(for: app), .confirm)
     }
 
+    func testContactWithUsdtLocksOnlyFixedLightningFunding() {
+        let app = appWithInvoice(paymentHash: "fixed", amountSatoshis: 10000)
+        app.contactPaymentContext = ContactPaymentContext(publicKey: "pubkycontact", endpoints: [
+            .init(methodId: .usdtArbitrum, value: "0x1111111111111111111111111111111111111111", min: nil, max: nil, rawPayload: ""),
+        ])
+        XCTAssertEqual(contactPaymentRoute(for: app), .amount)
+        app.selectedWalletToPayFrom = .lightning
+        XCTAssertEqual(app.fixedLightningAmountSats, 10000)
+        app.paykitUsesUsdt = true
+        XCTAssertNil(app.fixedLightningAmountSats)
+        app.paykitUsesUsdt = false
+        app.selectedWalletToPayFrom = .onchain
+        XCTAssertNil(app.fixedLightningAmountSats)
+        app.selectedWalletToPayFrom = .lightning
+        XCTAssertEqual(app.fixedLightningAmountSats, 10000)
+        app.scannedLightningInvoice = appWithInvoice(paymentHash: "amountless", amountSatoshis: 0).scannedLightningInvoice
+        XCTAssertNil(app.fixedLightningAmountSats)
+    }
+
     func testReserveRaceFallsBackToConfirm() {
         XCTAssertEqual(
             PaymentNavigationHelper.confirmRouteAfterQuickPayCap(app: appWithEligibleInvoice),
diff --git a/BitkitTests/SendConfirmationLifecycleTests.swift b/BitkitTests/SendConfirmationLifecycleTests.swift
index 1bac4e761..ced82fb11 100644
--- a/BitkitTests/SendConfirmationLifecycleTests.swift
+++ b/BitkitTests/SendConfirmationLifecycleTests.swift
@@ -7,6 +7,27 @@ import XCTest
 
 @MainActor
 final class SendConfirmationLifecycleTests: XCTestCase {
+    func testFixedLightningReviewUsesInvoiceAmountAfterEditingAnotherFundingSource() async throws {
+        snapshotAppDefaultsDomain()
+        snapshotAppGroupDefaults("home_screen_display_currency_code_v1", "home_screen_display_currency_symbol_v1")
+        let app = AppViewModel()
+        let wallet = WalletViewModel()
+        let sheets = SheetViewModel()
+        sheets.activeSheetConfiguration = SheetConfiguration(id: .send, data: nil)
+        app.scannedLightningInvoice = LightningInvoice(
+            bolt11: "test-invoice", paymentHash: Data(), amountSatoshis: 10000,
+            timestampSeconds: 0, expirySeconds: 0, isExpired: false,
+            description: nil, networkType: .regtest, payeeNodeId: nil
+        )
+        app.selectedWalletToPayFrom = .lightning
+        wallet.sendAmountSats = 1000
+        let window = host(app: app, wallet: wallet, sheets: sheets, path: .constant([]))
+        defer { close(window) }
+        try await Task.sleep(for: .milliseconds(100))
+
+        XCTAssertEqual(wallet.sendAmountSats, 10000)
+    }
+
     func testSuspendedPreparationCannotChangeClosedOrReplacementSend() async throws {
         snapshotAppDefaultsDomain()
         snapshotAppGroupDefaults("home_screen_display_currency_code_v1", "home_screen_display_currency_symbol_v1")
diff --git a/BitkitTests/SendConfirmationViewTests.swift b/BitkitTests/SendConfirmationViewTests.swift
index 54876bdab..9304b7606 100644
--- a/BitkitTests/SendConfirmationViewTests.swift
+++ b/BitkitTests/SendConfirmationViewTests.swift
@@ -3,6 +3,26 @@ import LDKNode
 import XCTest
 
 final class SendConfirmationViewTests: XCTestCase {
+    func testLightningPaymentRejectsAmountsThatDifferFromTheFixedInvoice() async throws {
+        for (invoiceAmount, reviewedAmount, expectedSend) in [(10000, 1000, false), (10000, 10000, true), (0, 1000, true)] {
+            var sent = false
+            do {
+                try await SendConfirmationView.sendLightningPayment(
+                    invoiceAmountSats: UInt64(invoiceAmount),
+                    reviewedAmountSats: UInt64(reviewedAmount),
+                    request: nil,
+                    authorize: { _ in },
+                    onAuthorizationFailure: { _ in }
+                ) { sent = true }
+                XCTAssertTrue(expectedSend)
+            } catch {
+                XCTAssertFalse(expectedSend)
+                XCTAssertEqual(error as? PaykitPaymentRequestError, .amountMismatch)
+            }
+            XCTAssertEqual(sent, expectedSend)
+        }
+    }
+
     func testRetainedHardwareConfirmationLocksSignedFeeRateDespitePresetEdits() {
         let signed = HwFundingSignedTx(serializedTx: "original", miningFeeSats: 181, feeRate: 2.25, totalSpent: 42181)
         for preset: UInt32? in [1, 17, 99, nil] {
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 2e0fc2e09..1e3bc5c8a 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -4,6 +4,30 @@ import XCTest
 
 @MainActor
 final class UsdtWalletManagerTests: XCTestCase {
+    func testNativeSubmissionRejectsAnExpiredPreciseDeadlineWithoutCreatingATransfer() async throws {
+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: directory) }
+        let wallet = try UsdtWallet(
+            address: "0x1111111111111111111111111111111111111111",
+            storagePath: directory.appendingPathComponent("usdt.sqlite").path,
+            rpcUrl: "http://127.0.0.1:1", bundlerUrl: "http://127.0.0.1:1", bridgeUrl: nil,
+            backup: UnavailableUsdtBackup()
+        )
+        let deadline = try XCTUnwrap(PaykitPreciseInstant(timestamp: "2020-01-01T00:00:00.123456789Z"))
+        do {
+            _ = try await wallet.sendWithDeadline(
+                quoteId: "expired-request", mnemonic: "test test test test test test test test test test test junk",
+                passphrase: nil, submissionDeadline: deadline.timestamp
+            )
+            XCTFail("An expired payment must not be submitted")
+        } catch {
+            guard let error = error as? UsdtError, case .SubmissionDeadlineExpired = error else { throw error }
+            XCTAssertEqual(UsdtWalletManager.message(for: error), t("wallet__payment_request_expired"))
+        }
+        XCTAssertTrue(try wallet.history().isEmpty)
+    }
+
     func testFeeCollectionFailureIsActionableWithoutMisclassifyingOtherRejections() {
         XCTAssertEqual(UsdtWalletManager.message(for: UsdtError.TransactionRejected(reason: "Paymaster fee collection failed")),
                        t("usdt__error_fee_collection"))
@@ -94,3 +118,9 @@ final class UsdtWalletManagerTests: XCTestCase {
         } catch is CancellationError {}
     }
 }
+
+private final class UnavailableUsdtBackup: UsdtBackup {
+    func persist(snapshot _: String) async throws {
+        throw UsdtError.BackupUnavailable
+    }
+}
diff --git a/BitkitUITests/UsdtWalletUITests.swift b/BitkitUITests/UsdtWalletUITests.swift
index 90a386e2e..a7b98e900 100644
--- a/BitkitUITests/UsdtWalletUITests.swift
+++ b/BitkitUITests/UsdtWalletUITests.swift
@@ -26,17 +26,19 @@ final class UsdtWalletUITests: XCTestCase {
         app.buttons["UsdtWallet"].tap()
         XCTAssertTrue(app.buttons["UsdtReceive"].waitForExistence(timeout: 5))
         app.buttons["UsdtReceive"].tap()
-        let addressElement = app.staticTexts["UsdtReceiveAddress"]
-        XCTAssertTrue(addressElement.waitForExistence(timeout: 30))
+        XCTAssertTrue(app.buttons["UsdtReceiveDetails"].waitForExistence(timeout: 30))
         capture(app, "USDT receive")
         app.buttons["UsdtReceiveDetails"].tap()
+        let addressElement = app.otherElements["UsdtReceiveAddress"].staticTexts["ReceiveOnchainAddress"]
+        XCTAssertTrue(addressElement.waitForExistence(timeout: 30))
         capture(app, "USDT receive details")
         let address = addressElement.label
         _ = try await forkCall("test_fundWallet", [address])
-        let back = app.buttons.matching(identifier: "NavigationBack")
-        try XCTUnwrap(back.allElementsBoundByIndex.first(where: \.isHittable)).tap()
-        let fundedBalance = app.staticTexts.matching(identifier: "UsdtBalance")
-            .matching(NSPredicate(format: "label CONTAINS %@", "1000")).firstMatch
+        let receiveHeader = app.staticTexts["Receive Dollars"].coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5))
+        receiveHeader.press(forDuration: 0.1, thenDragTo: app.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.95)))
+        XCTAssertTrue(app.buttons["UsdtReceiveDetails"].waitForNonExistence(timeout: 5))
+        let fundedBalance = app.otherElements["UsdtBalance"].staticTexts
+            .matching(NSPredicate(format: "label CONTAINS %@", "1,000")).firstMatch
         XCTAssertTrue(fundedBalance.waitForExistence(timeout: 60))
         app.buttons["UsdtSend"].tap()
         XCTAssertTrue(app.buttons["UsdtManual"].waitForExistence(timeout: 5))
@@ -127,11 +129,35 @@ final class UsdtWalletUITests: XCTestCase {
         app.buttons["UsdtWallet"].tap()
         XCTAssertTrue(app.buttons["UsdtReceive"].waitForExistence(timeout: 5))
         app.buttons["UsdtReceive"].tap()
-        XCTAssertTrue(app.staticTexts["UsdtReceiveAddress"].waitForExistence(timeout: 30), app.debugDescription)
-        XCTAssertTrue(app.staticTexts["UsdtReceiveAddress"].label.hasPrefix("0x"))
-        XCTAssertTrue(app.staticTexts.containing(NSPredicate(format: "label CONTAINS %@", "Arbitrum One only")).firstMatch.exists)
-        let back = app.buttons.matching(identifier: "NavigationBack")
-        try XCTUnwrap(back.allElementsBoundByIndex.first(where: \.isHittable)).tap()
+        XCTAssertTrue(app.buttons["UsdtReceiveDetails"].waitForExistence(timeout: 30))
+        let qr = app.descendants(matching: .any).matching(identifier: "QRCode").firstMatch
+        XCTAssertTrue(qr.waitForExistence(timeout: 5))
+        let amountlessUri = qr.label
+        XCTAssertFalse(amountlessUri.contains("uint256="))
+        app.buttons["SpecifyInvoiceButton"].tap()
+        app.buttons["N5"].tap()
+        try XCTUnwrap(app.buttons.matching(identifier: "NavigationBack").allElementsBoundByIndex.first(where: \.isHittable)).tap()
+        XCTAssertTrue(qr.waitForExistence(timeout: 5))
+        XCTAssertEqual(qr.label, amountlessUri)
+        app.buttons["SpecifyInvoiceButton"].tap()
+        app.buttons["N3"].tap()
+        app.buttons["UsdtDepositCreate"].tap()
+        XCTAssertTrue(qr.waitForExistence(timeout: 5))
+        let committedUri = qr.label
+        XCTAssertTrue(committedUri.contains("uint256=3000000"))
+        app.buttons["SpecifyInvoiceButton"].tap()
+        app.buttons["N5"].tap()
+        try XCTUnwrap(app.buttons.matching(identifier: "NavigationBack").allElementsBoundByIndex.first(where: \.isHittable)).tap()
+        XCTAssertTrue(qr.waitForExistence(timeout: 5))
+        XCTAssertEqual(qr.label, committedUri)
+        app.buttons["UsdtReceiveDetails"].tap()
+        let address = app.otherElements["UsdtReceiveAddress"].staticTexts["ReceiveOnchainAddress"]
+        XCTAssertTrue(address.waitForExistence(timeout: 30), app.debugDescription)
+        XCTAssertTrue(address.label.hasPrefix("0x"))
+        XCTAssertTrue(app.buttons["UsdtReceiveNetwork"].label.contains("Arbitrum One"))
+        let receiveHeader = app.staticTexts["Receive Dollars"].coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5))
+        receiveHeader.press(forDuration: 0.1, thenDragTo: app.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.95)))
+        XCTAssertTrue(app.buttons["UsdtReceiveDetails"].waitForNonExistence(timeout: 5))
         app.buttons["UsdtSend"].tap()
         XCTAssertTrue(app.buttons["UsdtManual"].waitForExistence(timeout: 5))
         app.buttons["UsdtManual"].tap()
diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index 28dcb96e4..3ebe5e70a 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -56,6 +56,17 @@ Use disposable wallets and a controlled RPC, bundler and encrypted VSS test envi
 - [ ] Mine the test operation and refresh. Verify a single activity entry, the original request attribution, and successful proof delivery.
 - [ ] Repeat restore with an unavailable local storage dependency. Verify restore remains incomplete and no replacement wallet backup is uploaded.
 
+## Paykit quoted reviews and history
+
+Requires two linked owned wallets and funded payment rails: Arbitrum One USDT or the local Arbitrum fork fixture for USDT review, and usable Bitcoin balances for Bitcoin review. A Bitcoin regtest balance does not fund USDT. The differing-rate checks require a controlled request issuer and BTC/USD rate source; proof-status checks require controlled receipt evidence. No payment is submitted by the review steps.
+
+- [ ] Open an unpaid USD request accepting only USDT. Continue from Amount to review. Verify Payment Request, the requester avatar, From and For summary, the exact dollar amount and additional fee. Open details and verify Contact, recipient address and invoice note. Close without swiping to pay.
+- [ ] Open a quoted request for 1000 USD requiring 1 BTC while Bitkit's controlled BTC/USD rate is 2000. Verify details label 1000 USD as Requested amount, while payment review shows 1 BTC and Bitkit's approximately 2000 USD valuation. Close without paying.
+- [ ] Open a BTC request with different quoted prices for Bitcoin and Lightning. Switch Savings and Spending and verify each method's payable BTC amount, Bitkit's own fiat valuation and explicit payment approval. Close without paying.
+- [ ] Open a linked USDT-only contact with a published private payment list, enter 0.01 USDT and continue to review. Verify the owned recipient address and fee, then close without paying.
+- [ ] Using an existing request paid in USDT, open history on payer and requester. Verify the sent or received arrow, its background and the date/time icons use USDT teal even when the request denomination is BTC or USD.
+- [ ] In request history, verify an unverified delivered proof says Proof submitted, not Paid. A received USDT request stays Pending until its matching proof is verified, then shows Payment verified, Received underpaid or Received after expiry with the actual USDT amount and no conflicting proof-delivery label.
+
 ## Paykit settlement, later installments and evidence
 
 Requires funded Arbitrum accounts, controlled billing time, and controlled receipt evidence, none of which is listed in Capabilities.
@@ -79,4 +90,5 @@ Reference: [USDT designs](https://www.figma.com/design/ltqvnKiejWj0JQiqtDf2JJ/Bi
 - [ ] Enter an accepted dollar amount and verify its BTC equivalent. Continue and verify Estimated Fees shows the expected deduction and received amount, then continues to the QR for that network.
 - [ ] Open address details, verify Copy and QR target the same address, and return to the QR.
 - [ ] Back out of an unprepared network and verify the displayed network always matches the QR. Return to Arbitrum and verify its original wallet address.
+- [ ] With a controlled Bitcoin invoice-refresh failure, open USDT Receive and select Savings or Spending. Verify the error offers Try Again instead of remaining on a spinner. Restore the backend and retry; verify the fresh Bitcoin QR appears without the previous amount or note.
 - [ ] With an authorized incoming transfer or an explicitly identified fixture, verify teal receive confetti, Details and OK; Details opens that transfer.
diff --git a/Docs/USDT.md b/Docs/USDT.md
index 97d3d5117..f45bd4044 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -1,6 +1,6 @@
 # USDT configuration
 
-Normal builds use published bitkit-core `0.8.0-rc2`, including its matching native libraries and generated bindings.
+Normal builds use published bitkit-core `0.8.0-rc3`, including its matching native libraries and generated bindings.
 
 USDT uses Arbitrum One regardless of the Bitcoin network setting. Builds use the credential-free Bitkit gateway by default:
 
@@ -25,6 +25,8 @@ History catch-up is deferred while the USDT send sheet is open. Balance and pend
 
 ## Paykit
 
+USDT request sends pass the earlier of the approved conversion quote expiry and request payment deadline to Core as the original precise timestamp. Core persists that cutoff with the signed operation and enforces it before the initial submission and recovery retries. Expired pending operations remain tracked for settlement evidence. Operations created before deadline support have no stored cutoff and retain their existing recovery behavior.
+
 Paykit uses a direct Arbitrum USDT0 endpoint (`usdt-arbitrum-address`). Existing public/private sharing settings control publication. The payload binds the address, chain 42161 and pinned token; bridge routes are excluded from Paykit choices.
 
 Bitkit creates BTC or USD requests and also reads USDT-denominated requests from other wallets. The accepted methods are immutable request terms. Every accepted cross-asset currency has an explicit requester-supplied rate; the denominating asset needs no conversion. USD/USDT is exactly 1:1. Bitcoin rates come from the existing BTC/USD source when issuing terms, not when verifying received funds. External requests without rates allow only same-asset payment. A listed method without its required rate cannot be used.
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index 724cb7fc5..abebc23c6 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -1,17 +1,13 @@
 <journey name="paykit quoted usdt requests">
-  <description>Two linked Bitkit wallets with Paykit and USDT enabled, sharing enabled by their owners, and a fresh BTC/USD rate. Ordinary request-creation checks can stop at Amount without funds. The controlled quote checks need a linked test peer and sufficient regtest balance to reach confirmation; do not authorize a payment. Funded settlement, later installments and controlled evidence checks are manual tests in Docs/USDT-QA.md.</description>
+  <description>Two linked Bitkit wallets with Paykit and USDT enabled, sharing enabled by their owners, and a fresh BTC/USD rate. These request-creation and amount-screen checks need no funds and stop before payment review. Funded Arbitrum review, paid history, controlled rates and proof verification are manual tests in Docs/USDT-QA.md; a Bitcoin regtest balance does not fund USDT.</description>
   <actions>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
-    <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Continue to USDT review. Verify Payment Request, the requester avatar, From and For summary, exact dollar amount and additional fee. Open details and verify Contact, recipient address and the invoice note. Close without swiping to pay.</action>
+    <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
     <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
-    <action>With a linked test payer, open a quoted request for 1000 USD requiring 1 BTC while Bitkit's BTC/USD rate is 2000. Verify the request details label 1000 USD as Requested amount. On payment review, verify 1 BTC and Bitkit's approximately 2000 USD valuation. Close without paying.</action>
-    <action>Open a BTC request with different quoted prices for Bitcoin and Lightning. Switch Savings and Spending and verify the payable BTC amount changes to the selected method's quoted amount. Verify the confirmation uses Bitkit's own fiat valuation and requires approval. Close without paying.</action>
     <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method; close before subscribing.</action>
     <action>Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing.</action>
-    <action>With an existing request paid in USDT, open its history entry on the payer and requester. Verify the sent or received arrow and its background use the USDT teal in the list and details, and the date and time icons in details use the same teal. The color follows the payment method even when the request is denominated in BTC or USD.</action>
-    <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01 and continue to review. Verify the owned recipient address and fee, then close without paying.</action>
-    <action>Open request history on both wallets. A delivered proof without independent receipt verification says Proof submitted, not Paid. A received USDT request shows Pending until its matching proof is verified, then Payment verified, Received underpaid or Received after expiry with the actual USDT amount, without a second conflicting proof-delivery label.</action>
+    <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01, then close without continuing to review.</action>
   </actions>
 </journey>
diff --git a/journeys/send/lightning-fee-review.xml b/journeys/send/lightning-fee-review.xml
index 44c92cf77..68b62560b 100644
--- a/journeys/send/lightning-fee-review.xml
+++ b/journeys/send/lightning-fee-review.xml
@@ -15,5 +15,9 @@
     <action>On the sending wallet, open the received payment request and tap Pay if it has not opened automatically</action>
     <action>Open Show Details and verify confirmation shows 1,000 sats, Spending, the receiving contact and a numeric estimated fee</action>
     <action>Dismiss the send review without swiping to pay and verify the request remains unpaid</action>
+    <action>On the receiving wallet, enable USDT sharing and publish a fresh 10,000-sat fixed Lightning invoice for the sending contact</action>
+    <action>On the sending wallet, pay that contact and select Spending. Verify the amount is 10,000 sats and keypad or Max cannot change it</action>
+    <action>Switch to Savings or USDT and enter a different amount, then switch back to Spending. Verify the invoice amount returns to 10,000 sats</action>
+    <action>Continue to review and verify the amount is 10,000 sats, then cancel without paying</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index 34e346ac0..dc99bb0e8 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -3,7 +3,7 @@
   <actions>
     <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount or review screen preserves recipient and 0.010001 USDT. Verify no payment occurs without approval.</action>
     <action>Cancel the send, then reopen the identical URI. Verify the amount or review screen opens again. Cancel and open a different owned recipient and amount, verifying only the new values appear.</action>
-    <action>While a USDT contact payment or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
+    <action>While a USDT contact amount screen or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
     <action>Cancel the send. Open the same link without uint256. Verify the amount screen opens with no amount and accepts a new amount.</action>
     <action>Cancel the send. From the main scanner, paste or import a QR containing the same amount-bearing URI. Verify it opens the USDT send flow with the same recipient and amount.</action>
     <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
diff --git a/journeys/usdt-receive-amount-and-units.xml b/journeys/usdt-receive-amount-and-units.xml
index d6fbad9fd..7b07bdafe 100644
--- a/journeys/usdt-receive-amount-and-units.xml
+++ b/journeys/usdt-receive-amount-and-units.xml
@@ -3,8 +3,10 @@
   <actions>
     <action>Open USDT from Home. Verify the USDT balance, teal Tether icon and existing activity rows.</action>
     <action>Open Receive. Verify Receive Dollars, the USDT tab and Network: Arbitrum One on the QR screen.</action>
+    <action>Tap Edit, enter 5 and tap Back. Verify the QR has no uint256 amount.</action>
     <action>Tap Edit. Enter 3.5. Verify the dollar amount and BTC equivalent are displayed, there is no input-unit toggle, the keypad follows the divider, and Continue stays at the bottom without overlap.</action>
     <action>Continue to the QR. Verify it requests the Arbitrum USDT token, the wallet address and uint256=3500000, never Bitcoin.</action>
+    <action>Tap Edit, enter a different amount and tap Back. Verify the QR still requests uint256=3500000.</action>
     <action>Open Share and verify the shared text includes Network: Arbitrum One and the exact payment URI. Cancel sharing. Open Show Details. Verify Network: Arbitrum One, the same Arbitrum address and teal Copy control. Verify Share includes the same network and payment URI, while Copy contains only the address. Open Network and verify Arbitrum is marked Default and all enabled bridge networks remain available. Return to the QR.</action>
     <action>Select Savings. Verify Receive Bitcoin and a Bitcoin QR. Select USDT and verify Receive Dollars and the Arbitrum USDT QR.</action>
     <action>Close Receive and return Home. Open a USDT activity row, then Show All. Verify USDT details and mixed activity remain reachable.</action>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index e4d918932..994176b9a 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -3,7 +3,7 @@
   <actions>
     <action>On Home, verify the Savings/Spending and USDT balance dividers align vertically, including any hardware wallet rows.</action>
     <action>Verify USDT balances and activity amounts show at most two decimals; a nonzero amount below one cent shows &lt;0.01. Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet, with its Tether coin illustration anchored at the upper right.</action>
-    <action>Open Receive. Verify the address starts with 0x and the network is Arbitrum One. Open details and verify Copy and the QR show the same address.</action>
+    <action>Open Receive. Verify the network is Arbitrum One. Open details, verify the address starts with 0x, and verify Copy and the QR show the same address.</action>
     <action>Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing.</action>
     <action>Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote.</action>
     <action>Set an amount and note in Bitcoin Receive, then close it. Open a fresh USDT Receive sheet and switch to Savings and Spending. Verify the new Bitcoin QR has no previous amount or note, and hardware-wallet receive remains available when paired.</action>

From b3c1f898ed4fdceb641d2fcf7defe56e04d2802e Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 11:20:02 -0500
Subject: [PATCH 21/62] fix: reuse USDT core within the wallet session

---
 Bitkit/Managers/UsdtWalletManager.swift       | 26 +++----
 .../PaykitPaymentRequestServiceTests.swift    |  2 +-
 BitkitTests/UsdtWalletManagerTests.swift      | 68 +++++++++++++++++--
 journeys/usdt-wallet-navigation.xml           |  2 +-
 4 files changed, 78 insertions(+), 20 deletions(-)

diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index 473a21122..6c54db5ea 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -1,6 +1,5 @@
 import BitkitCore
 import Combine
-import CryptoKit
 import Foundation
 import Observation
 
@@ -24,8 +23,8 @@ final class UsdtWalletManager {
     var errorMessage: String?
     var isSendPresented = false
     private var core: UsdtWallet?
-    private var credentialFingerprint: SHA256.Digest?
     private let storageDirectory: URL
+    private let loadCredentials: @MainActor () async throws -> (String, String?)
     private var wiping = false
     private var activeOperations = 0
     private var initialization: Task<UsdtWallet, Error>?
@@ -42,8 +41,17 @@ final class UsdtWalletManager {
         "Arbitrum One"
     }
 
-    init(storageDirectory: URL = Env.bitkitCoreStorage(walletIndex: 0)) {
+    init(
+        storageDirectory: URL = Env.bitkitCoreStorage(walletIndex: 0),
+        loadCredentials: @escaping @MainActor () async throws -> (String, String?) = {
+            try await ServiceQueue.background(.core, wrapErrors: false) {
+                guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
+                return try (mnemonic, Keychain.loadString(key: .bip39Passphrase(index: 0)))
+            }
+        }
+    ) {
         self.storageDirectory = storageDirectory
+        self.loadCredentials = loadCredentials
     }
 
     func refresh(includeHistory: Bool = false) async {
@@ -276,7 +284,6 @@ final class UsdtWalletManager {
             await withCheckedContinuation { idleWaiter = $0 }
         }
         core = nil
-        credentialFingerprint = nil
         balance = nil
         address = ""
         receiveUri = ""
@@ -310,6 +317,7 @@ final class UsdtWalletManager {
 
     private func wallet() async throws -> UsdtWallet {
         guard isConfigured, let bundlerUrl = Env.usdtBundlerUrl, let rpcUrl = Env.usdtRpcUrl else { throw UsdtError.NotConfigured }
+        if let core { return core }
         if let initialization { return try await initialization.value }
         let task = Task { try await initializeWallet(bundlerUrl: bundlerUrl, rpcUrl: rpcUrl) }
         initialization = task
@@ -318,14 +326,7 @@ final class UsdtWalletManager {
     }
 
     private func initializeWallet(bundlerUrl: String, rpcUrl: String) async throws -> UsdtWallet {
-        let credentials = try await ServiceQueue.background(.core, wrapErrors: false) {
-            guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
-            let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
-            return (mnemonic, passphrase)
-        }
-        let fingerprint = try SHA256.hash(data: JSONEncoder().encode([credentials.0, credentials.1 ?? ""]))
-        if credentialFingerprint != fingerprint { core = nil; balance = nil; transfers = []; historyComplete = false }
-        if let core { return core }
+        let credentials = try await loadCredentials()
         let address = try await ServiceQueue.background(.core, wrapErrors: false) {
             try usdtAddress(mnemonic: credentials.0, passphrase: credentials.1)
         }
@@ -340,7 +341,6 @@ final class UsdtWalletManager {
                 backup: UsdtVssBackup()
             )
         }
-        credentialFingerprint = fingerprint
         self.address = wallet.receiveAddress()
         receiveUri = wallet.receiveUri()
         core = wallet
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index 3494c402a..b098f8ea6 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -5786,7 +5786,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
     }
 
     func testPreparingSheetRequiresCurrentPresentationSessionAndContext() async throws {
-        let expiresAt = Date().addingTimeInterval(60)
+        let expiresAt = Date(timeIntervalSince1970: Date().timeIntervalSince1970.rounded(.up) + 60)
         let sdk = try PaymentRequestSdkMock(records: [paymentRequestRecord(
             expiresAt: PaykitSubscriptionTimestamp.string(from: expiresAt)
         )])
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 1e3bc5c8a..96ed3976c 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -89,6 +89,43 @@ final class UsdtWalletManagerTests: XCTestCase {
         )
     }
 
+    func testWalletReadsCredentialsOncePerSessionAndUsesFreshCredentialsAfterWipe() async throws {
+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: directory) }
+        let mnemonic = "test test test test test test test test test test test junk"
+        var credentialReads = 0
+        let manager = UsdtWalletManager(storageDirectory: directory, loadCredentials: {
+            credentialReads += 1
+            return (mnemonic, nil)
+        })
+        async let first = manager.paymentEndpoint()
+        async let second = manager.paymentEndpoint()
+        let (firstEndpoint, secondEndpoint) = try await (first, second)
+        XCTAssertEqual(firstEndpoint, secondEndpoint)
+        _ = try await manager.storedTransfer("missing")
+        let snapshot = try await manager.backupSnapshot()
+        let backup = try XCTUnwrap(snapshot)
+        try await manager.restoreBackup(backup)
+        XCTAssertEqual(credentialReads, 1)
+
+        try await manager.wipe()
+        do {
+            _ = try await manager.paymentEndpoint()
+            XCTFail("A wiped session must not read credentials or reopen its wallet")
+        } catch is CancellationError {}
+        XCTAssertEqual(credentialReads, 1)
+
+        let restored = UsdtWalletManager(storageDirectory: directory, loadCredentials: {
+            credentialReads += 1
+            return (mnemonic, "restored passphrase")
+        })
+        let restoredEndpoint = try await restored.paymentEndpoint()
+        XCTAssertNotEqual(restoredEndpoint, firstEndpoint)
+        XCTAssertEqual(credentialReads, 2)
+        try await restored.wipe()
+    }
+
     func testWipeRemovesUsdtPersistenceAndStopsSession() async throws {
         let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         defer { try? FileManager.default.removeItem(at: directory) }
@@ -101,14 +138,35 @@ final class UsdtWalletManagerTests: XCTestCase {
             try Data("private payment data".utf8).write(to: file)
         }
 
-        let manager = UsdtWalletManager(storageDirectory: directory)
-        async let first: Void = manager.wipe()
-        async let second: Void = manager.wipe()
-        _ = try await (first, second)
+        let initializationStarted = expectation(description: "credential read started")
+        var resumeInitialization: CheckedContinuation<Void, Never>?
+        let manager = UsdtWalletManager(storageDirectory: directory, loadCredentials: {
+            await withCheckedContinuation { continuation in
+                resumeInitialization = continuation
+                initializationStarted.fulfill()
+            }
+            return ("test test test test test test test test test test test junk", nil)
+        })
+        let endpoint = Task { try await manager.paymentEndpoint() }
+        await fulfillment(of: [initializationStarted], timeout: 2)
+        let wipeStarted = expectation(description: "wipe started during initialization")
+        let first = Task {
+            wipeStarted.fulfill()
+            try await manager.wipe()
+        }
+        await fulfillment(of: [wipeStarted], timeout: 2)
+        do {
+            _ = try await manager.paymentEndpoint()
+            XCTFail("A wipe must block further wallet operations")
+        } catch is CancellationError {}
+        let second = Task { try await manager.wipe() }
+        resumeInitialization?.resume()
+        _ = try await endpoint.value
+        _ = try await (first.value, second.value)
         for file in usdtFiles {
             XCTAssertFalse(FileManager.default.fileExists(atPath: file.path))
         }
-        XCTAssertTrue(FileManager.default.fileExists(atPath: unrelated.path))
+        XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: directory.path), [unrelated.lastPathComponent])
         XCTAssertTrue(manager.address.isEmpty)
         XCTAssertTrue(manager.transfers.isEmpty)
         XCTAssertNil(manager.balance)
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index 994176b9a..bb8d7c866 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -6,7 +6,7 @@
     <action>Open Receive. Verify the network is Arbitrum One. Open details, verify the address starts with 0x, and verify Copy and the QR show the same address.</action>
     <action>Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing.</action>
     <action>Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote.</action>
-    <action>Set an amount and note in Bitcoin Receive, then close it. Open a fresh USDT Receive sheet and switch to Savings and Spending. Verify the new Bitcoin QR has no previous amount or note, and hardware-wallet receive remains available when paired.</action>
+    <action>Set an amount and note in Bitcoin Receive, then close it. Open a fresh USDT Receive sheet and switch to Savings and Spending. Verify Savings shows a fresh Bitcoin QR with no previous amount or note. Spending shows a fresh Lightning QR when receive liquidity is available; an unfunded wallet shows the Spending receive setup instead. Verify hardware-wallet receive remains available when paired.</action>
     <action>Return Home and open Bitcoin Receive. Verify the Bitcoin address, network and amount controls remain separate from USDT.</action>
   </actions>
 </journey>

From 170bddb51c305ed13fa9d4908e8ff9f42c9ea78b Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 12:14:18 -0500
Subject: [PATCH 22/62] fix: show completed deposit refunds accurately

---
 .../Wallets/UsdtDepositHistoryView.swift      | 17 +++++++----
 BitkitTests/UsdtWalletManagerTests.swift      | 28 +++++++++++++++++--
 journeys/usdt-bridge-support.xml              |  2 ++
 3 files changed, 39 insertions(+), 8 deletions(-)

diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index b235fb1ee..c6400c515 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -131,7 +131,7 @@ struct UsdtDepositHistoryView: View {
             if let tx = detail.order?
                 .destinationTx { SendSectionView(t("wallet__activity_tx_id") + " · Arbitrum One") { BodySText(tx).textSelection(.enabled) } }
             if let tx = detail.order?.refundTx ?? detail.deposit.refundTx {
-                SendSectionView(t("usdt__deposit_refund")) { BodySText(tx).textSelection(.enabled) }
+                SendSectionView(t("usdt__refund_tx")) { BodySText(tx).textSelection(.enabled) }
             }
             if detail.deposit.asset != "USDT" || UsdtDepositNetwork.named(detail.deposit.network) == nil {
                 BodySText(t("usdt__deposit_wrong_asset"), textColor: .textSecondary)
@@ -183,6 +183,9 @@ struct UsdtDepositHistoryView: View {
                 approved = nil
                 message = nil
             }
+            if ["completed", "refunded"].contains(detail.order?.status ?? detail.deposit.status) {
+                message = nil
+            }
             selected = detail
         } catch is CancellationError {} catch { self.error = UsdtWalletManager.message(for: error) }
     }
@@ -235,7 +238,7 @@ private struct RefundApproval {
 
 extension UsdtDeposit {
     var statusText: String {
-        code == nil ? depositStatusText(status) : t("usdt__deposit_needs_attention")
+        depositStatusText(status, code: code)
     }
 }
 
@@ -246,16 +249,18 @@ extension UsdtDepositDetail {
     }
 
     var statusText: String {
-        statusCode == nil ? depositStatusText(order?.status ?? deposit.status) : t("usdt__deposit_needs_attention")
+        depositStatusText(order?.status ?? deposit.status, code: statusCode)
     }
 }
 
-private func depositStatusText(_ status: String) -> String {
+private func depositStatusText(_ status: String, code: String?) -> String {
     switch status {
     case "completed": t("usdt__confirmed")
     case "refunded": t("usdt__deposit_refunded")
-    case "refunding", "refund_requested": t("usdt__deposit_refunding")
-    case "pending", "processing": t("usdt__pending")
+    case "refunding", "refund_requested":
+        code == nil || code == "standing_refund_pending" ? t("usdt__deposit_refunding") : t("usdt__deposit_needs_attention")
+    case "pending", "processing":
+        code == nil ? t("usdt__pending") : t("usdt__deposit_needs_attention")
     default: t("usdt__deposit_needs_attention")
     }
 }
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 96ed3976c..31f70527f 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -71,6 +71,30 @@ final class UsdtWalletManagerTests: XCTestCase {
         }
     }
 
+    func testDepositStatusDistinguishesRefundProgressFromActionableErrors() {
+        let cases: [(String, String?, String)] = [
+            ("completed", "standing_route_unavailable", "usdt__confirmed"),
+            ("refunded", "xchain_amount_too_small", "usdt__deposit_refunded"),
+            ("refund_requested", "standing_refund_pending", "usdt__deposit_refunding"),
+            ("refunding", "standing_refund_pending", "usdt__deposit_refunding"),
+            ("refund_requested", "standing_tron_refund_requires_operator", "usdt__deposit_needs_attention"),
+            ("refunding", "refund_error", "usdt__deposit_needs_attention"),
+            ("pending", "standing_route_unavailable", "usdt__deposit_needs_attention"),
+            ("below_minimum", "xchain_amount_too_small", "usdt__deposit_needs_attention"),
+        ]
+        for (status, code, key) in cases {
+            let deposit = UsdtDeposit(id: "deposit", network: "bsc", asset: "USDT", amount: 100, sourceTx: "tx", status: status,
+                                      code: code, refundTx: nil)
+            let order = UsdtDepositOrder(status: status, amountIn: 100, amountOut: 90, destinationTx: nil, refundTx: nil, code: code)
+            XCTAssertEqual(deposit.statusText, t(key), status)
+            for linkedOrder in [nil, order] {
+                let detail = UsdtDepositDetail(deposit: deposit, order: linkedOrder)
+                XCTAssertEqual(detail.statusText, t(key), status)
+                XCTAssertEqual(detail.statusCode, code, status)
+            }
+        }
+    }
+
     private func transfer(_ id: String, incoming: Bool = true, status: UsdtTransferStatus = .confirmed, amount: UInt64 = 1_000_000) -> UsdtTransfer {
         UsdtTransfer(
             id: id,
@@ -102,7 +126,7 @@ final class UsdtWalletManagerTests: XCTestCase {
         async let first = manager.paymentEndpoint()
         async let second = manager.paymentEndpoint()
         let (firstEndpoint, secondEndpoint) = try await (first, second)
-        XCTAssertEqual(firstEndpoint, secondEndpoint)
+        XCTAssertEqual(firstEndpoint.value, secondEndpoint.value)
         _ = try await manager.storedTransfer("missing")
         let snapshot = try await manager.backupSnapshot()
         let backup = try XCTUnwrap(snapshot)
@@ -121,7 +145,7 @@ final class UsdtWalletManagerTests: XCTestCase {
             return (mnemonic, "restored passphrase")
         })
         let restoredEndpoint = try await restored.paymentEndpoint()
-        XCTAssertNotEqual(restoredEndpoint, firstEndpoint)
+        XCTAssertNotEqual(restoredEndpoint.value, firstEndpoint.value)
         XCTAssertEqual(credentialReads, 2)
         try await restored.wipe()
     }
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
index 71eff70a7..496360012 100644
--- a/journeys/usdt-bridge-support.xml
+++ b/journeys/usdt-bridge-support.xml
@@ -6,6 +6,8 @@
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting.</action>
     <action>Open USDT Receive, then Network and Deposit Activity, and open a deposit.</action>
+    <action>For a refunded deposit, verify both the history row and detail show Refunded, even when an earlier error code is retained. Verify the transaction is labeled Refund transaction in the detail. Verify no pending-refund notice remains after refreshing the completed refund.</action>
+    <action>For a refund in progress, verify Refunding is shown for the provider's pending acknowledgment. A refund requiring operator intervention must still show Needs attention.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard includes the deposit reference, source network and source transaction, plus the current status and any destination or refund transaction.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the receive sheet closes and the report form opens with the deposit details prefilled. Return without submitting or requesting a refund.</action>
   </actions>

From 37af927ea1739db49fd78a6f807a80ef0a2e4376 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 13:24:26 -0500
Subject: [PATCH 23/62] feat: align USDT send and activity designs

---
 Bitkit.xcodeproj/project.pbxproj              |   2 +-
 .../xcshareddata/swiftpm/Package.resolved     |   4 +-
 Bitkit/Components/NumberPadActionButton.swift |   2 +-
 Bitkit/Components/SwipeButton.swift           |  19 +-
 Bitkit/Managers/UsdtWalletManager.swift       |   7 +
 .../Localization/en.lproj/Localizable.strings |  15 +-
 .../Views/Wallets/Send/SendAmountView.swift   | 128 ++++++++--
 Bitkit/Views/Wallets/UsdtActivityDetail.swift | 191 +++++++++-----
 Bitkit/Views/Wallets/UsdtSendView.swift       | 238 +++++++++++-------
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |   2 +-
 BitkitTests/UsdtDisplayTests.swift            |   2 +-
 BitkitTests/UsdtSupportDetailsTests.swift     |   1 +
 BitkitTests/UsdtWalletManagerTests.swift      |   1 +
 Docs/USDT-QA.md                               |   2 +-
 Docs/USDT.md                                  |   2 +-
 journeys/usdt-payment-links-and-scans.xml     |   1 +
 journeys/usdt-send-review-and-details.xml     |  13 +
 17 files changed, 429 insertions(+), 201 deletions(-)
 create mode 100644 journeys/usdt-send-review-and-details.xml

diff --git a/Bitkit.xcodeproj/project.pbxproj b/Bitkit.xcodeproj/project.pbxproj
index 1c2328a65..cae18c31b 100644
--- a/Bitkit.xcodeproj/project.pbxproj
+++ b/Bitkit.xcodeproj/project.pbxproj
@@ -1234,7 +1234,7 @@
 			repositoryURL = "https://github.com/synonymdev/bitkit-core";
 			requirement = {
 				kind = exactVersion;
-				version = "0.8.0-rc3";
+				version = "0.8.0-rc4";
 			};
 		};
 		96E493A22C942FD1000E8BC2 /* XCRemoteSwiftPackageReference "swift-secp256k1" */ = {
diff --git a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
index 2e7726992..e4cf80709 100644
--- a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
+++ b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -6,8 +6,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/synonymdev/bitkit-core",
       "state" : {
-        "revision" : "98bf9c666a9342fb498cc99cd1676ed2195eb910",
-        "version" : "0.8.0-rc3"
+        "revision" : "1ebbd776d83acd1748cd9b32375d5aa420ebb4aa",
+        "version" : "0.8.0-rc4"
       }
     },
     {
diff --git a/Bitkit/Components/NumberPadActionButton.swift b/Bitkit/Components/NumberPadActionButton.swift
index 699ba3152..37ec87c3d 100644
--- a/Bitkit/Components/NumberPadActionButton.swift
+++ b/Bitkit/Components/NumberPadActionButton.swift
@@ -40,7 +40,7 @@ struct NumberPadActionButton: View {
             .background(background)
             .overlay(
                 RoundedRectangle(cornerRadius: 8)
-                    .stroke(variant == .secondary ? color : Color.clear, lineWidth: 2)
+                    .stroke(variant == .secondary ? color : Color.clear, lineWidth: 1)
             )
             .cornerRadius(8)
         }
diff --git a/Bitkit/Components/SwipeButton.swift b/Bitkit/Components/SwipeButton.swift
index 850055ea9..e1facc1f4 100644
--- a/Bitkit/Components/SwipeButton.swift
+++ b/Bitkit/Components/SwipeButton.swift
@@ -7,6 +7,7 @@ struct SwipeButton: View {
     var isDisabled = false
     /// Blocks interaction and shows the knob spinner while an operation is running.
     var isLoading = false
+    var isComplete = false
     /// Optional binding for swipe progress (0...1), e.g. to drive animations in the parent.
     var swipeProgress: Binding<CGFloat>?
     let onComplete: () async throws -> Void
@@ -15,11 +16,15 @@ struct SwipeButton: View {
     @State private var isSubmitting = false
 
     private var isBusy: Bool {
-        isDisabled || isLoading || isSubmitting
+        isDisabled || isLoading || isSubmitting || isComplete
     }
 
     private var showsSpinner: Bool {
-        isLoading || isSubmitting
+        !isComplete && (isLoading || isSubmitting)
+    }
+
+    private var contentOpacity: Double {
+        isDisabled && !isLoading && !isSubmitting && !isComplete ? 0.5 : 1
     }
 
     private let buttonHeight: CGFloat = 76
@@ -49,12 +54,12 @@ struct SwipeButton: View {
                             .frame(height: buttonHeight - innerPadding)
                             .padding(.horizontal, innerPadding / 2)
                     }
-                    .opacity(isDisabled ? 0.5 : 1)
+                    .opacity(contentOpacity)
 
                 // Track text
                 BodySSBText(title)
                     .frame(maxWidth: .infinity, alignment: .center)
-                    .opacity(Double(1.0 - textProgress) * (isDisabled ? 0.5 : 1))
+                    .opacity(Double(1.0 - textProgress) * contentOpacity)
 
                 // Knob
                 Circle()
@@ -69,20 +74,20 @@ struct SwipeButton: View {
                                     .resizable()
                                     .frame(width: 24, height: 24)
                                     .foregroundColor(.gray7)
-                                    .opacity(Double(1.0 - (offset / halfWidth)))
+                                    .opacity(isComplete ? 0 : Double(1.0 - (offset / halfWidth)))
 
                                 Image("check-mark")
                                     .resizable()
                                     .frame(width: 32, height: 32)
                                     .foregroundColor(.gray7)
-                                    .opacity(Double(max(0, (offset - halfWidth) / halfWidth)))
+                                    .opacity(isComplete ? 1 : Double(max(0, (offset - halfWidth) / halfWidth)))
                             }
                         }
                     )
                     .accessibilityIdentifier("GRAB")
                     .offset(x: clampedOffset)
                     .padding(.horizontal, innerPadding / 2)
-                    .opacity(isDisabled ? 0.5 : 1)
+                    .opacity(contentOpacity)
                     .gesture(
                         DragGesture()
                             .onChanged { value in
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index 6c54db5ea..4afc8922c 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -108,6 +108,13 @@ final class UsdtWalletManager {
         return try await wallet.quoteTransfer(recipient: recipient, amount: value, destination: destination)
     }
 
+    func quoteMaximum(recipient: String, destination: UsdtDestination) async throws -> UsdtQuote {
+        try beginOperation()
+        defer { finishOperation() }
+        let wallet = try await wallet()
+        return try await wallet.quoteMaxTransfer(recipient: recipient, destination: destination)
+    }
+
     func backupSnapshot() async throws -> String? {
         guard isConfigured else {
             if FileManager.default.fileExists(atPath: storageDirectory.path) {
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 12a2de851..174724ac3 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1809,7 +1809,7 @@
 // USDT
 "usdt__activity" = "Activity";
 "usdt__address" = "Recipient address";
-"usdt__amount" = "Amount (USDT)";
+"usdt__amount" = "Amount";
 "usdt__bridge_attention" = "Bridge needs attention";
 "usdt__bridging" = "Delivering to destination";
 "usdt__confirmed" = "Confirmed";
@@ -1834,7 +1834,7 @@
 "usdt__error_route" = "This network is currently unavailable.";
 "usdt__expected_amount" = "Expected amount";
 "usdt__failed" = "Failed";
-"usdt__fee_note" = "All fees are paid in USDT. The final network fee may be lower than this maximum.";
+"usdt__fee_note" = "All fees are paid in USDT. Final fee may be lower.";
 "usdt__history_sync" = "Older activity is still syncing. Your balance is up to date when the connection is available.";
 "usdt__maximum_fee" = "Maximum fee";
 "usdt__network_warning" = "Select the network used by the recipient. Sending to an address on the wrong network can lose funds.";
@@ -1943,3 +1943,14 @@
 "wallet__payment_request_requested_amount" = "Requested amount";
 
 "profile__auth_approval_services_separator" = " and ";
+
+"usdt__network" = "Network";
+"usdt__sender_network" = "Sender network";
+"usdt__sent_title" = "Sent USDT";
+"usdt__pay_from" = "Pay from";
+
+"usdt__to_network" = "To network {network}";
+
+"usdt__from_address" = "From address";
+
+"usdt__to_address" = "To address";
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index 983dd512e..3077db4d0 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -25,6 +25,7 @@ struct SendAmountView: View {
     @State private var isContinuing = false
     @State private var usdtAmount = ""
     @State private var conversionError: String?
+    @State private var showingFundingSources = false
 
     var amountSats: UInt64 {
         amountViewModel.amountSats
@@ -67,25 +68,11 @@ struct SendAmountView: View {
     }
 
     private var selectedSourceLabel: String {
-        return switch selectedFundingSource {
-        case .spending:
-            t("wallet__spending__title")
-        case .savings:
-            t("wallet__savings__title")
-        case .usdt: "USDT"
-        case let .hardware(walletId):
-            hwWalletManager.wallets.first(where: { $0.id == walletId })?.name
-                ?? hwWalletManager.vendor(walletId: walletId).modelName
-        }
+        fundingSourceLabel(selectedFundingSource)
     }
 
     private var selectedSourceColor: Color {
-        switch selectedFundingSource {
-        case .spending: .purpleAccent
-        case .savings: .brandAccent
-        case .usdt: .usdtAccent
-        case .hardware: .blueAccent
-        }
+        fundingSourceColor(selectedFundingSource)
     }
 
     private var assetButtonTestIdentifier: String {
@@ -140,7 +127,7 @@ struct SendAmountView: View {
 
             VStack(alignment: .leading, spacing: 0) {
                 if app.paykitUsesUsdt {
-                    NumberPadAmountText(value: usdtAmount.isEmpty ? "0" : usdtAmount, symbol: "$")
+                    UsdtAmountHeader(amount: usdtAmount.isEmpty ? "0" : usdtAmount)
                         .accessibilityIdentifier("SendNumberField")
                 } else {
                     NumberPadTextField(viewModel: amountViewModel, testIdentifier: "SendNumberField")
@@ -148,15 +135,14 @@ struct SendAmountView: View {
                 }
                 if let conversionError { BodySText(conversionError, textColor: .brandAccent).padding(.top, 12) }
 
-                Spacer()
+                if app.paykitUsesUsdt { Spacer().frame(height: 32) } else { Spacer() }
 
                 // Available balance section
                 HStack(alignment: .bottom) {
                     if app.paykitUsesUsdt {
                         VStack(alignment: .leading, spacing: 4) {
                             CaptionMText(t("wallet__send_available"))
-                            BodySSBText((settings.hideBalance ? "•••••" : usdt.balance.map { PaykitAmount(asset: .usdt, atomic: $0).value } ?? "—") +
-                                " USDT")
+                            BodySSBText(settings.hideBalance ? "•••••" : "$ " + (usdt.balance.map { usdtOverviewAmount($0) } ?? "—"))
                         }
                     } else {
                         AvailableAmount(
@@ -184,12 +170,17 @@ struct SendAmountView: View {
                         imageName: canSwitchFundingSource ? "arrow-up-down" : nil,
                         color: selectedSourceColor,
                         variant: canSwitchFundingSource ? .primary : .secondary,
-                        disabled: !canSwitchFundingSource || isContinuing,
+                        disabled: isContinuing,
                         isLoading: hwSend.isFundingSourceLoading
                     ) {
-                        selectNextFundingSource()
+                        showingFundingSources = true
                     }
                     .accessibilityIdentifier("AssetButton-\(assetButtonTestIdentifier)")
+                    .popover(isPresented: $showingFundingSources, arrowEdge: .bottom) {
+                        fundingSourceMenu
+                            .presentationCompactAdaptation(.popover)
+                            .presentationBackground(Color.gray6)
+                    }
 
                     if !app.paykitUsesUsdt {
                         NumberPadActionButton(
@@ -410,13 +401,98 @@ struct SendAmountView: View {
         amountViewModel.maxAmountOverride = availableAmount > 0 ? availableAmount : nil
     }
 
-    private func selectNextFundingSource() {
-        guard canSwitchFundingSource else { return }
-        let currentIndex = fundingSources.firstIndex(of: selectedFundingSource) ?? -1
-        selectFundingSource(fundingSources[(currentIndex + 1) % fundingSources.count])
+    private var fundingSourceMenu: some View {
+        let sources: [SendFundingSource] = [.savings, .spending] + hwWalletManager.wallets.map {
+            .hardware(walletId: $0.walletId)
+        } + [.usdt]
+        return VStack(alignment: .leading, spacing: 0) {
+            ForEach(sources.indices, id: \.self) { index in
+                let source = sources[index]
+                let enabled = fundingSources.contains(source)
+                Button {
+                    showingFundingSources = false
+                    selectFundingSource(source)
+                } label: {
+                    VStack(alignment: .leading, spacing: 8) {
+                        HStack(spacing: 8) {
+                            CaptionMText(fundingSourceLabel(source)).lineLimit(1)
+                            if case let .hardware(walletId) = source,
+                               let hardwareWallet = hwWalletManager.wallets.first(where: { $0.walletId == walletId })
+                            {
+                                HwWalletConnectionIcon(isConnected: hardwareWallet.isConnected)
+                                    .frame(width: 16, height: 16)
+                            }
+                        }
+                        HStack(spacing: 8) {
+                            Image(fundingSourceIcon(source)).resizable().scaledToFit().frame(width: 24, height: 24)
+                            if source == .usdt {
+                                BodyMSBText(settings.hideBalance ? "•••••" : usdt.balance.map { usdtOverviewAmount($0) } ?? "—")
+                            } else {
+                                MoneyText(sats: Int(fundingSourceBalance(source)), forceUnit: .bitcoin, size: .bodyMSB,
+                                          symbol: false, enableHide: true, fillsWidth: false)
+                            }
+                            Spacer(minLength: 0)
+                            if source == selectedFundingSource {
+                                Image("check").resizable().scaledToFit().frame(width: 16, height: 16)
+                                    .foregroundStyle(fundingSourceColor(source))
+                            }
+                        }
+                    }
+                    .padding(.vertical, 12)
+                    .contentShape(Rectangle())
+                }
+                .buttonStyle(.plain)
+                .disabled(!enabled || hwSend.isFundingSourceLoading)
+                .opacity(enabled ? 1 : 0.30)
+                .accessibilityIdentifier("SendFundingSource-\(index)")
+                if index < sources.count - 1 { CustomDivider() }
+            }
+        }
+        .padding(.horizontal, 24).padding(.vertical, 12)
+        .frame(width: 250)
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("SendFundingSources")
+    }
+
+    private func fundingSourceLabel(_ source: SendFundingSource) -> String {
+        switch source {
+        case .savings: t("wallet__savings__title")
+        case .spending: t("wallet__spending__title")
+        case .usdt: "USDT"
+        case let .hardware(walletId):
+            hwWalletManager.wallets.first { $0.walletId == walletId }?.name ?? hwWalletManager.vendor(walletId: walletId).modelName
+        }
+    }
+
+    private func fundingSourceColor(_ source: SendFundingSource) -> Color {
+        switch source {
+        case .savings: .brandAccent
+        case .spending: .purpleAccent
+        case .usdt: .usdtAccent
+        case .hardware: .blueAccent
+        }
+    }
+
+    private func fundingSourceIcon(_ source: SendFundingSource) -> String {
+        switch source {
+        case .savings: "btc"
+        case .spending: "ln"
+        case .usdt: "tether-circle"
+        case .hardware: "btc-circle-blue"
+        }
+    }
+
+    private func fundingSourceBalance(_ source: SendFundingSource) -> UInt64 {
+        switch source {
+        case .savings: UInt64(wallet.spendableOnchainBalanceSats)
+        case .spending: UInt64(wallet.maxSendLightningSats)
+        case let .hardware(walletId): hwWalletManager.fundingBalance(walletId: walletId)
+        case .usdt: 0
+        }
     }
 
     private func selectFundingSource(_ source: SendFundingSource) {
+        guard source != selectedFundingSource, fundingSources.contains(source) else { return }
         let target: PaykitAsset = source == .usdt ? .usdt : .btc
         let selectsFixedLightning = source == .spending && (app.scannedLightningInvoice?.amountSatoshis ?? 0) > 0
         if app.contactPaymentContext?.incomingPaymentRequest != nil || (!selectsFixedLightning && app.paykitUsesUsdt != (source == .usdt)) {
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index ed3f76768..d896e67a0 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -15,7 +15,9 @@ struct UsdtActivityRow: View {
         ActivityRowContainer {
             ActivityRowContent(
                 title: contactName ?? transfer.title,
-                subtitle: DateFormatterHelpers.getActivityItemDate(transfer.timestamp)
+                subtitle: transfer.status == .bridging
+                    ? t("usdt__to_network", variables: ["network": transfer.destination.label])
+                    : DateFormatterHelpers.getActivityItemDate(transfer.timestamp)
             ) {
                 UsdtActivityIcon(transfer: transfer)
             } amount: {
@@ -40,8 +42,8 @@ struct UsdtActivityIcon: View {
     var body: some View {
         CircularIcon(
             icon: transfer.statusIcon,
-            iconColor: transfer.statusColor,
-            backgroundColor: transfer.statusColor.opacity(0.16),
+            iconColor: .usdtAccent,
+            backgroundColor: Color.usdtAccent.opacity(0.16),
             size: size
         )
     }
@@ -56,85 +58,60 @@ struct UsdtActivityDetail: View {
     @Environment(\.dismiss) private var dismiss
     @Environment(\.scenePhase) private var scenePhase
 
+    @State private var showDetails = false
+
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
-            NavigationBar(title: transfer?.title ?? t("usdt__activity"), onBack: { dismiss() }).padding(.bottom, 16)
+            NavigationBar(title: t(transfer?.isIncoming == true ? "usdt__payment_received" : "usdt__sent_title"), onBack: { dismiss() })
+                .padding(.bottom, 16)
             if let transfer {
                 ScrollView(showsIndicators: false) {
                     VStack(alignment: .leading, spacing: 16) {
-                        HStack(alignment: .bottom) {
-                            UsdtAmountHeader(
-                                amount: usdtFormatAmount(amount: transfer.activityAmount),
-                                prefix: transfer.isIncoming ? "+ " : "− ", hideBalance: settings.hideBalance
-                            )
-                            UsdtActivityIcon(transfer: transfer, size: 48)
-                        }
-                        .padding(.bottom, 16)
-                        SendSectionView(t("wallet__activity_status")) {
-                            Label {
-                                BodySSBText(transfer.status.label, textColor: transfer.statusColor)
-                            } icon: {
-                                Image(transfer.statusIcon).foregroundColor(transfer.statusColor)
-                            }
-                            .accessibilityIdentifier("UsdtActivityStatus")
-                        }
-                        let time = DateFormatterHelpers.formatActivityDetail(transfer.timestamp)
-                        HStack(spacing: 16) {
-                            SendSectionView(t("wallet__activity_date")) { BodySSBText(time.date) }
-                            SendSectionView(t("wallet__activity_time")) { BodySSBText(time.time) }
-                        }
-                        if let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) {
-                            SendSectionView(t(transfer.isIncoming ? "wallet__send_from" : "wallet__send_to")) {
-                                BodySSBText(contacts.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }?.displayName
-                                    ?? PubkyPublicKeyFormat.displayTruncated(key))
+                        VStack(alignment: .leading, spacing: 16) {
+                            CaptionMText(settings.hideBalance ? "• • • • •" : "$ " + usdtOverviewAmount(transfer.activityAmount))
+                            HStack(spacing: 16) {
+                                DisplayText(
+                                    "<accent>\(transfer.isIncoming ? "+" : "−")</accent> "
+                                        + (settings.hideBalance ? "• • • • •" : usdtOverviewAmount(transfer.activityAmount)),
+                                    accentColor: .textSecondary, accentFont: Fonts.extraBold
+                                ).lineLimit(1).minimumScaleFactor(0.5)
+                                UsdtActivityIcon(transfer: transfer, size: 48)
                             }
+                            .frame(height: 36)
+                        }.padding(.bottom, 16)
+                        if showDetails {
+                            technicalDetails(transfer)
+                        } else {
+                            summary(transfer)
                         }
-                        SendSectionView(t("usdt__destination")) { BodySSBText(transfer.destination.label) }
-                        if !transfer.isIncoming {
-                            SendSectionView(t("usdt__address")) { BodySSBText(transfer.recipient).textSelection(.enabled) }
-                            HStack(alignment: .top, spacing: 16) {
-                                if transfer.status != .failed, transfer.status != .replaced {
-                                    SendSectionView(t(transfer.destination != .arbitrum && transfer.status != .confirmed
-                                            ? "usdt__expected_amount" : "usdt__recipient_gets")) { amountText(transfer.receivedAmount) }
-                                }
-                                SendSectionView(t("wallet__activity_fee")) {
-                                    if let fee = transfer.fee {
-                                        amountText(fee)
-                                    } else { BodySSBText("—") }
-                                }
-                            }
-                        }
-                        if let bridge = transfer.orchestra {
-                            SendSectionView(t("usdt__bridge_provider")) { BodySSBText("Orchestra") }
-                            SendSectionView(t("usdt__bridge_reference")) { BodySText(bridge.quoteId).textSelection(.enabled) }
-                            if let hash = bridge.destinationTx {
-                                SendSectionView(t("usdt__destination_tx")) { BodySText(hash).textSelection(.enabled) }
-                            }
-                            if let amount = bridge.refundAmount, let hash = bridge.refundTx {
-                                SendSectionView(t("usdt__deposit_refunded")) { amountText(amount) }
-                                SendSectionView(t("usdt__refund_tx")) { BodySText(hash).textSelection(.enabled) }
-                            }
-                        }
-                        if let txHash = transfer.txHash {
-                            SendSectionView(t("wallet__activity_tx_id")) { BodySText(txHash).textSelection(.enabled) }
+                        CustomButton(
+                            title: t(showDetails ? "common__hide_details" : "wallet__send_details"), size: .small,
+                            icon: Image(showDetails ? "eye-slash" : "git-branch").resizable().frame(width: 16, height: 16)
+                                .foregroundColor(.usdtAccent), shouldExpand: true
+                        ) { showDetails.toggle() }
+                            .accessibilityIdentifier("UsdtActivityDetails")
+                        if showDetails, let txHash = transfer.txHash {
                             if transfer.destination != .arbitrum, transfer.orchestra == nil {
                                 CustomButton(title: t("usdt__track_bridge"), variant: .secondary, shouldExpand: true) {
                                     if let url = URL(string: "https://layerzeroscan.com/tx/" + txHash) { openURL(url) }
                                 }
                             }
-                            if let url = URL(string: "https://arbiscan.io/tx/" + txHash) {
-                                CustomButton(title: t("wallet__activity_explore"), variant: .secondary, shouldExpand: true) { openURL(url) }
-                            }
-                        }
-                        if transfer.destination != .arbitrum {
-                            UsdtSupportActions(details: transfer.supportDetails)
                         }
+                        if transfer.destination != .arbitrum { UsdtSupportActions(details: transfer.supportDetails) }
+                    }
+                }
+                .frame(maxHeight: .infinity, alignment: .top)
+                if showDetails, let txHash = transfer.txHash {
+                    CustomButton(title: t("wallet__activity_explorer"), shouldExpand: true) {
+                        if let url = URL(string: "https://arbiscan.io/tx/" + txHash) { openURL(url) }
                     }
-                    .bottomSafeAreaPadding()
+                    .padding(.top, 24)
+                    .accessibilityIdentifier("UsdtActivityExplorer")
                 }
             }
         }
         .padding(.horizontal, 16)
+        .bottomSafeAreaPadding()
         .navigationBarHidden(true)
         .task(id: scenePhase) {
             guard scenePhase == .active else { return }
@@ -145,12 +122,72 @@ struct UsdtActivityDetail: View {
         }
     }
 
+    @ViewBuilder
+    private func summary(_ transfer: UsdtTransfer) -> some View {
+        HStack(alignment: .top, spacing: 16) {
+            UsdtDetailCell(title: t("wallet__activity_status"), value: transfer.status.label,
+                           icon: transfer.status == .confirmed ? "check-circle" : transfer.statusIcon, valueColor: transfer.statusColor)
+                .accessibilityIdentifier("UsdtActivityStatus")
+            UsdtDetailCell(title: t("usdt__network"), value: UsdtDestination.arbitrum.label, icon: "usdt-network")
+        }
+        let time = DateFormatterHelpers.formatActivityDetail(transfer.timestamp)
+        HStack(alignment: .top, spacing: 16) {
+            UsdtDetailCell(title: t("wallet__activity_date"), value: time.date, icon: "calendar")
+            UsdtDetailCell(title: t("wallet__activity_time"), value: time.time, icon: "clock")
+        }
+        HStack(alignment: .top, spacing: 16) {
+            UsdtDetailCell(title: t("wallet__activity_payment"), value: displayedAmount(transfer.amount), icon: "user")
+            UsdtDetailCell(title: t("wallet__activity_fee"), value: transfer.fee.map(displayedAmount) ?? "—", icon: "speed-normal")
+        }
+        if let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) {
+            SendSectionView(t("wallet__payment_request_contact")) {
+                BodySSBText(contacts.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }?.displayName
+                    ?? PubkyPublicKeyFormat.displayTruncated(key))
+            }
+        }
+        if transfer.destination != .arbitrum, transfer.status != .failed, transfer.status != .replaced {
+            SendSectionView(t(transfer.status == .confirmed ? "usdt__recipient_gets" : "usdt__expected_amount")) {
+                amountText(transfer.receivedAmount)
+            }
+        }
+    }
+
+    @ViewBuilder
+    private func technicalDetails(_ transfer: UsdtTransfer) -> some View {
+        if let txHash = transfer.txHash {
+            SendSectionView(t("wallet__activity_tx_id")) { BodySSBText(txHash).textSelection(.enabled) }
+        }
+        if let sender = transfer.sender ?? (!transfer.isIncoming && !usdt.address.isEmpty ? usdt.address : nil) {
+            SendSectionView(t("usdt__from_address")) { BodySSBText(sender).textSelection(.enabled) }
+        }
+        SendSectionView(t("usdt__to_address")) { BodySSBText(transfer.recipient).textSelection(.enabled) }
+        HStack(alignment: .top, spacing: 16) {
+            UsdtDetailCell(title: t("usdt__sender_network"), value: UsdtDestination.arbitrum.label, icon: "usdt-network")
+            UsdtDetailCell(title: t("usdt__destination"), value: transfer.destination.label, icon: "usdt-network")
+        }
+        if let bridge = transfer.orchestra {
+            SendSectionView(t("usdt__bridge_provider")) { BodySSBText("Orchestra") }
+            SendSectionView(t("usdt__bridge_reference")) { BodySSBText(bridge.quoteId).textSelection(.enabled) }
+            if let hash = bridge.destinationTx {
+                SendSectionView(t("usdt__destination_tx")) { BodySSBText(hash).textSelection(.enabled) }
+            }
+            if let amount = bridge.refundAmount, let hash = bridge.refundTx {
+                SendSectionView(t("usdt__deposit_refunded")) { amountText(amount) }
+                SendSectionView(t("usdt__refund_tx")) { BodySSBText(hash).textSelection(.enabled) }
+            }
+        }
+    }
+
+    private func displayedAmount(_ amount: UInt64) -> String {
+        settings.hideBalance ? "• • • • •" : usdtOverviewAmount(amount)
+    }
+
     private var transfer: UsdtTransfer? {
         usdt.transfers.first { $0.id == transferId }
     }
 
     private func amountText(_ amount: UInt64) -> some View {
-        BodySSBText((settings.hideBalance ? " • • • • •" : usdtFormatAmount(amount: amount)) + " USDT")
+        BodySSBText((settings.hideBalance ? " • • • • •" : usdtOverviewAmount(amount)) + " USDT")
     }
 }
 
@@ -165,7 +202,8 @@ extension UsdtTransfer {
     var title: String {
         switch status {
         case .failed, .replaced: status.label
-        case .pending, .bridging, .bridgeNeedsAttention, .bridgeFailed, .bridgeRefunded: status.label
+        case .bridging: t("wallet__activity_transferring")
+        case .pending, .bridgeNeedsAttention, .bridgeFailed, .bridgeRefunded: status.label
         default: t(isIncoming ? "usdt__received" : "usdt__sent")
         }
     }
@@ -176,8 +214,9 @@ extension UsdtTransfer {
 
     var statusIcon: String {
         switch status {
-        case .failed, .replaced, .bridgeFailed: "x-mark"
-        case .pending, .bridging, .bridgeNeedsAttention: "hourglass-simple"
+        case .failed, .replaced, .bridgeFailed: "x-circle"
+        case .pending, .bridgeNeedsAttention: "hourglass-simple"
+        case .bridging: "arrow-up-down"
         case .confirmed: isIncoming ? "arrow-down" : "arrow-up"
         case .bridgeRefunded: "arrow-down"
         }
@@ -191,3 +230,19 @@ extension UsdtTransfer {
         }
     }
 }
+
+struct UsdtDetailCell: View {
+    let title: String
+    let value: String
+    let icon: String
+    var valueColor: Color = .textPrimary
+
+    var body: some View {
+        SendSectionView(title) {
+            HStack(spacing: 4) {
+                Image(icon).resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(.usdtAccent)
+                BodySSBText(value, textColor: valueColor)
+            }.frame(minHeight: 20, alignment: .leading)
+        }
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index ff3789f9c..16774cf00 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -22,12 +22,15 @@ struct UsdtSendView: View {
     @State private var destination: UsdtDestination = .arbitrum
     @State private var destinations = Env.usdtDestinations
     @State private var quote: UsdtQuote?
+    @State private var maximumQuote: UsdtQuote?
+    @State private var preparingMaximum = false
     @State private var editingRecipient = false
     @State private var editingAmount = false
     @State private var busy = false
     @State private var error: String?
     @State private var pin = false
     @State private var submitted = false
+    @State private var paymentComplete = false
     @State private var showDetails = false
     @State private var warning: String?
     @State private var confirmedWarnings: Set<String> = []
@@ -148,6 +151,10 @@ struct UsdtSendView: View {
             guard scenePhase == .active, submitted else { return }
             if busy, let quote {
                 if quote.destination == .arbitrum { await usdt.waitForTransfer(quote.id) }
+                if submittedStatus == .confirmed {
+                    paymentComplete = true
+                    do { try await Task.sleep(for: .seconds(1)) } catch { return }
+                }
                 busy = false
             }
             while !Task.isCancelled, [.pending, .bridging, .bridgeNeedsAttention].contains(submittedStatus) {
@@ -173,29 +180,35 @@ struct UsdtSendView: View {
     }
 
     private var networkSelector: some View {
-        SendSectionView(t("usdt__destination")) {
-            if !embedded, destinations.count > 1 {
-                Menu {
-                    ForEach(destinations, id: \.self) { item in
-                        Button(item.label) {
-                            guard destination != item else { return }
-                            destination = item
-                            recipient = ""
-                            amount = ""
-                            quote = nil
-                            error = nil
-                        }
+        SendSectionView(t("usdt__network")) { networkButton }
+    }
+
+    private var networkButton: some View {
+        Menu {
+            ForEach(destinations, id: \.self) { item in
+                Button(item.label) {
+                    guard destination != item else { return }
+                    destination = item
+                    maximumQuote = nil
+                    quote = nil
+                    error = nil
+                    if !recipient.isEmpty, (try? usdtValidateRecipient(value: recipient, destination: item)) == nil {
+                        editingAmount = false
+                        editingRecipient = true
                     }
-                } label: {
-                    NumberPadActionButton(text: destination.label, color: .usdtAccent, variant: .secondary) {}
                 }
-                .accessibilityIdentifier("UsdtNetwork")
-            } else {
-                BodySSBText(destination.label)
-                    .frame(minHeight: 28)
-                    .accessibilityIdentifier("UsdtNetwork")
             }
+        } label: {
+            HStack(spacing: 4) {
+                Image("usdt-network").resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(.usdtAccent)
+                CaptionBText(destination.label).lineLimit(1).minimumScaleFactor(0.8)
+            }
+            .padding(.horizontal, 8).frame(height: 28)
+            .background(Color.white06, in: Capsule())
+            .overlay(Capsule().stroke(Color.white10, lineWidth: 1))
         }
+        .disabled(embedded || destinations.count < 2 || busy)
+        .accessibilityIdentifier("UsdtNetwork")
     }
 
     private var recipientContent: some View {
@@ -240,8 +253,7 @@ struct UsdtSendView: View {
 
     private var amountContent: some View {
         VStack(alignment: .leading, spacing: 0) {
-            CaptionMText("USDT · " + destination.label).padding(.bottom, 8)
-            NumberPadAmountText(value: amount.isEmpty ? "0" : amount, symbol: "$")
+            UsdtAmountHeader(amount: amount.isEmpty ? "0" : amount)
                 .accessibilityIdentifier("UsdtAmount")
                 .padding(.bottom, 32)
             if let error {
@@ -249,23 +261,40 @@ struct UsdtSendView: View {
             }
             HStack(alignment: .bottom) {
                 VStack(alignment: .leading, spacing: 8) {
-                    CaptionMText(t("usdt__balance"))
-                    BodySSBText((settings.hideBalance ? " • • • • •" : usdt.balance.map { usdtFormatAmount(amount: $0) } ?? "—") + " USDT")
+                    CaptionMText(t("wallet__send_available"))
+                    BodySSBText(settings.hideBalance ? " • • • • •" : "$ " + (usdt.balance.map { usdtOverviewAmount($0) } ?? "—"))
                 }
                 Spacer()
                 NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
+                if !embedded {
+                    NumberPadActionButton(text: t("common__max"), color: .usdtAccent, disabled: busy,
+                                          isLoading: preparingMaximum)
+                    {
+                        Task { await useMaximum() }
+                    }
+                    .accessibilityIdentifier("UsdtMax")
+                    networkButton
+                }
             }
             .padding(.bottom, 16)
             CustomDivider()
-            NumberPad(type: .decimal, isDisabled: busy || embedded, onDeleteLongPress: { amount = "" }, onPress: enterAmount)
+            NumberPad(type: .decimal, isDisabled: busy || embedded, onDeleteLongPress: { amount = ""; maximumQuote = nil }, onPress: enterAmount)
                 .frame(maxHeight: .infinity)
-            CustomButton(title: t("common__continue"), isDisabled: busy || amount.isEmpty, isLoading: busy) {
+            CustomButton(title: t("common__continue"), isDisabled: busy || amount.isEmpty, isLoading: busy && !preparingMaximum) {
                 guard !busy, quote == nil else { return }
                 busy = true
                 error = nil
                 defer { busy = false }
                 do {
-                    quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination)
+                    if let maximumQuote {
+                        let fresh = maximumQuote.expiresAt > UInt64(Date().timeIntervalSince1970) + 5
+                        let prepared: UsdtQuote = if fresh { maximumQuote }
+                        else { try await usdt.quoteMaximum(recipient: recipient, destination: destination) }
+                        quote = prepared
+                        amount = usdtFormatAmount(amount: prepared.amount)
+                    } else {
+                        quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination)
+                    }
                     showDetails = false
                     confirmedWarnings = []
                 } catch is CancellationError {
@@ -280,74 +309,44 @@ struct UsdtSendView: View {
 
     private func confirmation(_ quote: UsdtQuote) -> some View {
         VStack(alignment: .leading, spacing: 0) {
-            ScrollView(showsIndicators: false) {
-                VStack(alignment: .leading, spacing: 0) {
-                    UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount))
-                        .contentShape(Rectangle()).onTapGesture { if !busy { goBack() } }
-                        .padding(.bottom, paymentRequest == nil ? 44 : 24)
-                    if showDetails {
-                        VStack(alignment: .leading, spacing: 16) {
-                            HStack(alignment: .top, spacing: 16) {
-                                SendSectionView(t("wallet__send_from")) {
-                                    NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
-                                }
-                                if paymentContext != nil {
-                                    SendSectionView(t("wallet__payment_request_contact")) {
-                                        HStack(spacing: 4) {
-                                            if let contact { PubkyContactAvatar(contact: contact, size: 20) }
-                                            BodySSBText(contactName).lineLimit(1)
-                                        }.frame(height: 28)
-                                    }
-                                } else {
-                                    SendSectionView(t("usdt__destination")) { BodySSBText(quote.destination.label).frame(height: 28) }
-                                }
-                            }
-                            SendSectionView(t("wallet__send_to")) { BodySSBText(quote.recipient).textSelection(.enabled) }
-                            if let provider = quote.bridgeProvider {
-                                SendSectionView(t("usdt__bridge_provider")) { BodySSBText(provider == .orchestra ? "Orchestra" : "USDT0") }
+            GeometryReader { geometry in
+                ScrollView(showsIndicators: false) {
+                    VStack(alignment: .leading, spacing: 0) {
+                        UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), displayAmount: usdtOverviewAmount(quote.amount))
+                            .contentShape(Rectangle()).onTapGesture { if !busy { goBack() } }
+                            .padding(.bottom, 32)
+                        if showDetails {
+                            quoteDetails(quote)
+                            if let requestNote { PaymentRequestInvoiceNote(note: requestNote).padding(.top, 16) }
+                        } else {
+                            if paymentRequest != nil {
+                                PaymentRequestSummary(contactName: contactName, note: requestNote).padding(.bottom, 16)
                             }
+                            Spacer(minLength: 0)
+                            PaymentReviewIllustration(swipeProgress: swipeProgress, maximumHeight: 192)
+                                .padding(.top, 16).frame(height: 256)
                         }
-                        if let requestNote { PaymentRequestInvoiceNote(note: requestNote).padding(.top, 16) }
-                    } else {
-                        if paymentRequest != nil {
-                            PaymentRequestSummary(contactName: contactName, note: requestNote).padding(.bottom, 16)
-                        }
-                        PaymentReviewIllustration(swipeProgress: swipeProgress, maximumHeight: 220)
-                    }
-                    if quote.destination != .arbitrum {
-                        SendSectionView(t(quote.bridgeProvider == .orchestra ? "usdt__expected_amount" : "usdt__recipient_gets")) {
-                            BodySSBText(usdtFormatAmount(amount: quote.receivedAmount) + " USDT")
-                        }.padding(.top, 16)
-                        if quote.bridgeProvider == .orchestra {
-                            SendSectionView(t("usdt__bridge_deducted_fee")) {
-                                BodySSBText(usdtFormatAmount(amount: quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
-                            }.padding(.top, 16)
-                        }
-                    }
-                    SendSectionView(t("usdt__maximum_fee")) {
-                        BodySSBText(usdtFormatAmount(amount: quote.maximumFee) + " USDT")
+                        if quote.destination != .arbitrum { bridgeCosts(quote).padding(.top, 16) }
+                        if let error { BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError") }
+                        CustomButton(
+                            title: t(showDetails ? "common__hide_details" : "common__show_details"), size: .small,
+                            icon: Image(showDetails ? "eye-slash" : "speed-normal").resizable().frame(width: 16, height: 16)
+                                .foregroundColor(.usdtAccent), background: Color.white06
+                        ) { showDetails.toggle() }
+                            .frame(maxWidth: .infinity).padding(.vertical, 24)
+                            .accessibilityIdentifier("UsdtReviewDetails")
+                        if showDetails { Spacer(minLength: 0) }
                     }
-                    .padding(.top, 16)
-                    if quote.destination != .arbitrum {
-                        SendSectionView(t("usdt__maximum_total")) { BodySSBText(usdtFormatAmount(amount: quote.amount + quote.maximumFee) + " USDT") }
-                            .padding(.top, 16)
-                    }
-                    BodySText(t(quote.bridgeProvider == .orchestra ? "usdt__bridge_estimate_note" : "usdt__fee_note"), textColor: .textSecondary)
-                        .padding(
-                            .top,
-                            12
-                        )
-                    if let error { BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError") }
+                    .frame(minHeight: geometry.size.height, alignment: .top)
                 }
             }
-            CustomButton(
-                title: t(showDetails ? "common__hide_details" : "common__show_details"), size: .small,
-                icon: Image(showDetails ? "eye-slash" : "coins").foregroundColor(.usdtAccent), background: Color(hex: 0x151515)
-            ) { showDetails.toggle() }
-                .frame(maxWidth: .infinity).padding(.vertical, 24)
-                .accessibilityIdentifier("UsdtReviewDetails")
+            if showDetails {
+                CaptionText(t(quote.bridgeProvider == .orchestra ? "usdt__bridge_estimate_note" : "usdt__fee_note"))
+                    .multilineTextAlignment(.center).frame(maxWidth: .infinity).padding(.bottom, 24)
+            }
             SwipeButton(
-                title: t("wallet__send_swipe"), accentColor: .usdtAccent, isDisabled: busy, isLoading: busy, swipeProgress: $swipeProgress
+                title: t("wallet__send_swipe"), accentColor: .usdtAccent, isDisabled: busy,
+                isLoading: busy, isComplete: paymentComplete, swipeProgress: $swipeProgress
             ) {
                 await confirmPayment()
                 if !submitted { throw CancellationError() }
@@ -357,6 +356,49 @@ struct UsdtSendView: View {
         }
     }
 
+    private func quoteDetails(_ quote: UsdtQuote) -> some View {
+        VStack(alignment: .leading, spacing: 16) {
+            HStack(alignment: .top, spacing: 16) {
+                SendSectionView(t("usdt__pay_from")) {
+                    NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
+                }
+                UsdtDetailCell(title: t("usdt__network"), value: quote.destination.label, icon: "usdt-network")
+            }
+            HStack(alignment: .top, spacing: 16) {
+                UsdtDetailCell(title: t("wallet__activity_payment"), value: usdtOverviewAmount(quote.amount), icon: "user")
+                UsdtDetailCell(title: t("wallet__activity_fee"), value: usdtOverviewAmount(quote.maximumFee), icon: "speed-normal")
+            }
+            if paymentContext != nil {
+                SendSectionView(t("wallet__payment_request_contact")) {
+                    HStack(spacing: 4) {
+                        if let contact { PubkyContactAvatar(contact: contact, size: 20) }
+                        BodySSBText(contactName).lineLimit(1)
+                    }
+                }
+            }
+            SendSectionView(t("wallet__activity_address")) {
+                BodySSBText(quote.recipient).fixedSize(horizontal: false, vertical: true).textSelection(.enabled)
+            }
+            if let provider = quote.bridgeProvider {
+                SendSectionView(t("usdt__bridge_provider")) { BodySSBText(provider == .orchestra ? "Orchestra" : "USDT0") }
+            }
+        }
+    }
+
+    private func bridgeCosts(_ quote: UsdtQuote) -> some View {
+        VStack(alignment: .leading, spacing: 16) {
+            SendSectionView(t(quote.bridgeProvider == .orchestra ? "usdt__expected_amount" : "usdt__recipient_gets")) {
+                BodySSBText(usdtFormatAmount(amount: quote.receivedAmount) + " USDT")
+            }
+            if quote.bridgeProvider == .orchestra {
+                SendSectionView(t("usdt__bridge_deducted_fee")) {
+                    BodySSBText(usdtFormatAmount(amount: quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
+                }
+            }
+            SendSectionView(t("usdt__maximum_total")) { BodySSBText(usdtFormatAmount(amount: quote.amount + quote.maximumFee) + " USDT") }
+        }
+    }
+
     private var submittedContent: some View {
         VStack(alignment: .leading, spacing: 0) {
             if let quote {
@@ -396,10 +438,11 @@ struct UsdtSendView: View {
         do {
             let request: UsdtPaymentRequest = if value.contains(":") { try usdtParsePaymentRequest(value: value) }
             else { try UsdtPaymentRequest(recipient: usdtValidateRecipient(value: value, destination: destination), amount: nil, chainId: nil) }
-            guard request.chainId == nil || destination == .arbitrum else { throw UsdtError.WrongNetwork }
+            if request.chainId != nil { destination = .arbitrum }
             recipient = request.recipient
-            amount = request.amount.map { usdtFormatAmount(amount: $0) } ?? ""
+            if let requestedAmount = request.amount { amount = usdtFormatAmount(amount: requestedAmount) }
         } catch { self.error = UsdtWalletManager.message(for: error); return }
+        maximumQuote = nil
         recipientFocused = false
         editingAmount = true
         error = nil
@@ -429,8 +472,23 @@ struct UsdtSendView: View {
         error = nil
     }
 
+    private func useMaximum() async {
+        guard !busy, !embedded else { return }
+        busy = true
+        preparingMaximum = true
+        error = nil
+        defer { busy = false; preparingMaximum = false }
+        do {
+            let prepared = try await usdt.quoteMaximum(recipient: recipient, destination: destination)
+            maximumQuote = prepared
+            amount = usdtFormatAmount(amount: prepared.amount)
+        } catch is CancellationError {
+        } catch { self.error = UsdtWalletManager.message(for: error) }
+    }
+
     private func enterAmount(_ key: String) {
         guard !busy else { return }
+        maximumQuote = nil
         amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
     }
 
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index c465dd0e7..b45c660e1 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -187,7 +187,7 @@ func usdtDisplaySats(amount: String, rate: PaykitExchangeRate?, now: Date = Date
 }
 
 func usdtOverviewAmount(_ amount: UInt64, locale: Locale = .current) -> String {
-    let format = Decimal.FormatStyle.number.precision(.fractionLength(0 ... 2))
+    let format = Decimal.FormatStyle.number.precision(.fractionLength(2))
         .rounded(rule: .toNearestOrAwayFromZero).locale(locale)
     if amount > 0, amount < 10000 { return "<" + (Decimal(1) / 100).formatted(format) }
     return (Decimal(amount) / 1_000_000).formatted(format)
diff --git a/BitkitTests/UsdtDisplayTests.swift b/BitkitTests/UsdtDisplayTests.swift
index 2f8e407e4..712f176e6 100644
--- a/BitkitTests/UsdtDisplayTests.swift
+++ b/BitkitTests/UsdtDisplayTests.swift
@@ -17,7 +17,7 @@ final class UsdtDisplayTests: XCTestCase {
     func testOverviewAmountsRoundToCentsWithoutHidingSmallBalances() {
         let locale = Locale(identifier: "en_US")
         for (amount, expected): (UInt64, String) in [
-            (0, "0"), (1, "<0.01"), (9999, "<0.01"), (10000, "0.01"),
+            (0, "0.00"), (1, "<0.01"), (9999, "<0.01"), (10000, "0.01"), (10_000_000, "10.00"),
             (123_456_789, "123.46"), (1_025_000, "1.03"), (1_234_567_890, "1,234.57"),
         ] {
             XCTAssertEqual(usdtOverviewAmount(amount, locale: locale), expected, "amount: \(amount)")
diff --git a/BitkitTests/UsdtSupportDetailsTests.swift b/BitkitTests/UsdtSupportDetailsTests.swift
index 5767be457..d0f7b3a8a 100644
--- a/BitkitTests/UsdtSupportDetailsTests.swift
+++ b/BitkitTests/UsdtSupportDetailsTests.swift
@@ -6,6 +6,7 @@ import XCTest
 final class UsdtSupportDetailsTests: XCTestCase {
     func testTransferSupportIncludesProviderReferencesAndTransactions() {
         var transfer = UsdtTransfer(
+            sender: nil,
             id: "local-id", txHash: "source-tx", userOperationHash: nil, bridgeGuid: "message-id", orchestra: nil,
             recipient: "recipient-address", destination: .polygon, amount: 100, receivedAmount: 90,
             fee: 10, isIncoming: false, status: .bridgeNeedsAttention, timestamp: 1
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 31f70527f..7c8693c05 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -97,6 +97,7 @@ final class UsdtWalletManagerTests: XCTestCase {
 
     private func transfer(_ id: String, incoming: Bool = true, status: UsdtTransferStatus = .confirmed, amount: UInt64 = 1_000_000) -> UsdtTransfer {
         UsdtTransfer(
+            sender: nil,
             id: id,
             txHash: status == .pending ? nil : id,
             userOperationHash: nil,
diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index 3ebe5e70a..e0539fe85 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -60,7 +60,7 @@ Use disposable wallets and a controlled RPC, bundler and encrypted VSS test envi
 
 Requires two linked owned wallets and funded payment rails: Arbitrum One USDT or the local Arbitrum fork fixture for USDT review, and usable Bitcoin balances for Bitcoin review. A Bitcoin regtest balance does not fund USDT. The differing-rate checks require a controlled request issuer and BTC/USD rate source; proof-status checks require controlled receipt evidence. No payment is submitted by the review steps.
 
-- [ ] Open an unpaid USD request accepting only USDT. Continue from Amount to review. Verify Payment Request, the requester avatar, From and For summary, the exact dollar amount and additional fee. Open details and verify Contact, recipient address and invoice note. Close without swiping to pay.
+- [ ] Open an unpaid USD request accepting only USDT. Continue from Amount to review. Verify Payment Request, the requester avatar, From and For summary, the dollar amount rounded to cents. Open details and verify the additional fee, Contact, recipient address and invoice note. Amount entry retains the exact six-decimal payment value. Close without swiping to pay.
 - [ ] Open a quoted request for 1000 USD requiring 1 BTC while Bitkit's controlled BTC/USD rate is 2000. Verify details label 1000 USD as Requested amount, while payment review shows 1 BTC and Bitkit's approximately 2000 USD valuation. Close without paying.
 - [ ] Open a BTC request with different quoted prices for Bitcoin and Lightning. Switch Savings and Spending and verify each method's payable BTC amount, Bitkit's own fiat valuation and explicit payment approval. Close without paying.
 - [ ] Open a linked USDT-only contact with a published private payment list, enter 0.01 USDT and continue to review. Verify the owned recipient address and fee, then close without paying.
diff --git a/Docs/USDT.md b/Docs/USDT.md
index f45bd4044..d52bea43f 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -1,6 +1,6 @@
 # USDT configuration
 
-Normal builds use published bitkit-core `0.8.0-rc3`, including its matching native libraries and generated bindings.
+Normal builds use published bitkit-core `0.8.0-rc4`, including its matching native libraries and generated bindings. MAX requires the USDT gateway to allow Core's pinned balance override during gas estimation; it never applies to signing or submission.
 
 USDT uses Arbitrum One regardless of the Bitcoin network setting. Builds use the credential-free Bitkit gateway by default:
 
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index dc99bb0e8..e375236c7 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -4,6 +4,7 @@
     <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount or review screen preserves recipient and 0.010001 USDT. Verify no payment occurs without approval.</action>
     <action>Cancel the send, then reopen the identical URI. Verify the amount or review screen opens again. Cancel and open a different owned recipient and amount, verifying only the new values appear.</action>
     <action>While a USDT contact amount screen or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
+    <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>
     <action>Cancel the send. Open the same link without uint256. Verify the amount screen opens with no amount and accepts a new amount.</action>
     <action>Cancel the send. From the main scanner, paste or import a QR containing the same amount-bearing URI. Verify it opens the USDT send flow with the same recipient and amount.</action>
     <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
diff --git a/journeys/usdt-send-review-and-details.xml b/journeys/usdt-send-review-and-details.xml
new file mode 100644
index 000000000..3f09de308
--- /dev/null
+++ b/journeys/usdt-send-review-and-details.xml
@@ -0,0 +1,13 @@
+<journey name="usdt send review and details">
+  <description>Use an onboarded wallet with USDT, a fresh BTC/USD rate, an owned recipient and existing sent/received activity. Quotes require the service with MAX support. No payment is submitted.</description>
+  <actions>
+    <action>Open USDT Send and enter the owned recipient. On Amount, verify the BTC equivalent above the dollar amount, 32-point gap before Available balance, USDT badge, MAX and network pill. Enter a six-decimal amount and verify no precision is lost.</action>
+    <action>Open the network pill and select another EVM network. Verify the amount and valid recipient remain. Change to Solana with an EVM recipient and verify recipient entry is required. Enter an owned plain Solana address and verify the previous amount remains. Return to Arbitrum, enter the owned EVM address and verify the amount still remains.</action>
+    <action>From recipient entry with another network selected, paste an explicit Arbitrum USDT URI. Verify the selected network becomes Arbitrum and the link amount is retained. A plain 0x address preserves the selected network.</action>
+    <action>Tap MAX. Verify it fills a positive amount below the balance and remains on Amount. Continue and verify the payment plus maximum fee fits within the balance. Back out without swiping.</action>
+    <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note above the swipe control. Hide Details restores the illustration. Cancel without paying.</action>
+    <action>Open an existing sent USDT activity. Verify the heading is Sent USDT, the signed amount includes the actual fee, and summary rows show Status/Network, Date/Time and Payment/Fee with teal icons. Open Details and verify transaction ID, known sender, recipient and source/destination networks; Open Block Explorer stays at the bottom.</action>
+    <action>Open an existing received activity. Verify Received USDT and a positive amount. Verify Details shows the verified sender when available and does not invent one for older unknown records. Check pending, failed and transferring rows use their matching icons, and transferring shows its destination.</action>
+    <action>Prepare a contact payment that accepts multiple payment methods. Open the payment-source button and verify the balance menu shows Savings, Spending, any paired hardware wallet and USDT. Unsupported methods are disabled. Select a supported method and verify its label, available balance and payable amount update. Cancel without paying.</action>
+  </actions>
+</journey>

From 5d6b5b7194f1c2785a1809d0fc7d7168f48b1d18 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 13:54:39 -0500
Subject: [PATCH 24/62] docs: align USDT QA with current navigation

---
 Docs/USDT-QA.md                  | 4 ++--
 journeys/usdt-bridge-support.xml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index e0539fe85..8360d05a2 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -20,8 +20,8 @@ A funded Arbitrum wallet uses the real gateway with USDT0 and Orchestra enabled.
 USDT is configured against the real gateway; both app and service enable Polygon through USDT_BRIDGE_NETWORKS, and USDT_BRIDGES_URL enables Orchestra destinations. Use a funded wallet and an owned destination address. Mainnet transfers require authorization. Preserve wallet data, keep authentication out of recordings, and record actual transaction hashes and fees.
 
 - [ ] Open the home screen and verify the USDT balance, then open USDT and Send.
-- [ ] Choose Polygon in UsdtNetwork and open manual address entry. Verify an invalid address and an Arbitrum-specific payment URI cannot advance.
-- [ ] Select Arbitrum and accept an Arbitrum payment URI. Go back from amount entry and change to Polygon. Verify the previous recipient and amount are cleared and must be entered again.
+- [ ] Choose Polygon in UsdtNetwork and open manual address entry. Verify an invalid address cannot advance. Enter an Arbitrum-specific payment URI and verify the selected network changes to Arbitrum and uses the URI recipient and amount.
+- [ ] Change to Polygon from amount entry. Verify the valid EVM recipient and entered amount are retained. Change to Solana and verify a compatible recipient is required; entering a plain Solana address preserves the amount, while a supported payment URI with an explicit amount replaces it.
 - [ ] Enter the owned destination address and a small USDT amount. Verify the review shows Polygon, the full recipient, selected provider, estimated received amount, included Orchestra routing cost where applicable, additional maximum source fee and maximum total debit in USDT.
 - [ ] Authorize one payment. Verify it appears in activity as awaiting cross-network delivery rather than claiming delivery from source-chain execution alone.
 - [ ] Restart the app and verify the same transfer continues tracking without sending a second payment.
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
index 496360012..6377f39c7 100644
--- a/journeys/usdt-bridge-support.xml
+++ b/journeys/usdt-bridge-support.xml
@@ -2,7 +2,7 @@
   <description>Use an onboarded wallet with an outbound cross-network transfer and an Orchestra deposit in its history. Existing history or a provider fixture is sufficient; do not submit a payment or support request.</description>
   <actions>
     <action>Open USDT from Home, then open a cross-network transfer in Activity.</action>
-    <action>Verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed.</action>
+    <action>Tap Details (id "UsdtActivityDetails"), then verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting.</action>
     <action>Open USDT Receive, then Network and Deposit Activity, and open a deposit.</action>

From 270b2549b84997158c6bb9b573bb32f615dab1c8 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 14:23:23 -0500
Subject: [PATCH 25/62] fix: complete usdt design consistency

---
 Bitkit/Components/PaykitAmountText.swift         |  8 ++++++--
 Bitkit/Components/PaymentRequestSummary.swift    |  3 ++-
 Bitkit/Components/SwipeButton.swift              |  8 ++++----
 .../PaymentRequests/PaymentRequestsView.swift    |  2 +-
 .../Wallets/Send/SendConfirmationView.swift      |  3 ++-
 Bitkit/Views/Wallets/Sheets/ReceivedTx.swift     | 16 +++++++++++-----
 .../Views/Wallets/UsdtDepositHistoryView.swift   |  7 +++++--
 Bitkit/Views/Wallets/UsdtReceiveView.swift       |  6 +++---
 Bitkit/Views/Wallets/UsdtSendView.swift          | 10 +++++-----
 Docs/USDT-QA.md                                  |  4 ++++
 journeys/usdt-receive-amount-and-units.xml       |  2 +-
 journeys/usdt-send-review-and-details.xml        |  2 +-
 12 files changed, 45 insertions(+), 26 deletions(-)

diff --git a/Bitkit/Components/PaykitAmountText.swift b/Bitkit/Components/PaykitAmountText.swift
index 3c6b4b488..d50e43ab7 100644
--- a/Bitkit/Components/PaykitAmountText.swift
+++ b/Bitkit/Components/PaykitAmountText.swift
@@ -6,14 +6,18 @@ struct PaykitAmountText: View {
     var prefix = ""
     var color: Color = .textPrimary
 
+    private var displayValue: String {
+        amount.asset == .usdt ? usdtOverviewAmount(amount.atomic) : amount.value
+    }
+
     var body: some View {
         if amount.asset == .btc {
             MoneyText(sats: Int(clamping: amount.atomic), size: size, symbol: true,
                       prefix: prefix, color: color, symbolColor: .textSecondary, fillsWidth: false)
         } else if size == .display {
-            NumberPadAmountText(value: prefix + amount.value, symbol: "$")
+            NumberPadAmountText(value: prefix + displayValue, symbol: "$")
         } else {
-            BodyMSBText(prefix + "$" + amount.value, textColor: color)
+            BodyMSBText(prefix + "$" + displayValue, textColor: color)
         }
     }
 }
diff --git a/Bitkit/Components/PaymentRequestSummary.swift b/Bitkit/Components/PaymentRequestSummary.swift
index 4a578641c..1f9a25c29 100644
--- a/Bitkit/Components/PaymentRequestSummary.swift
+++ b/Bitkit/Components/PaymentRequestSummary.swift
@@ -3,6 +3,7 @@ import SwiftUI
 struct PaymentRequestSummary: View {
     let contactName: String
     let note: String?
+    let accentColor: Color
 
     var body: some View {
         HStack(alignment: .top, spacing: 16) {
@@ -35,7 +36,7 @@ struct PaymentRequestSummary: View {
             Image(icon)
                 .resizable()
                 .scaledToFit()
-                .foregroundColor(.white)
+                .foregroundColor(accentColor)
                 .frame(width: 16, height: 16)
 
             BodySSBText(text, textColor: textColor)
diff --git a/Bitkit/Components/SwipeButton.swift b/Bitkit/Components/SwipeButton.swift
index e1facc1f4..9f9c0ad9a 100644
--- a/Bitkit/Components/SwipeButton.swift
+++ b/Bitkit/Components/SwipeButton.swift
@@ -33,9 +33,9 @@ struct SwipeButton: View {
     var body: some View {
         GeometryReader { geometry in
             let maxOffset = max(1, geometry.size.width - buttonHeight)
-            let clampedOffset = max(0, min(offset, geometry.size.width - buttonHeight))
+            let clampedOffset = isLoading || isComplete ? maxOffset : max(0, min(offset, maxOffset))
             let trailWidth = max(0, min(clampedOffset + (buttonHeight - innerPadding), geometry.size.width - innerPadding))
-            let textProgress = offset / maxOffset
+            let textProgress = clampedOffset / maxOffset
             let halfWidth = geometry.size.width / 2
 
             ZStack(alignment: .leading) {
@@ -74,13 +74,13 @@ struct SwipeButton: View {
                                     .resizable()
                                     .frame(width: 24, height: 24)
                                     .foregroundColor(.gray7)
-                                    .opacity(isComplete ? 0 : Double(1.0 - (offset / halfWidth)))
+                                    .opacity(isComplete ? 0 : Double(1.0 - (clampedOffset / halfWidth)))
 
                                 Image("check-mark")
                                     .resizable()
                                     .frame(width: 32, height: 32)
                                     .foregroundColor(.gray7)
-                                    .opacity(isComplete ? 1 : Double(max(0, (offset - halfWidth) / halfWidth)))
+                                    .opacity(isComplete ? 1 : Double(max(0, (clampedOffset - halfWidth) / halfWidth)))
                             }
                         }
                     )
diff --git a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
index f33a1e38c..b07e17598 100644
--- a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
+++ b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
@@ -735,6 +735,6 @@ private extension PaykitUsdtPaymentService.Receipt {
         let key = !verified ? "wallet__payment_request_status_pending" :
             underpaid ? "wallet__payment_request_underpaid" :
             afterExpiry ? "wallet__payment_request_after_expiry" : "wallet__payment_request_payment_verified"
-        return t(key) + " · " + amount.value + " USDT"
+        return t(key) + " · " + usdtOverviewAmount(amount.atomic) + " USDT"
     }
 }
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index b21e8d5b0..57c86b6c7 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -308,7 +308,8 @@ struct SendConfirmationView: View {
                 if let request = oneOffPaymentRequest {
                     PaymentRequestSummary(
                         contactName: contactPaymentContact?.displayName ?? PubkyPublicKeyFormat.displayTruncated(request.counterparty),
-                        note: oneOffPaymentRequestNote
+                        note: oneOffPaymentRequestNote,
+                        accentColor: accentColor
                     )
                     .padding(.bottom, 16)
                 }
diff --git a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
index cd28e5aea..478d8c97c 100644
--- a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
+++ b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
@@ -45,16 +45,16 @@ struct ReceivedTx: View {
                     if let amount = config.details.usdtAmount {
                         UsdtAmountHeader(amount: usdtFormatAmount(amount: amount), displayAmount: usdtOverviewAmount(amount))
                             .accessibilityIdentifier("ReceivedTransaction")
+                            .contentShape(Rectangle())
+                            .onTapGesture { showUsdtDetails() }
                     } else {
                         MoneyStack(sats: Int(config.details.sats), showSymbol: true, testIdPrefix: "ReceivedTransaction")
                     }
                     Spacer()
                     HStack(spacing: 16) {
-                        if let transferId = config.details.usdtTransferId {
-                            CustomButton(title: t("wallet__send_details"), variant: .secondary) {
-                                sheets.hideSheet()
-                                navigation.navigate(.usdtActivity(transferId: transferId))
-                            }.accessibilityIdentifier("ReceivedTransactionDetails")
+                        if config.details.usdtTransferId != nil {
+                            CustomButton(title: t("wallet__send_details"), variant: .secondary, action: showUsdtDetails)
+                                .accessibilityIdentifier("ReceivedTransactionDetails")
                         }
                         CustomButton(title: buttonText) { sheets.hideSheet() }
                             .accessibilityIdentifier("ReceivedTransactionButton")
@@ -64,6 +64,12 @@ struct ReceivedTx: View {
             }
         }
     }
+
+    private func showUsdtDetails() {
+        guard let transferId = config.details.usdtTransferId else { return }
+        sheets.hideSheet()
+        navigation.navigate(.usdtActivity(transferId: transferId))
+    }
 }
 
 #Preview {
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index c6400c515..cdb1fcd95 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -113,7 +113,10 @@ struct UsdtDepositHistoryView: View {
     private func detail(_ detail: UsdtDepositDetail) -> some View {
         VStack(alignment: .leading, spacing: 16) {
             if detail.deposit.asset == "USDT" {
-                UsdtAmountHeader(amount: detail.deposit.amount.map { usdtFormatAmount(amount: $0) } ?? "—", hideBalance: settings.hideBalance)
+                UsdtAmountHeader(
+                    amount: detail.deposit.amount.map { usdtFormatAmount(amount: $0) } ?? "—",
+                    displayAmount: detail.deposit.amount.map { usdtOverviewAmount($0) }, hideBalance: settings.hideBalance
+                )
             } else {
                 BodySSBText(detail.deposit.asset + " · " + detail.deposit.network.uppercased())
             }
@@ -148,7 +151,7 @@ struct UsdtDepositHistoryView: View {
     }
 
     private func amount(_ value: UInt64?) -> String {
-        (settings.hideBalance ? " • • • • •" : value.map { usdtFormatAmount(amount: $0) } ?? "—") + " USDT"
+        (settings.hideBalance ? " • • • • •" : value.map { usdtOverviewAmount($0) } ?? "—") + " USDT"
     }
 
     private func loadPage(_ offset: UInt32) async {
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index 0479918eb..0336ca4ad 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -113,7 +113,7 @@ struct UsdtReceiveView: View {
             page = item == nil || deposit != nil ? .address : .amount
         } label: {
             HStack(spacing: 16) {
-                Image("tether").resizable().frame(width: 40, height: 40)
+                Image("tether-circle").resizable().scaledToFit().frame(width: 40, height: 40)
                 BodyMSBText(item?.label ?? "Arbitrum One")
                 if item == nil { BodySText(t("common__default"), textColor: .textSecondary) }
                 Spacer()
@@ -144,7 +144,7 @@ struct UsdtReceiveView: View {
 
     private func feeEstimate(_ deposit: UsdtDepositAddress) -> some View {
         VStack(alignment: .leading, spacing: 24) {
-            UsdtAmountHeader(amount: usdtFormatAmount(amount: deposit.amount))
+            UsdtAmountHeader(amount: usdtFormatAmount(amount: deposit.amount), displayAmount: usdtOverviewAmount(deposit.amount))
             BodyMText(t("usdt__deposit_fee_note"), textColor: .textSecondary)
             VStack(alignment: .leading, spacing: 24) {
                 feeRow(
@@ -161,7 +161,7 @@ struct UsdtReceiveView: View {
 
     private func feeRow(_ title: String, amount: UInt64?) -> some View {
         SendSectionView(title.uppercased(), dividerSpacing: 24) {
-            BodyMSBText("<accent>± $</accent> " + (amount.map { usdtFormatAmount(amount: $0) } ?? "—"), accentColor: .textSecondary)
+            BodyMSBText("<accent>± $</accent> " + (amount.map { usdtOverviewAmount($0) } ?? "—"), accentColor: .textSecondary)
         }
     }
 }
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 16774cf00..906f6b07b 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -320,10 +320,10 @@ struct UsdtSendView: View {
                             if let requestNote { PaymentRequestInvoiceNote(note: requestNote).padding(.top, 16) }
                         } else {
                             if paymentRequest != nil {
-                                PaymentRequestSummary(contactName: contactName, note: requestNote).padding(.bottom, 16)
+                                PaymentRequestSummary(contactName: contactName, note: requestNote, accentColor: .usdtAccent).padding(.bottom, 16)
                             }
                             Spacer(minLength: 0)
-                            PaymentReviewIllustration(swipeProgress: swipeProgress, maximumHeight: 192)
+                            PaymentReviewIllustration(swipeProgress: busy || paymentComplete ? 1 : swipeProgress, maximumHeight: 192)
                                 .padding(.top, 16).frame(height: 256)
                         }
                         if quote.destination != .arbitrum { bridgeCosts(quote).padding(.top, 16) }
@@ -388,14 +388,14 @@ struct UsdtSendView: View {
     private func bridgeCosts(_ quote: UsdtQuote) -> some View {
         VStack(alignment: .leading, spacing: 16) {
             SendSectionView(t(quote.bridgeProvider == .orchestra ? "usdt__expected_amount" : "usdt__recipient_gets")) {
-                BodySSBText(usdtFormatAmount(amount: quote.receivedAmount) + " USDT")
+                BodySSBText(usdtOverviewAmount(quote.receivedAmount) + " USDT")
             }
             if quote.bridgeProvider == .orchestra {
                 SendSectionView(t("usdt__bridge_deducted_fee")) {
-                    BodySSBText(usdtFormatAmount(amount: quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
+                    BodySSBText(usdtOverviewAmount(quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
                 }
             }
-            SendSectionView(t("usdt__maximum_total")) { BodySSBText(usdtFormatAmount(amount: quote.amount + quote.maximumFee) + " USDT") }
+            SendSectionView(t("usdt__maximum_total")) { BodySSBText(usdtOverviewAmount(quote.amount + quote.maximumFee) + " USDT") }
         }
     }
 
diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index 8360d05a2..b7db11213 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -92,3 +92,7 @@ Reference: [USDT designs](https://www.figma.com/design/ltqvnKiejWj0JQiqtDf2JJ/Bi
 - [ ] Back out of an unprepared network and verify the displayed network always matches the QR. Return to Arbitrum and verify its original wallet address.
 - [ ] With a controlled Bitcoin invoice-refresh failure, open USDT Receive and select Savings or Spending. Verify the error offers Try Again instead of remaining on a spinner. Restore the backend and retry; verify the fresh Bitcoin QR appears without the previous amount or note.
 - [ ] With an authorized incoming transfer or an explicitly identified fixture, verify teal receive confetti, Details and OK; Details opens that transfer.
+- [ ] With an authorized send or an explicitly identified fixture, check the swipe after warning and PIN prompts: loading and the completed checkmark stay at the right end, the swipe label is hidden, and confirmation keeps its side spacing until the success screen appears.
+- [ ] Verify bridge review, estimated fees and deposit history round displayed amounts to cents without changing the exact payment, QR or support-export values. Check a nonzero sub-cent value displays <0.01.
+- [ ] Open a payment-request review and verify From and For icons use the selected payment method’s color: orange for Savings, purple for Spending and teal for USDT.
+- [ ] On a received USDT celebration with available details, tap the amount and verify it opens the same activity as Details.
diff --git a/journeys/usdt-receive-amount-and-units.xml b/journeys/usdt-receive-amount-and-units.xml
index 7b07bdafe..7bd339618 100644
--- a/journeys/usdt-receive-amount-and-units.xml
+++ b/journeys/usdt-receive-amount-and-units.xml
@@ -7,7 +7,7 @@
     <action>Tap Edit. Enter 3.5. Verify the dollar amount and BTC equivalent are displayed, there is no input-unit toggle, the keypad follows the divider, and Continue stays at the bottom without overlap.</action>
     <action>Continue to the QR. Verify it requests the Arbitrum USDT token, the wallet address and uint256=3500000, never Bitcoin.</action>
     <action>Tap Edit, enter a different amount and tap Back. Verify the QR still requests uint256=3500000.</action>
-    <action>Open Share and verify the shared text includes Network: Arbitrum One and the exact payment URI. Cancel sharing. Open Show Details. Verify Network: Arbitrum One, the same Arbitrum address and teal Copy control. Verify Share includes the same network and payment URI, while Copy contains only the address. Open Network and verify Arbitrum is marked Default and all enabled bridge networks remain available. Return to the QR.</action>
+    <action>Open Share and verify the shared text includes Network: Arbitrum One and the exact payment URI. Cancel sharing. Open Show Details. Verify Network: Arbitrum One, the same Arbitrum address and teal Copy control. Verify Share includes the same network and payment URI, while Copy contains only the address. Open Network and verify Arbitrum is marked Default and all enabled bridge networks remain available, with circular USDT icons. Return to the QR.</action>
     <action>Select Savings. Verify Receive Bitcoin and a Bitcoin QR. Select USDT and verify Receive Dollars and the Arbitrum USDT QR.</action>
     <action>Close Receive and return Home. Open a USDT activity row, then Show All. Verify USDT details and mixed activity remain reachable.</action>
   </actions>
diff --git a/journeys/usdt-send-review-and-details.xml b/journeys/usdt-send-review-and-details.xml
index 3f09de308..465a98e3f 100644
--- a/journeys/usdt-send-review-and-details.xml
+++ b/journeys/usdt-send-review-and-details.xml
@@ -5,7 +5,7 @@
     <action>Open the network pill and select another EVM network. Verify the amount and valid recipient remain. Change to Solana with an EVM recipient and verify recipient entry is required. Enter an owned plain Solana address and verify the previous amount remains. Return to Arbitrum, enter the owned EVM address and verify the amount still remains.</action>
     <action>From recipient entry with another network selected, paste an explicit Arbitrum USDT URI. Verify the selected network becomes Arbitrum and the link amount is retained. A plain 0x address preserves the selected network.</action>
     <action>Tap MAX. Verify it fills a positive amount below the balance and remains on Amount. Continue and verify the payment plus maximum fee fits within the balance. Back out without swiping.</action>
-    <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note above the swipe control. Hide Details restores the illustration. Cancel without paying.</action>
+    <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note above the swipe control. Displayed amounts round to cents; nonzero values below one cent show &lt;0.01. Hide Details restores the illustration. Cancel without paying.</action>
     <action>Open an existing sent USDT activity. Verify the heading is Sent USDT, the signed amount includes the actual fee, and summary rows show Status/Network, Date/Time and Payment/Fee with teal icons. Open Details and verify transaction ID, known sender, recipient and source/destination networks; Open Block Explorer stays at the bottom.</action>
     <action>Open an existing received activity. Verify Received USDT and a positive amount. Verify Details shows the verified sender when available and does not invent one for older unknown records. Check pending, failed and transferring rows use their matching icons, and transferring shows its destination.</action>
     <action>Prepare a contact payment that accepts multiple payment methods. Open the payment-source button and verify the balance menu shows Savings, Spending, any paired hardware wallet and USDT. Unsupported methods are disabled. Select a supported method and verify its label, available balance and payable amount update. Cancel without paying.</action>

From f7e8240d9bff32259897937f000400488860d1c8 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 14:54:37 -0500
Subject: [PATCH 26/62] fix(usdt): retain queued sends and clarify deposit
 history

---
 Bitkit/Managers/UsdtWalletManager.swift       | 25 +++++++++++--------
 .../Wallets/UsdtDepositHistoryView.swift      |  9 +------
 Bitkit/Views/Wallets/UsdtSendView.swift       |  8 ++++--
 BitkitTests/UsdtWalletManagerTests.swift      |  1 -
 journeys/hardware-wallet/send-onchain.xml     |  1 +
 journeys/usdt-bridge-support.xml              |  4 +--
 journeys/usdt-payment-links-and-scans.xml     |  2 +-
 7 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index 4afc8922c..dfda9efb6 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -153,17 +153,22 @@ final class UsdtWalletManager {
         try beginOperation()
         defer { finishOperation() }
         let wallet = try await wallet()
-        let transfer = try await ServiceQueue.background(.core, wrapErrors: false) {
-            guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
-            let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
-            try await beforeSubmission()
-            return try await wallet.sendWithDeadline(
-                quoteId: quote.id, mnemonic: mnemonic, passphrase: passphrase,
-                submissionDeadline: submissionDeadline?.timestamp
-            )
+        do {
+            let transfer = try await ServiceQueue.background(.core, wrapErrors: false) {
+                guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
+                let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
+                try await beforeSubmission()
+                return try await wallet.sendWithDeadline(
+                    quoteId: quote.id, mnemonic: mnemonic, passphrase: passphrase,
+                    submissionDeadline: submissionDeadline?.timestamp
+                )
+            }
+            transfers.removeAll { $0.id == transfer.id }
+            transfers.insert(transfer, at: 0)
+        } catch {
+            if let saved = try? await ServiceQueue.background(.core, wrapErrors: false, { try wallet.history() }) { transfers = saved }
+            throw error
         }
-        transfers.removeAll { $0.id == transfer.id }
-        transfers.insert(transfer, at: 0)
     }
 
     func paymentProof(quoteId: String, binding: UsdtPaymentProofBinding) async throws -> UsdtPaymentProof? {
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index cdb1fcd95..6e3b050ed 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -29,14 +29,13 @@ struct UsdtDepositHistoryView: View {
                     VStack(alignment: .leading, spacing: 16) {
                         if let selected { detail(selected) }
                         else {
-                            BodySText(t("usdt__deposit_status_note"), textColor: .textSecondary)
                             if deposits.isEmpty { BodySText(t("usdt__deposit_empty"), textColor: .textSecondary) }
                             ForEach(deposits, id: \.id) { deposit in
                                 Button {
                                     Task { await loadDetail(deposit.id) }
                                 } label: {
                                     ActivityRowContainer {
-                                        ActivityRowContent(title: deposit.network.uppercased(), subtitle: deposit.statusText) {
+                                        ActivityRowContent(title: deposit.network.uppercased(), subtitle: t("wallet__send_details")) {
                                             CircularIcon(
                                                 icon: "arrow-down",
                                                 iconColor: .usdtAccent,
@@ -239,12 +238,6 @@ private struct RefundApproval {
     let address: String
 }
 
-extension UsdtDeposit {
-    var statusText: String {
-        depositStatusText(status, code: code)
-    }
-}
-
 extension UsdtDepositDetail {
     var statusCode: String? {
         if let order { return order.code }
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 906f6b07b..1cb386479 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -539,8 +539,12 @@ struct UsdtSendView: View {
             submitted = true
             Task { await PaykitUsdtPaymentService.shared.reconcile(wallet: usdt) }
         } catch is CancellationError {} catch {
-            self.error = UsdtWalletManager.message(for: error)
-            self.quote = nil
+            if usdt.transfers.contains(where: { $0.id == quote.id }) {
+                submitted = true
+            } else {
+                self.error = UsdtWalletManager.message(for: error)
+                self.quote = nil
+            }
             Logger.warn("Failed to send USDT: \(UsdtWalletManager.message(for: error))", context: "UsdtSendView")
         }
     }
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 7c8693c05..df53b5362 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -86,7 +86,6 @@ final class UsdtWalletManagerTests: XCTestCase {
             let deposit = UsdtDeposit(id: "deposit", network: "bsc", asset: "USDT", amount: 100, sourceTx: "tx", status: status,
                                       code: code, refundTx: nil)
             let order = UsdtDepositOrder(status: status, amountIn: 100, amountOut: 90, destinationTx: nil, refundTx: nil, code: code)
-            XCTAssertEqual(deposit.statusText, t(key), status)
             for linkedOrder in [nil, order] {
                 let detail = UsdtDepositDetail(deposit: deposit, order: linkedOrder)
                 XCTAssertEqual(detail.statusText, t(key), status)
diff --git a/journeys/hardware-wallet/send-onchain.xml b/journeys/hardware-wallet/send-onchain.xml
index 6500f6bc6..cc60b9e27 100644
--- a/journeys/hardware-wallet/send-onchain.xml
+++ b/journeys/hardware-wallet/send-onchain.xml
@@ -16,6 +16,7 @@
     <action>Verify the Send sheet shows the recipient options, then tap "Enter Manually" (id "RecipientManual")</action>
     <action>Type the destination regtest address into the recipient field (id "RecipientInput") and tap Continue (id "AddressContinue")</action>
     <action>Verify the Send amount screen (id "SendAmount") is visible and its available amount (id "AvailableAmount") is greater than 0</action>
+    <action>Tap the funding-source button once, verify the source menu (id "SendFundingSources") opens, then select the paired Trezor row. Wait for balance loading to finish and verify the button shows the paired Trezor name in blue</action>
     <action>Tap the keys "1", "0", "0", "0", "0" (ids "N1", "N0", "N0", "N0", "N0") to enter 10 000 sats and tap Continue (id "ContinueAmount")</action>
     <action>Verify the review screen (id "SendConfirm") shows an amount of 10 000 sats and the paired hardware wallet as the funding source (blue accent)</action>
     <action>Tap "Show Details" (id "SendConfirmToggleDetails") and verify the destination address and a non-zero network fee are listed</action>
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
index 6377f39c7..660193bf5 100644
--- a/journeys/usdt-bridge-support.xml
+++ b/journeys/usdt-bridge-support.xml
@@ -5,8 +5,8 @@
     <action>Tap Details (id "UsdtActivityDetails"), then verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting.</action>
-    <action>Open USDT Receive, then Network and Deposit Activity, and open a deposit.</action>
-    <action>For a refunded deposit, verify both the history row and detail show Refunded, even when an earlier error code is retained. Verify the transaction is labeled Refund transaction in the detail. Verify no pending-refund notice remains after refreshing the completed refund.</action>
+    <action>Open USDT Receive, then Network and Deposit Activity. Verify rows show Details rather than a transfer status, then open a deposit.</action>
+    <action>For a refunded deposit, verify the detail shows Refunded, even when an earlier error code is retained. Verify the transaction is labeled Refund transaction in the detail. Verify no pending-refund notice remains after refreshing the completed refund.</action>
     <action>For a refund in progress, verify Refunding is shown for the provider's pending acknowledgment. A refund requiring operator intervention must still show Needs attention.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard includes the deposit reference, source network and source transaction, plus the current status and any destination or refund transaction.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the receive sheet closes and the report form opens with the deposit details prefilled. Return without submitting or requesting a refund.</action>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index e375236c7..d4bde4a5b 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -1,7 +1,7 @@
 <journey name="usdt payment links and scans">
   <description>Use an onboarded wallet with USDT configured and another owned wallet's Arbitrum receive URI. No payment is submitted. Hardware-wallet send remains Bitcoin-only.</description>
   <actions>
-    <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount or review screen preserves recipient and 0.010001 USDT. Verify no payment occurs without approval.</action>
+    <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount screen preserves the recipient and exact input 0.010001 USDT; the review rounds its displayed value to $0.01. Verify no payment occurs without approval.</action>
     <action>Cancel the send, then reopen the identical URI. Verify the amount or review screen opens again. Cancel and open a different owned recipient and amount, verifying only the new values appear.</action>
     <action>While a USDT contact amount screen or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
     <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>

From 931f51aa83e931c9261a613ae59163e9d3e51f4a Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 14:55:13 -0500
Subject: [PATCH 27/62] docs(usdt): cover retained payments during backup
 outages

---
 Docs/USDT-QA.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index b7db11213..39c2a6821 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -54,6 +54,7 @@ Use disposable wallets and a controlled RPC, bundler and encrypted VSS test envi
 - [ ] Restore that backup into a disposable wallet on the other platform using the same test seed.
 - [ ] Refresh the restored wallet. Verify it reconciles or retries the same signed operation and does not create a second payment.
 - [ ] Mine the test operation and refresh. Verify a single activity entry, the original request attribution, and successful proof delivery.
+- [ ] Make VSS unavailable before approving one payment. Verify no bundler submission. If core has recorded the operation, the send screen must track that payment without offering another Continue or approval. Otherwise it must show the backup error. Restore VSS and verify only the original approved operation continues, with one activity entry.
 - [ ] Repeat restore with an unavailable local storage dependency. Verify restore remains incomplete and no replacement wallet backup is uploaded.
 
 ## Paykit quoted reviews and history

From b35dd082406d97856d1dada245f8266de4273365 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 16:01:02 -0500
Subject: [PATCH 28/62] fix: keep maximum usdt bridge debit visible

---
 Bitkit/Views/Wallets/UsdtSendView.swift   | 9 ++++++++-
 BitkitUITests/UsdtWalletUITests.swift     | 4 ++--
 journeys/usdt-send-review-and-details.xml | 1 +
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 1cb386479..a6d07c1f6 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -344,6 +344,14 @@ struct UsdtSendView: View {
                 CaptionText(t(quote.bridgeProvider == .orchestra ? "usdt__bridge_estimate_note" : "usdt__fee_note"))
                     .multilineTextAlignment(.center).frame(maxWidth: .infinity).padding(.bottom, 24)
             }
+            if quote.destination != .arbitrum {
+                SendSectionView(t("usdt__maximum_total")) {
+                    BodySSBText(usdtOverviewAmount(quote.amount + quote.maximumFee) + " USDT")
+                }
+                .accessibilityElement(children: .contain)
+                .accessibilityIdentifier("UsdtMaximumTotal")
+                .padding(.bottom, 16)
+            }
             SwipeButton(
                 title: t("wallet__send_swipe"), accentColor: .usdtAccent, isDisabled: busy,
                 isLoading: busy, isComplete: paymentComplete, swipeProgress: $swipeProgress
@@ -395,7 +403,6 @@ struct UsdtSendView: View {
                     BodySSBText(usdtOverviewAmount(quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
                 }
             }
-            SendSectionView(t("usdt__maximum_total")) { BodySSBText(usdtOverviewAmount(quote.amount + quote.maximumFee) + " USDT") }
         }
     }
 
diff --git a/BitkitUITests/UsdtWalletUITests.swift b/BitkitUITests/UsdtWalletUITests.swift
index a7b98e900..13c351df0 100644
--- a/BitkitUITests/UsdtWalletUITests.swift
+++ b/BitkitUITests/UsdtWalletUITests.swift
@@ -176,11 +176,11 @@ final class UsdtWalletUITests: XCTestCase {
             )
         app.buttons["UsdtRecipientContinue"].tap()
         XCTAssertTrue(app.buttons["N1"].waitForExistence(timeout: 5))
-        XCTAssertTrue(app.staticTexts["1.23"].exists)
+        XCTAssertTrue(app.staticTexts["$ 1.23"].exists)
         for digit in 4 ... 8 {
             app.buttons["N\(digit)"].tap()
         }
-        XCTAssertTrue(app.staticTexts["1.234567"].exists)
+        XCTAssertTrue(app.staticTexts["$ 1.234567"].exists)
         XCTAssertFalse(app.otherElements["UsdtConfirm"].exists)
         let screenshot = XCTAttachment(screenshot: app.screenshot())
         screenshot.lifetime = .keepAlways
diff --git a/journeys/usdt-send-review-and-details.xml b/journeys/usdt-send-review-and-details.xml
index 465a98e3f..d8e01cc6f 100644
--- a/journeys/usdt-send-review-and-details.xml
+++ b/journeys/usdt-send-review-and-details.xml
@@ -6,6 +6,7 @@
     <action>From recipient entry with another network selected, paste an explicit Arbitrum USDT URI. Verify the selected network becomes Arbitrum and the link amount is retained. A plain 0x address preserves the selected network.</action>
     <action>Tap MAX. Verify it fills a positive amount below the balance and remains on Amount. Continue and verify the payment plus maximum fee fits within the balance. Back out without swiping.</action>
     <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note above the swipe control. Displayed amounts round to cents; nonzero values below one cent show &lt;0.01. Hide Details restores the illustration. Cancel without paying.</action>
+    <action>Prepare a cross-network payment and continue. Without scrolling, verify Maximum total debit (id "UsdtMaximumTotal") and its value are fully visible above Swipe To Pay. Show Details and verify the maximum remains visible. Cancel without paying.</action>
     <action>Open an existing sent USDT activity. Verify the heading is Sent USDT, the signed amount includes the actual fee, and summary rows show Status/Network, Date/Time and Payment/Fee with teal icons. Open Details and verify transaction ID, known sender, recipient and source/destination networks; Open Block Explorer stays at the bottom.</action>
     <action>Open an existing received activity. Verify Received USDT and a positive amount. Verify Details shows the verified sender when available and does not invent one for older unknown records. Check pending, failed and transferring rows use their matching icons, and transferring shows its destination.</action>
     <action>Prepare a contact payment that accepts multiple payment methods. Open the payment-source button and verify the balance menu shows Savings, Spending, any paired hardware wallet and USDT. Unsupported methods are disabled. Select a supported method and verify its label, available balance and payable amount update. Cancel without paying.</action>

From 2bad3719a199b79c5b95ce0815fe5d97c3c2b3ec Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 16:28:14 -0500
Subject: [PATCH 29/62] fix: preserve usdt payment links and clarify self sends

---
 Bitkit/Managers/UsdtWalletManager.swift       | 11 ++++++++
 .../Localization/en.lproj/Localizable.strings |  1 +
 Bitkit/ViewModels/AppViewModel.swift          |  8 ++++++
 .../Wallets/Send/SendEnterManuallyView.swift  |  9 +++++++
 Bitkit/Views/Wallets/UsdtReceiveView.swift    |  2 +-
 BitkitTests/UsdtPaymentLinkTests.swift        | 16 ++++++++++++
 BitkitTests/UsdtWalletManagerTests.swift      | 25 +++++++++++++++++++
 journeys/usdt-payment-links-and-scans.xml     |  3 ++-
 journeys/usdt-receive-amount-and-units.xml    |  2 +-
 journeys/usdt-wallet-navigation.xml           |  2 +-
 10 files changed, 75 insertions(+), 4 deletions(-)

diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index dfda9efb6..cc83c988d 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -3,6 +3,10 @@ import Combine
 import Foundation
 import Observation
 
+enum UsdtWalletError: Error {
+    case selfSend
+}
+
 @Observable @MainActor
 final class UsdtWalletManager {
     private nonisolated(unsafe) static let backupStateChanged = PassthroughSubject<Void, Never>()
@@ -105,6 +109,9 @@ final class UsdtWalletManager {
         defer { finishOperation() }
         let value = try usdtParseAmount(value: amount.replacingOccurrences(of: Locale.current.decimalSeparator ?? ".", with: "."))
         let wallet = try await wallet()
+        if recipient.trimmingCharacters(in: .whitespacesAndNewlines).caseInsensitiveCompare(wallet.receiveAddress()) == .orderedSame {
+            throw UsdtWalletError.selfSend
+        }
         return try await wallet.quoteTransfer(recipient: recipient, amount: value, destination: destination)
     }
 
@@ -112,6 +119,9 @@ final class UsdtWalletManager {
         try beginOperation()
         defer { finishOperation() }
         let wallet = try await wallet()
+        if recipient.trimmingCharacters(in: .whitespacesAndNewlines).caseInsensitiveCompare(wallet.receiveAddress()) == .orderedSame {
+            throw UsdtWalletError.selfSend
+        }
         return try await wallet.quoteMaxTransfer(recipient: recipient, destination: destination)
     }
 
@@ -360,6 +370,7 @@ final class UsdtWalletManager {
     }
 
     static func message(for error: Error) -> String {
+        if error is UsdtWalletError { return t("usdt__error_self_send") }
         guard let error = error as? UsdtError else { return t("usdt__error_network") }
         switch error {
         case .NotConfigured: return t("usdt__error_configuration")
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 174724ac3..5752e4469 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1829,6 +1829,7 @@
 "usdt__error_rate_limit" = "Too many requests. Please try again shortly.";
 "usdt__error_rejected" = "The USDT network rejected the request. Please try again.";
 "usdt__error_response" = "The USDT service returned an invalid response. Please try again later.";
+"usdt__error_self_send" = "You can’t send USDT to your own address.";
 "usdt__error_storage" = "Could not access USDT wallet data. Please try again.";
 "usdt__error_wallet" = "Could not access your USDT wallet. Reopen Bitkit and try again.";
 "usdt__error_route" = "This network is currently unavailable.";
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index f6326583d..73bd83a7a 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -1270,6 +1270,14 @@ extension AppViewModel {
             return
         }
 
+        if normalized.lowercased().hasPrefix("ethereum:") {
+            let valid = (try? resolveUsdtPaymentRoute(input: normalized)) != nil
+            manualEntryValidationResult = valid ? .valid : .invalid
+            isManualEntryInputValid = valid
+            if !valid { showValidationErrorToast(for: .invalid) }
+            return
+        }
+
         // Try to decode the invoice
         guard let decodedData = try? await decode(invoice: normalized) else {
             guard currentSequence == manualEntryValidationSequence else { return }
diff --git a/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift b/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
index 194f5141b..239c4df52 100644
--- a/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
+++ b/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
@@ -9,6 +9,7 @@ struct SendEnterManuallyView: View {
     @EnvironmentObject var navigation: NavigationViewModel
     @EnvironmentObject var pubkyProfile: PubkyProfileManager
     @EnvironmentObject var sheets: SheetViewModel
+    @EnvironmentObject var scanner: ScannerManager
     @Environment(HwWalletManager.self) private var hwWalletManager
 
     @Binding var navigationPath: [SendRoute]
@@ -78,6 +79,13 @@ struct SendEnterManuallyView: View {
             return
         }
 
+        if uri.lowercased().hasPrefix("ethereum:") {
+            await scanner.handleSendScan(uri, scope: hwSend.isActive ? .onchainPayments : .unrestricted) { route in
+                if let route { navigationPath.append(route) }
+            }
+            return
+        }
+
         do {
             wallet.resetSendState(speed: settings.defaultTransactionSpeed)
 
@@ -117,6 +125,7 @@ struct SendEnterManuallyView: View {
         .environmentObject(NavigationViewModel())
         .environmentObject(PubkyProfileManager())
         .environmentObject(SheetViewModel())
+        .environmentObject(ScannerManager())
         .environment(HwWalletManager())
         .preferredColorScheme(.dark)
 }
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index 0336ca4ad..a245a2110 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -198,7 +198,7 @@ struct UsdtReceiveAddressContent: View {
                     .accessibilityIdentifier("UsdtReceiveAddress")
                 } else {
                     QrArea(uri: uri, imageAsset: "tether-circle", accentColor: .usdtAccent,
-                           copyValue: address, shareText: shareText, onEdit: onEdit)
+                           copyValue: uri, shareText: shareText, onEdit: onEdit)
                 }
             } else if let error { BodySText(error, textColor: .brandAccent) }
             else { ProgressView() }
diff --git a/BitkitTests/UsdtPaymentLinkTests.swift b/BitkitTests/UsdtPaymentLinkTests.swift
index 604b7d023..9161762a7 100644
--- a/BitkitTests/UsdtPaymentLinkTests.swift
+++ b/BitkitTests/UsdtPaymentLinkTests.swift
@@ -1,4 +1,5 @@
 @testable import Bitkit
+import Combine
 import XCTest
 
 final class UsdtPaymentLinkTests: XCTestCase {
@@ -28,6 +29,21 @@ final class UsdtPaymentLinkTests: XCTestCase {
         XCTAssertThrowsError(try resolveUsdtPaymentRoute(input: uri, isEnabled: false))
     }
 
+    @MainActor
+    func testManualEntryAcceptsUsdtUriAndRejectsWrongChain() async {
+        let app = AppViewModel()
+        for (input, valid) in [(uri + "&uint256=10001", true), (uri.replacingOccurrences(of: "@42161", with: "@1"), false)] {
+            let validated = expectation(description: "Manual entry validated")
+            let observation = app.$isManualEntryInputValid.dropFirst().sink { actual in
+                XCTAssertEqual(actual, valid)
+                validated.fulfill()
+            }
+            app.validateManualEntryInput(input, savingsBalanceSats: 0, spendingBalanceSats: 0)
+            await fulfillment(of: [validated], timeout: 5)
+            observation.cancel()
+        }
+    }
+
     func testOtherInputsRemainWithTheirExistingScanner() throws {
         for input in [recipient, "bitcoin:bcrt1qexample", "lightning:lnbcrt1example", "pubkyexample", ""] {
             XCTAssertNil(try resolveUsdtPaymentRoute(input: input, isEnabled: true), input)
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index df53b5362..5216c72e2 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -4,6 +4,31 @@ import XCTest
 
 @MainActor
 final class UsdtWalletManagerTests: XCTestCase {
+    func testOwnAddressHasSpecificErrorForExactAndMaximumSends() async throws {
+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: directory) }
+        let manager = UsdtWalletManager(storageDirectory: directory, loadCredentials: {
+            ("test test test test test test test test test test test junk", nil)
+        })
+        _ = try await manager.paymentEndpoint()
+        let recipient = " \(manager.address.lowercased()) "
+        do {
+            _ = try await manager.quote(recipient: recipient, amount: "1", destination: .arbitrum)
+            XCTFail("Self-send must be rejected before requesting a quote")
+        } catch {
+            XCTAssertEqual(error as? UsdtWalletError, .selfSend)
+            XCTAssertEqual(UsdtWalletManager.message(for: error), t("usdt__error_self_send"))
+        }
+        do {
+            _ = try await manager.quoteMaximum(recipient: recipient, destination: .arbitrum)
+            XCTFail("Maximum self-send must be rejected before requesting a quote")
+        } catch {
+            XCTAssertEqual(error as? UsdtWalletError, .selfSend)
+        }
+        XCTAssertEqual(UsdtWalletManager.message(for: UsdtError.InvalidAddress), t("usdt__error_address"))
+    }
+
     func testNativeSubmissionRejectsAnExpiredPreciseDeadlineWithoutCreatingATransfer() async throws {
         let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index d4bde4a5b..196154a8d 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -7,9 +7,10 @@
     <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>
     <action>Cancel the send. Open the same link without uint256. Verify the amount screen opens with no amount and accepts a new amount.</action>
     <action>Cancel the send. From the main scanner, paste or import a QR containing the same amount-bearing URI. Verify it opens the USDT send flow with the same recipient and amount.</action>
-    <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
+    <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, choose Enter Manually, enter the same URI and continue. Verify the USDT recipient and exact amount are preserved. Repeat with a wrong-chain URI and in hardware-wallet Send; verify neither opens a USDT payment. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
     <action>Open or scan variants with the wrong chain, wrong token, duplicate amount and malformed recipient. Verify an error and no payable review. Check an ordinary Bitcoin or Lightning invoice still opens its existing send flow.</action>
     <action>On iOS, open a USDT link while Lightning is stopped but the wallet is ready. Verify it routes without starting Lightning. Open two different USDT links while the main scanner sheet is dismissing; verify an older delayed link cannot replace the review that opened first.</action>
+    <action>Enter this wallet’s own Arbitrum address in USDT Send, enter an amount and continue. Verify the error explicitly says you cannot send USDT to your own address, and no payment is submitted. Repeat with MAX.</action>
     <action>Enter the entire available USDT balance and continue. Verify the fee-collection error explains that the transaction fee could not be paid in USDT and suggests a smaller amount. Reduce the amount, reach review and close without signing.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-receive-amount-and-units.xml b/journeys/usdt-receive-amount-and-units.xml
index 7bd339618..7e083ae68 100644
--- a/journeys/usdt-receive-amount-and-units.xml
+++ b/journeys/usdt-receive-amount-and-units.xml
@@ -7,7 +7,7 @@
     <action>Tap Edit. Enter 3.5. Verify the dollar amount and BTC equivalent are displayed, there is no input-unit toggle, the keypad follows the divider, and Continue stays at the bottom without overlap.</action>
     <action>Continue to the QR. Verify it requests the Arbitrum USDT token, the wallet address and uint256=3500000, never Bitcoin.</action>
     <action>Tap Edit, enter a different amount and tap Back. Verify the QR still requests uint256=3500000.</action>
-    <action>Open Share and verify the shared text includes Network: Arbitrum One and the exact payment URI. Cancel sharing. Open Show Details. Verify Network: Arbitrum One, the same Arbitrum address and teal Copy control. Verify Share includes the same network and payment URI, while Copy contains only the address. Open Network and verify Arbitrum is marked Default and all enabled bridge networks remain available, with circular USDT icons. Return to the QR.</action>
+    <action>Tap Copy on the QR screen and verify the clipboard contains the exact payment URI including uint256=3500000. Open Share and verify the shared text includes Network: Arbitrum One and the exact payment URI. Cancel sharing. Open Show Details. Verify Network: Arbitrum One, the same Arbitrum address and teal Copy control. Verify Share includes the same network and payment URI, while Copy contains only the address. Open Network and verify Arbitrum is marked Default and all enabled bridge networks remain available, with circular USDT icons. Return to the QR.</action>
     <action>Select Savings. Verify Receive Bitcoin and a Bitcoin QR. Select USDT and verify Receive Dollars and the Arbitrum USDT QR.</action>
     <action>Close Receive and return Home. Open a USDT activity row, then Show All. Verify USDT details and mixed activity remain reachable.</action>
   </actions>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index bb8d7c866..c2c0f04df 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -3,7 +3,7 @@
   <actions>
     <action>On Home, verify the Savings/Spending and USDT balance dividers align vertically, including any hardware wallet rows.</action>
     <action>Verify USDT balances and activity amounts show at most two decimals; a nonzero amount below one cent shows &lt;0.01. Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet, with its Tether coin illustration anchored at the upper right.</action>
-    <action>Open Receive. Verify the network is Arbitrum One. Open details, verify the address starts with 0x, and verify Copy and the QR show the same address.</action>
+    <action>Open Receive. Verify the network is Arbitrum One. Open details, verify the address starts with 0x, and verify Details Copy contains only the address. Return to the QR and verify Copy contains the full USDT payment URI including the network and token.</action>
     <action>Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing.</action>
     <action>Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote.</action>
     <action>Set an amount and note in Bitcoin Receive, then close it. Open a fresh USDT Receive sheet and switch to Savings and Spending. Verify Savings shows a fresh Bitcoin QR with no previous amount or note. Spending shows a fresh Lightning QR when receive liquidity is available; an unfunded wallet shows the Spending receive setup instead. Verify hardware-wallet receive remains available when paired.</action>

From 4e2e5f9f7e5661f693c5306efce1632690cfaa2d Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 16:53:51 -0500
Subject: [PATCH 30/62] fix: explain insufficient bridge amounts using Core rc5

---
 Bitkit.xcodeproj/project.pbxproj                          | 2 +-
 .../xcshareddata/swiftpm/Package.resolved                 | 4 ++--
 Bitkit/Managers/UsdtWalletManager.swift                   | 1 +
 .../Resources/Localization/en.lproj/Localizable.strings   | 1 +
 BitkitTests/UsdtWalletManagerTests.swift                  | 8 ++++++++
 journeys/usdt-bridge-amount-errors.xml                    | 8 ++++++++
 6 files changed, 21 insertions(+), 3 deletions(-)
 create mode 100644 journeys/usdt-bridge-amount-errors.xml

diff --git a/Bitkit.xcodeproj/project.pbxproj b/Bitkit.xcodeproj/project.pbxproj
index cae18c31b..1056d1013 100644
--- a/Bitkit.xcodeproj/project.pbxproj
+++ b/Bitkit.xcodeproj/project.pbxproj
@@ -1234,7 +1234,7 @@
 			repositoryURL = "https://github.com/synonymdev/bitkit-core";
 			requirement = {
 				kind = exactVersion;
-				version = "0.8.0-rc4";
+				version = "0.8.0-rc5";
 			};
 		};
 		96E493A22C942FD1000E8BC2 /* XCRemoteSwiftPackageReference "swift-secp256k1" */ = {
diff --git a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
index e4cf80709..65771e26f 100644
--- a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
+++ b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -6,8 +6,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/synonymdev/bitkit-core",
       "state" : {
-        "revision" : "1ebbd776d83acd1748cd9b32375d5aa420ebb4aa",
-        "version" : "0.8.0-rc4"
+        "revision" : "f5972d655a9f9a3807df03899f79339ddc68ae83",
+        "version" : "0.8.0-rc5"
       }
     },
     {
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index cc83c988d..618f73aa2 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -375,6 +375,7 @@ final class UsdtWalletManager {
         switch error {
         case .NotConfigured: return t("usdt__error_configuration")
         case .InvalidAmount: return t("usdt__error_amount")
+        case .BridgeAmountTooSmall: return t("usdt__error_bridge_amount")
         case .InvalidAddress, .WrongNetwork: return t("usdt__error_address")
         case .InsufficientBalance: return t("usdt__error_balance")
         case .QuoteExpired: return t("usdt__error_expired")
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 5752e4469..8fa276579 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1819,6 +1819,7 @@
 "usdt__error_amount" = "Enter a valid amount with up to 6 decimal places.";
 "usdt__error_backup" = "Unable to back up this payment. It will be retried when backup is available.";
 "usdt__error_balance" = "Not enough USDT to cover the amount and fees.";
+"usdt__error_bridge_amount" = "Amount too small to cover bridge costs. Try a larger amount.";
 "usdt__error_clock" = "Set your device date and time automatically, then try again.";
 "usdt__error_configuration" = "USDT is currently unavailable. Please try again later.";
 "usdt__error_delegation" = "This address uses another wallet’s smart account. Disable its smart account mode there before sending with Bitkit.";
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 5216c72e2..5ba6db5cd 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -4,6 +4,14 @@ import XCTest
 
 @MainActor
 final class UsdtWalletManagerTests: XCTestCase {
+    func testBridgeCostErrorsAskForALargerAmountWithoutInventingAMinimum() {
+        let error = UsdtError.BridgeAmountTooSmall
+        XCTAssertEqual(UsdtWalletManager.message(for: error), t("usdt__error_bridge_amount"))
+        XCTAssertEqual(usdtDepositAmountMessage(error, amount: "3.5"), t("usdt__error_bridge_amount"))
+        XCTAssertEqual(usdtDepositAmountMessage(UsdtError.DepositAmountOutOfRange(minUsdCents: "200", maxUsdCents: nil), amount: "1"),
+                       t("usdt__deposit_minimum", variables: ["amount": "200".usdCents]))
+    }
+
     func testOwnAddressHasSpecificErrorForExactAndMaximumSends() async throws {
         let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
diff --git a/journeys/usdt-bridge-amount-errors.xml b/journeys/usdt-bridge-amount-errors.xml
new file mode 100644
index 000000000..bb456a55b
--- /dev/null
+++ b/journeys/usdt-bridge-amount-errors.xml
@@ -0,0 +1,8 @@
+<journey name="usdt bridge amount errors">
+  <description>Use an onboarded USDT wallet and a gateway fixture that rejects outbound quotes and inbound estimates with xchain_amount_too_small. No payment is submitted. The error describes live bridge costs rather than inventing a fixed network minimum.</description>
+  <actions>
+    <action>Open USDT Send, select Tron and enter a valid external Tron address. Enter 3.5 USDT and continue. Verify the amount screen remains visible, payment review does not open, and the error says Amount too small to cover bridge costs. Try a larger amount.</action>
+    <action>Return to USDT Receive, select Tron and enter an expected deposit amount of 3.5 USDT. Continue. Verify the same actionable error is shown and no deposit QR is presented. Verify the error does not claim that the provider's advertised minimum guarantees acceptance.</action>
+    <action>Change the fixture to provide a valid quote or estimate, increase the amount and continue. Verify the error clears and the flow advances. Stop before approving a payment or sharing a deposit request.</action>
+  </actions>
+</journey>

From b216ae3fb8c18699b50599a12fde1d6252771297 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 17:25:41 -0500
Subject: [PATCH 31/62] fix: show active incoming conversions as pending

---
 Bitkit/Views/Wallets/UsdtDepositHistoryView.swift | 2 +-
 BitkitTests/UsdtWalletManagerTests.swift          | 6 ++++++
 journeys/usdt-bridge-support.xml                  | 1 +
 3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index 6e3b050ed..0c5e2eecc 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -255,7 +255,7 @@ private func depositStatusText(_ status: String, code: String?) -> String {
     case "refunded": t("usdt__deposit_refunded")
     case "refunding", "refund_requested":
         code == nil || code == "standing_refund_pending" ? t("usdt__deposit_refunding") : t("usdt__deposit_needs_attention")
-    case "pending", "processing":
+    case "pending", "processing", "funded", "confirming", "swapping", "bridging", "delivering":
         code == nil ? t("usdt__pending") : t("usdt__deposit_needs_attention")
     default: t("usdt__deposit_needs_attention")
     }
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 5ba6db5cd..97e2e3518 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -112,6 +112,12 @@ final class UsdtWalletManagerTests: XCTestCase {
             ("refunding", "standing_refund_pending", "usdt__deposit_refunding"),
             ("refund_requested", "standing_tron_refund_requires_operator", "usdt__deposit_needs_attention"),
             ("refunding", "refund_error", "usdt__deposit_needs_attention"),
+            ("funded", nil, "usdt__pending"),
+            ("confirming", nil, "usdt__pending"),
+            ("swapping", nil, "usdt__pending"),
+            ("bridging", nil, "usdt__pending"),
+            ("delivering", nil, "usdt__pending"),
+            ("swapping", "order_error", "usdt__deposit_needs_attention"),
             ("pending", "standing_route_unavailable", "usdt__deposit_needs_attention"),
             ("below_minimum", "xchain_amount_too_small", "usdt__deposit_needs_attention"),
         ]
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
index 660193bf5..86bfde795 100644
--- a/journeys/usdt-bridge-support.xml
+++ b/journeys/usdt-bridge-support.xml
@@ -6,6 +6,7 @@
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting.</action>
     <action>Open USDT Receive, then Network and Deposit Activity. Verify rows show Details rather than a transfer status, then open a deposit.</action>
+    <action>For a deposit whose conversion order is funded, confirming, swapping, bridging or delivering without an error, verify Pending is shown. Refresh after completion and verify Confirmed. An active order with an explicit error, or an unknown status, must show Needs attention.</action>
     <action>For a refunded deposit, verify the detail shows Refunded, even when an earlier error code is retained. Verify the transaction is labeled Refund transaction in the detail. Verify no pending-refund notice remains after refreshing the completed refund.</action>
     <action>For a refund in progress, verify Refunding is shown for the provider's pending acknowledgment. A refund requiring operator intervention must still show Needs attention.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard includes the deposit reference, source network and source transaction, plus the current status and any destination or refund transaction.</action>

From d5ac83fdf62f3ae3fe82a85dfdb23c30bb199744 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Mon, 12 Oct 2026 19:50:47 -0500
Subject: [PATCH 32/62] fix: preserve grouped activity row identifiers

---
 Bitkit/Components/Activity/ActivityList.swift | 10 +++---
 .../Views/Wallets/Activity/ActivityRow.swift  | 19 +++++++++++
 BitkitTests/WalletActivityTests.swift         | 34 +++++++++++++++++++
 3 files changed, 59 insertions(+), 4 deletions(-)
 create mode 100644 BitkitTests/WalletActivityTests.swift

diff --git a/Bitkit/Components/Activity/ActivityList.swift b/Bitkit/Components/Activity/ActivityList.swift
index 027483529..3bc2c2e5d 100644
--- a/Bitkit/Components/Activity/ActivityList.swift
+++ b/Bitkit/Components/Activity/ActivityList.swift
@@ -15,14 +15,16 @@ struct ActivityList: View {
 
     var body: some View {
         let activities = getActivities()
-        let rows = WalletActivity.merged(activities, filteredUsdt)
+        let rows = WalletActivity.grouped(WalletActivity.merged(activities, filteredUsdt))
         if !rows.isEmpty {
             LazyVStack(alignment: .leading, spacing: 16) {
                 ForEach(Array(rows.enumerated()), id: \.element) { index, item in
-                    if index == 0 || rows[index - 1].groupTitle != item.groupTitle {
-                        CaptionMText(item.groupTitle).frame(height: 34, alignment: .bottom)
+                    switch item {
+                    case let .header(title):
+                        CaptionMText(title).frame(height: 34, alignment: .bottom)
+                    case let .activity(activity):
+                        WalletActivityRow(item: activity).accessibilityIdentifier("Activity-\(index)")
                     }
-                    WalletActivityRow(item: item).accessibilityIdentifier("Activity-\(index)")
                 }
             }
         } else {
diff --git a/Bitkit/Views/Wallets/Activity/ActivityRow.swift b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
index 0fce77d85..c4e8fcbbe 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityRow.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
@@ -105,6 +105,11 @@ enum WalletActivity: Hashable {
     case bitcoin(Activity)
     case usdt(UsdtTransfer)
 
+    enum GroupItem: Hashable {
+        case header(String)
+        case activity(WalletActivity)
+    }
+
     var timestamp: UInt64 {
         switch self {
         case let .bitcoin(.lightning(item)): item.timestamp
@@ -120,6 +125,20 @@ enum WalletActivity: Hashable {
     static func merged(_ bitcoin: [Activity], _ usdt: [UsdtTransfer]) -> [WalletActivity] {
         (bitcoin.map(Self.bitcoin) + usdt.map(Self.usdt)).sorted { $0.timestamp > $1.timestamp }
     }
+
+    static func grouped(_ activities: [WalletActivity]) -> [GroupItem] {
+        var result: [GroupItem] = []
+        var previousTitle: String?
+        for activity in activities {
+            let title = activity.groupTitle
+            if title != previousTitle {
+                result.append(.header(title))
+                previousTitle = title
+            }
+            result.append(.activity(activity))
+        }
+        return result
+    }
 }
 
 struct WalletActivityRow: View {
diff --git a/BitkitTests/WalletActivityTests.swift b/BitkitTests/WalletActivityTests.swift
new file mode 100644
index 000000000..fad1ef2b4
--- /dev/null
+++ b/BitkitTests/WalletActivityTests.swift
@@ -0,0 +1,34 @@
+@testable import Bitkit
+import BitkitCore
+import XCTest
+
+final class WalletActivityTests: XCTestCase {
+    func testMergedActivityPositionsIncludeDateHeaders() throws {
+        let today = Calendar.current.startOfDay(for: Date())
+        let yesterday = try XCTUnwrap(Calendar.current.date(byAdding: .day, value: -1, to: today))
+        let timestamp = UInt64(today.timeIntervalSince1970)
+        let sent = Activity.lightning(LightningActivity(
+            walletId: WalletScope.default, id: "sent", txType: .sent, status: .succeeded, value: 1000, fee: 0,
+            invoice: "invoice", message: "", timestamp: timestamp + 2, preimage: nil, contact: nil,
+            createdAt: nil, updatedAt: nil, seenAt: nil
+        ))
+        let received = UsdtTransfer(
+            sender: nil, id: "received", txHash: "tx", userOperationHash: nil, bridgeGuid: nil, orchestra: nil,
+            recipient: "recipient", destination: .arbitrum, amount: 1_000_000, receivedAmount: 1_000_000, fee: nil,
+            isIncoming: true, status: .confirmed, timestamp: timestamp + 1
+        )
+        var earlier = received
+        earlier.id = "earlier"
+        earlier.timestamp = UInt64(yesterday.timeIntervalSince1970)
+
+        let grouped = WalletActivity.grouped(WalletActivity.merged([sent], [earlier, received]))
+        XCTAssertEqual(grouped, [
+            .header(DateFormatterHelpers.getActivityGroupHeader(for: today)),
+            .activity(.bitcoin(sent)),
+            .activity(.usdt(received)),
+            .header(DateFormatterHelpers.getActivityGroupHeader(for: yesterday)),
+            .activity(.usdt(earlier)),
+        ])
+        XCTAssertTrue(WalletActivity.grouped([]).isEmpty)
+    }
+}

From 90194c174734db16cd70efd67f15cfabc3de8626 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 03:42:29 -0500
Subject: [PATCH 33/62] fix: reject usdt links during hardware manual entry

---
 .../Localization/en.lproj/Localizable.strings |  2 ++
 Bitkit/ViewModels/AppViewModel.swift          | 22 ++++++++++++++++++-
 .../Wallets/Send/SendConfirmationView.swift   |  3 ++-
 .../Wallets/Send/SendEnterManuallyView.swift  |  3 ++-
 BitkitTests/UsdtPaymentLinkTests.swift        | 19 ++++++++++++----
 journeys/usdt-payment-links-and-scans.xml     |  2 +-
 6 files changed, 43 insertions(+), 8 deletions(-)

diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 8fa276579..c4b60368d 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -97,6 +97,8 @@
 "hardware__send_broadcast_failed_text" = "Check your connection and try again.";
 "hardware__send_broadcast_failed_title" = "Payment not confirmed";
 "hardware__send_confirm_address" = "To address (confirm on device)";
+"hardware__send_onchain_only_title" = "Bitcoin address required";
+"hardware__send_onchain_only_text" = "This hardware wallet can only send to a Bitcoin address.";
 "hardware__send_open_connect" = "Open Trezor Connect";
 "hardware__send_open_connect_jade" = "Sign With Jade";
 "hardware__send_sign_title" = "Sign With Device";
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index 73bd83a7a..fda3e7064 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -64,6 +64,7 @@ enum ManualEntryValidationResult: Equatable {
     case valid
     case empty
     case invalid
+    case onchainOnly
     case insufficientSavings
     case insufficientSpending
     case expiredLightningOnly
@@ -394,6 +395,13 @@ class AppViewModel: ObservableObject {
                 description: t("other__scan__error__generic"),
                 accessibilityIdentifier: "InvalidAddressToast"
             )
+        case .onchainOnly:
+            toast(
+                type: .error,
+                title: t("hardware__send_onchain_only_title"),
+                description: t("hardware__send_onchain_only_text"),
+                accessibilityIdentifier: "HardwareOnchainOnlyToast"
+            )
         case .insufficientSavings:
             toast(
                 type: .error,
@@ -1218,7 +1226,12 @@ extension AppViewModel {
     }
 
     /// Queue validation with debounce
-    func validateManualEntryInput(_ rawValue: String, savingsBalanceSats: Int, spendingBalanceSats: Int) {
+    func validateManualEntryInput(
+        _ rawValue: String,
+        savingsBalanceSats: Int,
+        spendingBalanceSats: Int,
+        scope: ScanHandlingScope = .unrestricted
+    ) {
         // Increment sequence first so any pending debounced requests become stale
         manualEntryValidationSequence &+= 1
         let currentSequence = manualEntryValidationSequence
@@ -1232,6 +1245,13 @@ extension AppViewModel {
             return
         }
 
+        if scope == .onchainPayments, normalized.removingLightningSchemes().lowercased().hasPrefix("ethereum:") {
+            manualEntryValidationResult = .onchainOnly
+            isManualEntryInputValid = false
+            showValidationErrorToast(for: .onchainOnly)
+            return
+        }
+
         // Queue the validation with debounce, including the sequence to detect stale requests
         manualEntryValidationSubject.send((rawValue, savingsBalanceSats, spendingBalanceSats, currentSequence))
     }
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index 57c86b6c7..83b02bded 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -1568,7 +1568,8 @@ struct SendConfirmationView: View {
         app.validateManualEntryInput(
             value,
             savingsBalanceSats: wallet.spendableOnchainBalanceSats,
-            spendingBalanceSats: wallet.maxSendLightningSats
+            spendingBalanceSats: wallet.maxSendLightningSats,
+            scope: hwSend.isActive ? .onchainPayments : .unrestricted
         )
 
         if let manualIndex = navigationPath.firstIndex(of: .manual) {
diff --git a/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift b/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
index 239c4df52..56d61c37d 100644
--- a/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
+++ b/Bitkit/Views/Wallets/Send/SendEnterManuallyView.swift
@@ -27,7 +27,8 @@ struct SendEnterManuallyView: View {
                         wallet.spendableOnchainBalanceSats,
                         Int(clamping: hwWalletManager.maximumFundingBalanceSats)
                     ),
-                    spendingBalanceSats: wallet.maxSendLightningSats
+                    spendingBalanceSats: wallet.maxSendLightningSats,
+                    scope: hwSend.isActive ? .onchainPayments : .unrestricted
                 )
             }
         )
diff --git a/BitkitTests/UsdtPaymentLinkTests.swift b/BitkitTests/UsdtPaymentLinkTests.swift
index 9161762a7..3319da316 100644
--- a/BitkitTests/UsdtPaymentLinkTests.swift
+++ b/BitkitTests/UsdtPaymentLinkTests.swift
@@ -30,17 +30,28 @@ final class UsdtPaymentLinkTests: XCTestCase {
     }
 
     @MainActor
-    func testManualEntryAcceptsUsdtUriAndRejectsWrongChain() async {
+    func testManualEntryValidatesUsdtNetworkAndWalletScope() async {
         let app = AppViewModel()
-        for (input, valid) in [(uri + "&uint256=10001", true), (uri.replacingOccurrences(of: "@42161", with: "@1"), false)] {
+        defer { ToastWindowManager.shared.hideToast() }
+        let cases: [(String, ScanHandlingScope, ManualEntryValidationResult)] = [
+            (uri + "&uint256=10001", .unrestricted, .valid),
+            (uri + "&uint256=10001", .onchainPayments, .onchainOnly),
+            (uri.replacingOccurrences(of: "@42161", with: "@1"), .unrestricted, .invalid),
+            (uri, .unrestricted, .valid),
+        ]
+        for (input, scope, result) in cases {
             let validated = expectation(description: "Manual entry validated")
             let observation = app.$isManualEntryInputValid.dropFirst().sink { actual in
-                XCTAssertEqual(actual, valid)
+                XCTAssertEqual(actual, result == .valid)
                 validated.fulfill()
             }
-            app.validateManualEntryInput(input, savingsBalanceSats: 0, spendingBalanceSats: 0)
+            app.validateManualEntryInput(input, savingsBalanceSats: 0, spendingBalanceSats: 0, scope: scope)
             await fulfillment(of: [validated], timeout: 5)
             observation.cancel()
+            XCTAssertEqual(app.manualEntryValidationResult, result)
+            if result == .onchainOnly {
+                XCTAssertEqual(ToastWindowManager.shared.currentToast?.accessibilityIdentifier, "HardwareOnchainOnlyToast")
+            }
         }
     }
 
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index 196154a8d..861c00ac9 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -7,7 +7,7 @@
     <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>
     <action>Cancel the send. Open the same link without uint256. Verify the amount screen opens with no amount and accepts a new amount.</action>
     <action>Cancel the send. From the main scanner, paste or import a QR containing the same amount-bearing URI. Verify it opens the USDT send flow with the same recipient and amount.</action>
-    <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, choose Enter Manually, enter the same URI and continue. Verify the USDT recipient and exact amount are preserved. Repeat with a wrong-chain URI and in hardware-wallet Send; verify neither opens a USDT payment. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
+    <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, choose Enter Manually, enter the same URI and continue. Verify the USDT recipient and exact amount are preserved. Repeat with a wrong-chain URI and in hardware-wallet Send; verify neither opens a USDT payment. In hardware-wallet manual entry, verify the Bitcoin-address-required warning appears and Continue stays disabled. Replace the URI with a valid Bitcoin address and verify Continue becomes available. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
     <action>Open or scan variants with the wrong chain, wrong token, duplicate amount and malformed recipient. Verify an error and no payable review. Check an ordinary Bitcoin or Lightning invoice still opens its existing send flow.</action>
     <action>On iOS, open a USDT link while Lightning is stopped but the wallet is ready. Verify it routes without starting Lightning. Open two different USDT links while the main scanner sheet is dismissing; verify an older delayed link cannot replace the review that opened first.</action>
     <action>Enter this wallet’s own Arbitrum address in USDT Send, enter an amount and continue. Verify the error explicitly says you cannot send USDT to your own address, and no payment is submitted. Repeat with MAX.</action>

From d4f206cd69cc92a5bb084a9cf631adca8e57391f Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 04:59:08 -0500
Subject: [PATCH 34/62] fix: clarify subscription review and activity grouping

---
 .../Localization/en.lproj/Localizable.strings |  1 +
 .../CreateSubscriptionView.swift              | 53 +++++++++++--------
 .../Subscriptions/SubscriptionsView.swift     |  8 ++-
 .../Views/Wallets/Activity/ActivityRow.swift  | 25 +++++----
 BitkitTests/WalletActivityTests.swift         | 20 ++++++-
 journeys/paykit-quoted-usdt.xml               |  2 +-
 journeys/usdt-payment-links-and-scans.xml     |  2 +-
 journeys/usdt-wallet-navigation.xml           |  2 +-
 8 files changed, 75 insertions(+), 38 deletions(-)

diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index c4b60368d..faf271eff 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1631,6 +1631,7 @@
 "subscriptions__renews" = "Renews";
 "subscriptions__retry_payment" = "Retry Payment";
 "subscriptions__renews_date" = "Renews {date}";
+"subscriptions__payment_methods" = "Payment methods";
 "subscriptions__review_and_subscribe" = "Review & Subscribe";
 "subscriptions__status" = "Status";
 "subscriptions__subscribed" = "Subscribed";
diff --git a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
index cbd970249..27d9b0453 100644
--- a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
+++ b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
@@ -30,7 +30,7 @@ struct CreateSubscriptionView: View {
                     ScrollView(showsIndicators: false) {
                         VStack(alignment: .leading, spacing: 24) {
                             amount
-                            acceptedMethods
+                            SubscriptionPaymentMethods(title: t("wallet__payment_request_accepted_methods"), endpoints: acceptedEndpoints)
                             frequency
                             name
                             description
@@ -115,28 +115,6 @@ struct CreateSubscriptionView: View {
         )
     }
 
-    private var acceptedMethods: some View {
-        VStack(alignment: .leading, spacing: 8) {
-            CaptionMText(t("wallet__payment_request_accepted_methods"), textColor: .white64)
-            HStack(spacing: 16) {
-                if acceptedEndpoints.contains(PublicPaykitService.MethodId.usdtArbitrum.rawValue) {
-                    BodyMSBText("USDT", textColor: .usdtAccent)
-                }
-                if acceptedEndpoints.contains(where: { PublicPaykitService.MethodId(rawValue: $0)?.onchainNetwork != nil }) {
-                    BodyMSBText(t("lightning__savings"), textColor: .brandAccent)
-                }
-                if acceptedEndpoints.contains(PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue) {
-                    BodyMSBText(t("lightning__spending"), textColor: .purpleAccent)
-                }
-                if acceptedEndpoints.isEmpty {
-                    BodySText(t("wallet__payment_request_status_unavailable"), textColor: .white64)
-                }
-            }
-        }
-        .accessibilityElement(children: .contain)
-        .accessibilityIdentifier("SubscriptionAcceptedMethods")
-    }
-
     private var frequency: some View {
         VStack(alignment: .leading, spacing: 8) {
             CaptionMText(t("subscriptions__frequency").localizedUppercase, textColor: .white64)
@@ -405,3 +383,32 @@ private enum SubscriptionFrequencyOption: String, CaseIterable, CustomStringConv
         }
     }
 }
+
+struct SubscriptionPaymentMethods: View {
+    let title: String
+    let endpoints: [String]
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            CaptionMText(title, textColor: .white64)
+            HStack(spacing: 16) {
+                if endpoints.contains(PublicPaykitService.MethodId.usdtArbitrum.rawValue) {
+                    BodyMSBText("USDT", textColor: .usdtAccent)
+                }
+                if endpoints.contains(where: { PublicPaykitService.MethodId(rawValue: $0)?.onchainNetwork != nil }) {
+                    BodyMSBText(t("lightning__savings"), textColor: .brandAccent)
+                }
+                if endpoints.contains(PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue) ||
+                    endpoints.contains(PublicPaykitService.MethodId.bitcoinLightningLnurl.rawValue)
+                {
+                    BodyMSBText(t("lightning__spending"), textColor: .purpleAccent)
+                }
+                if endpoints.isEmpty {
+                    BodySText(t("wallet__payment_request_status_unavailable"), textColor: .white64)
+                }
+            }
+        }
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("SubscriptionAcceptedMethods")
+    }
+}
diff --git a/Bitkit/Views/Subscriptions/SubscriptionsView.swift b/Bitkit/Views/Subscriptions/SubscriptionsView.swift
index bf02b70b4..bdd0c60c8 100644
--- a/Bitkit/Views/Subscriptions/SubscriptionsView.swift
+++ b/Bitkit/Views/Subscriptions/SubscriptionsView.swift
@@ -636,6 +636,9 @@ struct SubscriptionSheet: View {
         return VStack(spacing: 0) {
             SheetHeader(title: t("subscriptions__review_and_subscribe"))
             SubscriptionAmountHeader(subscription: subscription)
+            SubscriptionPaymentMethods(title: t("subscriptions__payment_methods"), endpoints: subscription.acceptedPaymentEndpointIdentifiers)
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .padding(.bottom, 24)
             SubscriptionProviderCard(subscription: subscription, showsCounterparty: true) {
                 guard !isAccepting else { return }
                 previousRoute = route
@@ -666,7 +669,7 @@ struct SubscriptionSheet: View {
             Image("subscription-clock")
                 .resizable()
                 .aspectRatio(contentMode: .fit)
-                .frame(width: 256, height: 256)
+                .frame(maxWidth: 256, maxHeight: 256)
                 .accessibilityHidden(true)
             Spacer()
 
@@ -675,7 +678,8 @@ struct SubscriptionSheet: View {
                     title: payOnAcceptance
                         ? t("subscriptions__swipe_to_subscribe_and_pay")
                         : t("subscriptions__swipe_to_subscribe"),
-                    accentColor: .brandAccent,
+                    accentColor: subscription.acceptedPaymentEndpointIdentifiers == [PublicPaykitService.MethodId.usdtArbitrum.rawValue]
+                        ? .usdtAccent : .brandAccent,
                     isLoading: isAccepting || paymentRequests.isProcessingSubscription
                 ) {
                     do {
diff --git a/Bitkit/Views/Wallets/Activity/ActivityRow.swift b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
index c4e8fcbbe..84a80f3b3 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityRow.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
@@ -118,22 +118,29 @@ enum WalletActivity: Hashable {
         }
     }
 
-    var groupTitle: String {
-        DateFormatterHelpers.getActivityGroupHeader(for: Date(timeIntervalSince1970: TimeInterval(timestamp)))
-    }
-
     static func merged(_ bitcoin: [Activity], _ usdt: [UsdtTransfer]) -> [WalletActivity] {
         (bitcoin.map(Self.bitcoin) + usdt.map(Self.usdt)).sorted { $0.timestamp > $1.timestamp }
     }
 
     static func grouped(_ activities: [WalletActivity]) -> [GroupItem] {
+        let calendar = Calendar.current
+        let now = Date()
+        let today = calendar.startOfDay(for: now)
+        let boundaries = [
+            today,
+            calendar.date(byAdding: .day, value: -1, to: today) ?? today,
+            calendar.dateInterval(of: .weekOfYear, for: now)?.start ?? today,
+            calendar.dateInterval(of: .month, for: now)?.start ?? today,
+            calendar.dateInterval(of: .year, for: now)?.start ?? today,
+        ]
         var result: [GroupItem] = []
-        var previousTitle: String?
+        var groupStart = Date.distantFuture
         for activity in activities {
-            let title = activity.groupTitle
-            if title != previousTitle {
-                result.append(.header(title))
-                previousTitle = title
+            let date = Date(timeIntervalSince1970: TimeInterval(activity.timestamp))
+            if result.isEmpty || date < groupStart {
+                groupStart = boundaries.first { date >= $0 }
+                    ?? calendar.dateInterval(of: .year, for: date)?.start ?? date
+                result.append(.header(DateFormatterHelpers.getActivityGroupHeader(for: min(date, now))))
             }
             result.append(.activity(activity))
         }
diff --git a/BitkitTests/WalletActivityTests.swift b/BitkitTests/WalletActivityTests.swift
index fad1ef2b4..6258fcc62 100644
--- a/BitkitTests/WalletActivityTests.swift
+++ b/BitkitTests/WalletActivityTests.swift
@@ -21,14 +21,32 @@ final class WalletActivityTests: XCTestCase {
         earlier.id = "earlier"
         earlier.timestamp = UInt64(yesterday.timeIntervalSince1970)
 
-        let grouped = WalletActivity.grouped(WalletActivity.merged([sent], [earlier, received]))
+        var future = received
+        future.id = "future"
+        future.timestamp = timestamp + 2 * 24 * 60 * 60
+        var historical = received
+        historical.id = "historical"
+        let priorYear = try XCTUnwrap(Calendar.current.date(byAdding: .year, value: -1, to: today))
+        historical.timestamp = UInt64(priorYear.timeIntervalSince1970)
+        var older = historical
+        older.id = "older"
+        let olderYear = try XCTUnwrap(Calendar.current.date(byAdding: .year, value: -2, to: today))
+        older.timestamp = UInt64(olderYear.timeIntervalSince1970)
+
+        let grouped = WalletActivity.grouped(WalletActivity.merged([sent], [earlier, received, future, historical, older]))
         XCTAssertEqual(grouped, [
             .header(DateFormatterHelpers.getActivityGroupHeader(for: today)),
+            .activity(.usdt(future)),
             .activity(.bitcoin(sent)),
             .activity(.usdt(received)),
             .header(DateFormatterHelpers.getActivityGroupHeader(for: yesterday)),
             .activity(.usdt(earlier)),
+            .header(DateFormatterHelpers.getActivityGroupHeader(for: priorYear)),
+            .activity(.usdt(historical)),
+            .header(DateFormatterHelpers.getActivityGroupHeader(for: olderYear)),
+            .activity(.usdt(older)),
         ])
+        XCTAssertEqual(grouped.count, Set(grouped).count)
         XCTAssertTrue(WalletActivity.grouped([]).isEmpty)
     }
 }
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index abebc23c6..60ec33688 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -6,7 +6,7 @@
     <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
     <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
-    <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method; close before subscribing.</action>
+    <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method. Verify the subscription swipe uses USDT teal, then close before subscribing.</action>
     <action>Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing.</action>
     <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01, then close without continuing to review.</action>
   </actions>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index 861c00ac9..e28a65116 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -10,7 +10,7 @@
     <action>Cancel the send. From the ordinary Send options, paste the URI. Verify it opens the USDT send flow. Cancel, choose Enter Manually, enter the same URI and continue. Verify the USDT recipient and exact amount are preserved. Repeat with a wrong-chain URI and in hardware-wallet Send; verify neither opens a USDT payment. In hardware-wallet manual entry, verify the Bitcoin-address-required warning appears and Continue stays disabled. Replace the URI with a valid Bitcoin address and verify Continue becomes available. Cancel, then open Send again from the USDT wallet and verify the previous recipient and amount are cleared.</action>
     <action>Open or scan variants with the wrong chain, wrong token, duplicate amount and malformed recipient. Verify an error and no payable review. Check an ordinary Bitcoin or Lightning invoice still opens its existing send flow.</action>
     <action>On iOS, open a USDT link while Lightning is stopped but the wallet is ready. Verify it routes without starting Lightning. Open two different USDT links while the main scanner sheet is dismissing; verify an older delayed link cannot replace the review that opened first.</action>
-    <action>Enter this wallet’s own Arbitrum address in USDT Send, enter an amount and continue. Verify the error explicitly says you cannot send USDT to your own address, and no payment is submitted. Repeat with MAX.</action>
+    <action>Enter this wallet’s own Arbitrum address in USDT Send, enter an amount and continue. Verify the error explicitly says you cannot send USDT to your own address, and no payment is submitted. Repeat with MAX. On Android, enter this wallet’s own bare Arbitrum address through Home Send → Enter Manually and verify the self-send message appears while Continue stays disabled.</action>
     <action>Enter the entire available USDT balance and continue. Verify the fee-collection error explains that the transaction fee could not be paid in USDT and suggests a smaller amount. Reduce the amount, reach review and close without signing.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index c2c0f04df..1a7946026 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -3,7 +3,7 @@
   <actions>
     <action>On Home, verify the Savings/Spending and USDT balance dividers align vertically, including any hardware wallet rows.</action>
     <action>Verify USDT balances and activity amounts show at most two decimals; a nonzero amount below one cent shows &lt;0.01. Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet, with its Tether coin illustration anchored at the upper right.</action>
-    <action>Open Receive. Verify the network is Arbitrum One. Open details, verify the address starts with 0x, and verify Details Copy contains only the address. Return to the QR and verify Copy contains the full USDT payment URI including the network and token.</action>
+    <action>Open Receive. Verify the network is Arbitrum One. Open details, verify the address starts with 0x, and verify Details Copy contains only the address. Return to the QR and verify Copy contains the full USDT payment URI including the network and token. On Android, system Back from Details returns to the USDT QR; Back from the QR closes Receive without switching to Savings.</action>
     <action>Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing.</action>
     <action>Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote.</action>
     <action>Set an amount and note in Bitcoin Receive, then close it. Open a fresh USDT Receive sheet and switch to Savings and Spending. Verify Savings shows a fresh Bitcoin QR with no previous amount or note. Spending shows a fresh Lightning QR when receive liquidity is available; an unfunded wallet shows the Spending receive setup instead. Verify hardware-wallet receive remains available when paired.</action>

From 4842452dc233b468a25ba06c5b179238c89ff226 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 05:46:27 -0500
Subject: [PATCH 35/62] fix: distinguish sent and received bridge amounts

---
 .../Localization/en.lproj/Localizable.strings |  2 +
 Bitkit/Views/Wallets/UsdtSendView.swift       | 44 +++++++++++--------
 journeys/usdt-bridge-support.xml              |  2 +-
 journeys/usdt-send-review-and-details.xml     |  4 +-
 4 files changed, 31 insertions(+), 21 deletions(-)

diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index faf271eff..7b57ada51 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1959,3 +1959,5 @@
 "usdt__from_address" = "From address";
 
 "usdt__to_address" = "To address";
+
+"usdt__you_send" = "You send";
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index a6d07c1f6..1f7a6b26e 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -312,9 +312,20 @@ struct UsdtSendView: View {
             GeometryReader { geometry in
                 ScrollView(showsIndicators: false) {
                     VStack(alignment: .leading, spacing: 0) {
+                        if quote.destination != .arbitrum {
+                            CaptionMText(t("usdt__you_send")).padding(.bottom, 8)
+                        }
                         UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), displayAmount: usdtOverviewAmount(quote.amount))
                             .contentShape(Rectangle()).onTapGesture { if !busy { goBack() } }
-                            .padding(.bottom, 32)
+                        if quote.destination != .arbitrum {
+                            SendSectionView(t("usdt__recipient_gets")) {
+                                BodySSBText((quote.bridgeProvider == .orchestra ? "≈ " : "") + usdtOverviewAmount(quote.receivedAmount) + " USDT")
+                            }
+                            .accessibilityElement(children: .contain)
+                            .accessibilityIdentifier("UsdtRecipientAmount")
+                            .padding(.top, 16)
+                        }
+                        Spacer().frame(height: 32)
                         if showDetails {
                             quoteDetails(quote)
                             if let requestNote { PaymentRequestInvoiceNote(note: requestNote).padding(.top, 16) }
@@ -326,7 +337,13 @@ struct UsdtSendView: View {
                             PaymentReviewIllustration(swipeProgress: busy || paymentComplete ? 1 : swipeProgress, maximumHeight: 192)
                                 .padding(.top, 16).frame(height: 256)
                         }
-                        if quote.destination != .arbitrum { bridgeCosts(quote).padding(.top, 16) }
+                        if showDetails {
+                            if quote.bridgeProvider == .orchestra {
+                                bridgeCost(quote).padding(.top, 16)
+                            }
+                            CaptionText(t(quote.bridgeProvider == .orchestra ? "usdt__bridge_estimate_note" : "usdt__fee_note"))
+                                .multilineTextAlignment(.center).frame(maxWidth: .infinity).padding(.top, 16)
+                        }
                         if let error { BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError") }
                         CustomButton(
                             title: t(showDetails ? "common__hide_details" : "common__show_details"), size: .small,
@@ -339,10 +356,7 @@ struct UsdtSendView: View {
                     }
                     .frame(minHeight: geometry.size.height, alignment: .top)
                 }
-            }
-            if showDetails {
-                CaptionText(t(quote.bridgeProvider == .orchestra ? "usdt__bridge_estimate_note" : "usdt__fee_note"))
-                    .multilineTextAlignment(.center).frame(maxWidth: .infinity).padding(.bottom, 24)
+                .id(showDetails)
             }
             if quote.destination != .arbitrum {
                 SendSectionView(t("usdt__maximum_total")) {
@@ -350,7 +364,7 @@ struct UsdtSendView: View {
                 }
                 .accessibilityElement(children: .contain)
                 .accessibilityIdentifier("UsdtMaximumTotal")
-                .padding(.bottom, 16)
+                .padding(.vertical, 16)
             }
             SwipeButton(
                 title: t("wallet__send_swipe"), accentColor: .usdtAccent, isDisabled: busy,
@@ -373,7 +387,8 @@ struct UsdtSendView: View {
                 UsdtDetailCell(title: t("usdt__network"), value: quote.destination.label, icon: "usdt-network")
             }
             HStack(alignment: .top, spacing: 16) {
-                UsdtDetailCell(title: t("wallet__activity_payment"), value: usdtOverviewAmount(quote.amount), icon: "user")
+                UsdtDetailCell(title: t(quote.destination == .arbitrum ? "wallet__activity_payment" : "usdt__you_send"),
+                               value: usdtOverviewAmount(quote.amount), icon: "user")
                 UsdtDetailCell(title: t("wallet__activity_fee"), value: usdtOverviewAmount(quote.maximumFee), icon: "speed-normal")
             }
             if paymentContext != nil {
@@ -393,16 +408,9 @@ struct UsdtSendView: View {
         }
     }
 
-    private func bridgeCosts(_ quote: UsdtQuote) -> some View {
-        VStack(alignment: .leading, spacing: 16) {
-            SendSectionView(t(quote.bridgeProvider == .orchestra ? "usdt__expected_amount" : "usdt__recipient_gets")) {
-                BodySSBText(usdtOverviewAmount(quote.receivedAmount) + " USDT")
-            }
-            if quote.bridgeProvider == .orchestra {
-                SendSectionView(t("usdt__bridge_deducted_fee")) {
-                    BodySSBText(usdtOverviewAmount(quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
-                }
-            }
+    private func bridgeCost(_ quote: UsdtQuote) -> some View {
+        SendSectionView(t("usdt__bridge_deducted_fee")) {
+            BodySSBText(usdtOverviewAmount(quote.amount - min(quote.amount, quote.receivedAmount)) + " USDT")
         }
     }
 
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
index 86bfde795..0ad7ea4d9 100644
--- a/journeys/usdt-bridge-support.xml
+++ b/journeys/usdt-bridge-support.xml
@@ -5,7 +5,7 @@
     <action>Tap Details (id "UsdtActivityDetails"), then verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting.</action>
-    <action>Open USDT Receive, then Network and Deposit Activity. Verify rows show Details rather than a transfer status, then open a deposit.</action>
+    <action>Open USDT Receive, then Network, scroll to Cross-network Deposits (id "UsdtDepositHistory") and open it. Verify rows show Details rather than a transfer status, then open a deposit.</action>
     <action>For a deposit whose conversion order is funded, confirming, swapping, bridging or delivering without an error, verify Pending is shown. Refresh after completion and verify Confirmed. An active order with an explicit error, or an unknown status, must show Needs attention.</action>
     <action>For a refunded deposit, verify the detail shows Refunded, even when an earlier error code is retained. Verify the transaction is labeled Refund transaction in the detail. Verify no pending-refund notice remains after refreshing the completed refund.</action>
     <action>For a refund in progress, verify Refunding is shown for the provider's pending acknowledgment. A refund requiring operator intervention must still show Needs attention.</action>
diff --git a/journeys/usdt-send-review-and-details.xml b/journeys/usdt-send-review-and-details.xml
index d8e01cc6f..7266d1611 100644
--- a/journeys/usdt-send-review-and-details.xml
+++ b/journeys/usdt-send-review-and-details.xml
@@ -5,8 +5,8 @@
     <action>Open the network pill and select another EVM network. Verify the amount and valid recipient remain. Change to Solana with an EVM recipient and verify recipient entry is required. Enter an owned plain Solana address and verify the previous amount remains. Return to Arbitrum, enter the owned EVM address and verify the amount still remains.</action>
     <action>From recipient entry with another network selected, paste an explicit Arbitrum USDT URI. Verify the selected network becomes Arbitrum and the link amount is retained. A plain 0x address preserves the selected network.</action>
     <action>Tap MAX. Verify it fills a positive amount below the balance and remains on Amount. Continue and verify the payment plus maximum fee fits within the balance. Back out without swiping.</action>
-    <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note above the swipe control. Displayed amounts round to cents; nonzero values below one cent show &lt;0.01. Hide Details restores the illustration. Cancel without paying.</action>
-    <action>Prepare a cross-network payment and continue. Without scrolling, verify Maximum total debit (id "UsdtMaximumTotal") and its value are fully visible above Swipe To Pay. Show Details and verify the maximum remains visible. Cancel without paying.</action>
+    <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note in the scrollable details. Displayed amounts round to cents; nonzero values below one cent show &lt;0.01. Hide Details restores the illustration. Cancel without paying.</action>
+    <action>Prepare a cross-network payment and continue. Verify You send labels the entered amount and Recipient gets appears directly beneath it, with an approximation marker for Orchestra. Verify the recipient amount follows the quote rather than assuming it equals the sent amount. Without scrolling, verify Maximum total debit (id "UsdtMaximumTotal") and its value are fully visible above Swipe To Pay. Show Details and verify the maximum remains visible, Payment is labelled You send, and the fee note can be read by scrolling without overlapping the pinned total. For Orchestra, also verify the deducted bridge cost is fully readable when scrolled into view. Cancel without paying.</action>
     <action>Open an existing sent USDT activity. Verify the heading is Sent USDT, the signed amount includes the actual fee, and summary rows show Status/Network, Date/Time and Payment/Fee with teal icons. Open Details and verify transaction ID, known sender, recipient and source/destination networks; Open Block Explorer stays at the bottom.</action>
     <action>Open an existing received activity. Verify Received USDT and a positive amount. Verify Details shows the verified sender when available and does not invent one for older unknown records. Check pending, failed and transferring rows use their matching icons, and transferring shows its destination.</action>
     <action>Prepare a contact payment that accepts multiple payment methods. Open the payment-source button and verify the balance menu shows Savings, Spending, any paired hardware wallet and USDT. Unsupported methods are disabled. Select a supported method and verify its label, available balance and payable amount update. Cancel without paying.</action>

From 2a790d40377fd43480b6e9c3f288060b51a2c363 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 06:59:17 -0500
Subject: [PATCH 36/62] fix: preserve usdt flows after rebase

---
 Bitkit/Components/HardwareWalletsGrid.swift   | 45 ++++++++++---------
 Bitkit/Utilities/ClipboardPrompt.swift        |  8 ++++
 Bitkit/ViewModels/AppViewModel.swift          |  8 ++--
 Bitkit/Views/Home/HomeWalletView.swift        | 14 ++----
 Bitkit/Views/Wallets/Send/SendSheet.swift     |  2 +-
 .../ClipboardPromptValidatorTests.swift       | 21 +++++++++
 .../PaykitPaymentRequestServiceTests.swift    |  2 +-
 .../subscriptions/review-and-subscribe.xml    |  5 +--
 journeys/usdt-payment-links-and-scans.xml     |  1 +
 journeys/usdt-wallet-navigation.xml           |  2 +-
 10 files changed, 66 insertions(+), 42 deletions(-)

diff --git a/Bitkit/Components/HardwareWalletsGrid.swift b/Bitkit/Components/HardwareWalletsGrid.swift
index 00b5ce36c..4a5979296 100644
--- a/Bitkit/Components/HardwareWalletsGrid.swift
+++ b/Bitkit/Components/HardwareWalletsGrid.swift
@@ -1,40 +1,43 @@
 import SwiftUI
 
-/// Two-column grid of paired hardware wallets shown on Home, under the Savings/Spending tiles.
-/// Mirrors bitkit-android's `HwDevices` (rows chunked in pairs, divided like the on-chain tiles).
-struct HardwareWalletsGrid: View {
+struct HardwareWalletsGrid<AdditionalWallet: View>: View {
     let wallets: [HwWallet]
+    let showAdditionalWallet: Bool
     let onTap: (HwWallet) -> Void
+    let additionalWallet: AdditionalWallet
 
-    private var rows: [[HwWallet]] {
-        chunked(wallets, into: 2)
-    }
-
-    private func chunked(_ wallets: [HwWallet], into size: Int) -> [[HwWallet]] {
-        stride(from: 0, to: wallets.count, by: size).map { start in
-            let end = min(start + size, wallets.count)
-            return Array(wallets[start ..< end])
-        }
+    init(wallets: [HwWallet], showAdditionalWallet: Bool = false, onTap: @escaping (HwWallet) -> Void,
+         @ViewBuilder additionalWallet: () -> AdditionalWallet = { EmptyView() })
+    {
+        self.wallets = wallets
+        self.showAdditionalWallet = showAdditionalWallet
+        self.onTap = onTap
+        self.additionalWallet = additionalWallet()
     }
 
     var body: some View {
         VStack(spacing: 16) {
-            ForEach(Array(rows.enumerated()), id: \.offset) { _, row in
+            ForEach(Array(stride(from: 0, to: wallets.count + (showAdditionalWallet ? 1 : 0), by: 2)), id: \.self) { rowStart in
                 HStack(spacing: 16) {
-                    HardwareWalletCell(wallet: row[0], onTap: onTap)
-
+                    cell(at: rowStart)
                     CustomDivider(color: .gray4, type: .vertical)
-
-                    if row.count > 1 {
-                        HardwareWalletCell(wallet: row[1], onTap: onTap)
-                    } else {
-                        Color.clear.frame(maxWidth: .infinity)
-                    }
+                    cell(at: rowStart + 1)
                 }
                 .frame(height: 50)
             }
         }
     }
+
+    @ViewBuilder
+    private func cell(at index: Int) -> some View {
+        if index < wallets.count {
+            HardwareWalletCell(wallet: wallets[index], onTap: onTap)
+        } else if showAdditionalWallet, index == wallets.count {
+            additionalWallet
+        } else {
+            Color.clear.frame(maxWidth: .infinity)
+        }
+    }
 }
 
 private struct HardwareWalletCell: View {
diff --git a/Bitkit/Utilities/ClipboardPrompt.swift b/Bitkit/Utilities/ClipboardPrompt.swift
index 8d2e7f179..6ea1a3f70 100644
--- a/Bitkit/Utilities/ClipboardPrompt.swift
+++ b/Bitkit/Utilities/ClipboardPrompt.swift
@@ -51,8 +51,16 @@ enum ClipboardPromptValidator {
         _ uri: String,
         ownPublicKey: String?,
         contacts: [PubkyContact],
+        isUsdtEnabled: Bool = Env.isUsdtEnabled,
         decodeURI: (String) async -> Bool = { await (try? decode(invoice: $0)) != nil }
     ) async -> Bool {
+        do {
+            if try resolveUsdtPaymentRoute(input: uri, isEnabled: isUsdtEnabled) != nil {
+                return true
+            }
+        } catch {
+            return false
+        }
         if resolvePastedPubkyRoute(input: uri, ownPublicKey: ownPublicKey, contacts: contacts) != nil {
             return true
         }
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index fda3e7064..07ae48dfb 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -337,8 +337,8 @@ class AppViewModel: ObservableObject {
         )
     }
 
-    private func validateIncomingOnchainPaymentRequestAmount() -> Bool {
-        guard let amount = contactPaymentContext?.incomingPaymentRequest?.amountSats, amount < Env.dustLimit else { return true }
+    private func validateIncomingOnchainPaymentRequestAmount(_ amount: UInt64) -> Bool {
+        guard contactPaymentContext?.incomingPaymentRequest != nil, amount < Env.dustLimit else { return true }
         didRejectScannedPayment = true
         toast(
             type: .error,
@@ -354,7 +354,7 @@ class AppViewModel: ObservableObject {
 
     /// Validates the onchain request amount and balance, showing feedback when invalid.
     private func validateOnchainBalance(invoiceAmount: UInt64, onchainBalance: UInt64) -> Bool {
-        guard validateIncomingOnchainPaymentRequestAmount() else { return false }
+        guard validateIncomingOnchainPaymentRequestAmount(invoiceAmount) else { return false }
         if invoiceAmount > 0 {
             guard onchainBalance >= invoiceAmount else {
                 didRejectScannedPayment = true
@@ -858,7 +858,7 @@ extension AppViewModel {
 
             // Fallback to on-chain if address is available
             guard !invoice.address.isEmpty else { return }
-            guard validateIncomingOnchainPaymentRequestAmount() else { return }
+            guard validateIncomingOnchainPaymentRequestAmount(requestedAmount ?? invoice.amountSatoshis) else { return }
 
             // If node is running, validate balance immediately
             if paymentState.isNodeRunning {
diff --git a/Bitkit/Views/Home/HomeWalletView.swift b/Bitkit/Views/Home/HomeWalletView.swift
index fde2efaf7..94185ad6a 100644
--- a/Bitkit/Views/Home/HomeWalletView.swift
+++ b/Bitkit/Views/Home/HomeWalletView.swift
@@ -56,15 +56,10 @@ struct HomeWalletView: View {
             .frame(height: 50)
             .padding(.bottom, usdt.isConfigured && hwWalletManager.wallets.isEmpty ? 24 : 32)
 
-            if !hwWalletManager.wallets.isEmpty {
-                HardwareWalletsGrid(wallets: hwWalletManager.wallets) { hwWallet in
+            if !hwWalletManager.wallets.isEmpty || usdt.isConfigured {
+                HardwareWalletsGrid(wallets: hwWalletManager.wallets, showAdditionalWallet: usdt.isConfigured) { hwWallet in
                     navigation.navigate(.hardwareWallet(walletId: hwWallet.id))
-                }
-                .padding(.bottom, usdt.isConfigured ? 24 : 32)
-            }
-
-            if usdt.isConfigured {
-                HStack(spacing: 16) {
+                } additionalWallet: {
                     Button { navigation.navigate(.usdtWallet) } label: {
                         WalletBalanceContent {
                             CaptionMText("USDT")
@@ -77,10 +72,7 @@ struct HomeWalletView: View {
                     }
                     .buttonStyle(.plain)
                     .accessibilityIdentifier("UsdtWallet")
-                    CustomDivider(color: .gray4, type: .vertical)
-                    Color.clear.frame(maxWidth: .infinity)
                 }
-                .frame(height: 50)
                 .padding(.bottom, 32)
             }
 
diff --git a/Bitkit/Views/Wallets/Send/SendSheet.swift b/Bitkit/Views/Wallets/Send/SendSheet.swift
index 25cb7470b..424a07737 100644
--- a/Bitkit/Views/Wallets/Send/SendSheet.swift
+++ b/Bitkit/Views/Wallets/Send/SendSheet.swift
@@ -455,7 +455,7 @@ struct SendSheet: View {
 
     /// Validates the onchain request amount and balance, showing setup failure feedback when invalid.
     private func validateOnchainBalanceAndDismissIfInsufficient(invoiceAmount: UInt64, onchainBalance: UInt64) -> Bool {
-        if let amount = app.contactPaymentContext?.incomingPaymentRequest?.amountSats, amount < Env.dustLimit {
+        if app.contactPaymentContext?.incomingPaymentRequest != nil, invoiceAmount < Env.dustLimit {
             showPaymentSetupFailure(
                 title: t("wallet__lnurl_pay__error_min__title"),
                 description: t(
diff --git a/BitkitTests/ClipboardPromptValidatorTests.swift b/BitkitTests/ClipboardPromptValidatorTests.swift
index 18335a5d5..ba85bbcb6 100644
--- a/BitkitTests/ClipboardPromptValidatorTests.swift
+++ b/BitkitTests/ClipboardPromptValidatorTests.swift
@@ -5,6 +5,27 @@ import os
 import XCTest
 
 final class ClipboardPromptValidatorTests: XCTestCase {
+    func testUsdtLinksAreValidatedLocallyWhenEnabled() async {
+        let uri = "ethereum:\(PaykitUsdt.token)@42161/transfer?address=0x1111111111111111111111111111111111111111"
+        for (input, enabled, expected) in [
+            (uri, true, true),
+            (" \(uri)&uint256=10001\n", true, true),
+            (uri.replacingOccurrences(of: "ethereum:", with: "ETHEREUM:"), true, true),
+            (uri, false, false),
+            (uri.replacingOccurrences(of: "@42161", with: "@1"), true, false),
+            (uri.replacingOccurrences(of: PaykitUsdt.token, with: "0x2222222222222222222222222222222222222222"), true, false),
+            ("ethereum:invalid", true, false),
+        ] {
+            let supported = await ClipboardPromptValidator.isSupportedURI(
+                input, ownPublicKey: nil, contacts: [], isUsdtEnabled: enabled
+            ) { _ in
+                XCTFail("USDT clipboard links must be validated locally: '\(input)'")
+                return false
+            }
+            XCTAssertEqual(supported, expected, "\(input), enabled: \(enabled)")
+        }
+    }
+
     func testLightningAddressCandidatesDoNotInvokeNetworkDecoder() async {
         for uri in [
             "alice@corp.example",
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index b098f8ea6..f022bedcd 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -4575,7 +4575,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             window.rootViewController = nil
             ToastWindowManager.shared.hideToast()
         }
-        try await waitUntil { wallet.sendAmountSats == request.amountSats }
+        try await waitUntil { wallet.sendAmountSats == request.amount.atomic }
 
         wallet.nodeLifecycleState = .running
         try await waitUntil { sheets.activeSheetConfiguration == nil }
diff --git a/journeys/subscriptions/review-and-subscribe.xml b/journeys/subscriptions/review-and-subscribe.xml
index 05caab154..da098dba6 100644
--- a/journeys/subscriptions/review-and-subscribe.xml
+++ b/journeys/subscriptions/review-and-subscribe.xml
@@ -11,8 +11,7 @@
     naming when the first billing period ends sits below the card. Neither appears on Android. The
     handoff's "Automatically pay this subscription" toggle is unbuilt on both platforms.
 
-    The swipe knob is brand orange on both platforms, as the handoff draws it on all four subscription
-    sheets.
+    The swipe knob is USDT teal when USDT is the only accepted payment method, otherwise brand orange.
   </description>
   <actions>
     <action>Launch the E2E Bitkit app with Paykit UI enabled on the payer instance, with the creator saved as a linked contact and a spendable balance above 5,000 sats</action>
@@ -22,7 +21,7 @@
     <action>Tap the "Journey Sub" row (id "SubscriptionRow-&lt;paymentRequestId&gt;")</action>
     <action>Verify the Review and Subscribe sheet appears with 5,000 sats and the creator contact card</action>
     <action>Verify the swipe control reads "Swipe To Subscribe &amp; Pay" when the first period is due on acceptance, otherwise "Swipe To Subscribe"</action>
-    <action>Verify the swipe knob is brand orange, as on the cancel and delete sheets</action>
+    <action>Verify the swipe knob is USDT teal when USDT is the only accepted payment method, otherwise brand orange</action>
     <action>Swipe the confirm control to the end</action>
     <action>If the first period was due on acceptance: complete the send flow that opens, then verify the Subscribed confirmation appears</action>
     <action>If no payment was due: verify the Subscribed confirmation appears directly, with no send flow</action>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index e28a65116..d8f8bcbdb 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -2,6 +2,7 @@
   <description>Use an onboarded wallet with USDT configured and another owned wallet's Arbitrum receive URI. No payment is submitted. Hardware-wallet send remains Bitcoin-only.</description>
   <actions>
     <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount screen preserves the recipient and exact input 0.010001 USDT; the review rounds its displayed value to $0.01. Verify no payment occurs without approval.</action>
+    <action>On iOS, copy the USDT receive URI, return to Home and accept the clipboard prompt. Verify the USDT amount screen opens with the copied recipient and amount. Cancel without paying. Repeat with a wrong-chain URI and verify no payment prompt appears.</action>
     <action>Cancel the send, then reopen the identical URI. Verify the amount or review screen opens again. Cancel and open a different owned recipient and amount, verifying only the new values appear.</action>
     <action>While a USDT contact amount screen or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
     <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index 1a7946026..0bd6019dd 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -1,7 +1,7 @@
 <journey name="usdt wallet navigation">
   <description>Use an onboarded wallet in an E2E build with USDT RPC and bundler URLs configured. No chain funding or live provider is required. A network error may be visible when services are offline; no payment is submitted.</description>
   <actions>
-    <action>On Home, verify the Savings/Spending and USDT balance dividers align vertically, including any hardware wallet rows.</action>
+    <action>On Home, verify the Savings/Spending and USDT balance dividers align vertically, including any hardware wallet rows. With an odd number of paired hardware wallets, verify USDT fills the last row’s empty cell; with an even number, it starts the next row.</action>
     <action>Verify USDT balances and activity amounts show at most two decimals; a nonzero amount below one cent shows &lt;0.01. Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet, with its Tether coin illustration anchored at the upper right.</action>
     <action>Open Receive. Verify the network is Arbitrum One. Open details, verify the address starts with 0x, and verify Details Copy contains only the address. Return to the QR and verify Copy contains the full USDT payment URI including the network and token. On Android, system Back from Details returns to the USDT QR; Back from the QR closes Receive without switching to Savings.</action>
     <action>Close Receive, open Send and manual entry. Enter an invalid Bitcoin address and verify the address error prevents continuing.</action>

From a3c73e8b0571f0d6d3ad57c592e18cdbefedb121 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 09:14:04 -0500
Subject: [PATCH 37/62] Implement USDT opt-in and updated Figma sheets

---
 Bitkit/AppScene.swift                         |  8 +++
 .../usdt-settings.imageset/Contents.json      | 16 +++++
 .../usdt-settings.imageset/usdt-settings.svg  |  5 ++
 Bitkit/MainNavView.swift                      |  5 ++
 .../TimedSheets/TimedSheetManager.swift       |  2 +
 .../TimedSheets/UsdtIntroTimedSheet.swift     | 17 +++++
 Bitkit/Managers/UsdtWalletManager.swift       | 33 +++++++++-
 Bitkit/Models/SettingsBackupConfig.swift      |  1 +
 Bitkit/Models/UsdtPreference.swift            | 27 ++++++++
 .../Localization/en.lproj/Localizable.strings |  9 +++
 Bitkit/Services/PublicPaykitService.swift     |  2 +-
 Bitkit/Styles/SheetStyles.swift               | 16 +++++
 Bitkit/Styles/TextStyle.swift                 |  7 ++-
 Bitkit/ViewModels/AppViewModel.swift          | 11 ++--
 Bitkit/ViewModels/SettingsViewModel.swift     |  8 +++
 Bitkit/ViewModels/SheetViewModel.swift        |  9 +++
 Bitkit/Views/Home/HomeWalletView.swift        | 15 +++--
 .../Views/Settings/GeneralSettingsView.swift  | 50 +++++++++++----
 .../PubkyAuthApprovalSheet.swift              | 55 +++++++++++++---
 Bitkit/Views/Sheets/Sheet.swift               | 28 +++++++--
 Bitkit/Views/Sheets/UsdtIntroSheet.swift      | 62 +++++++++++++++++++
 Bitkit/Views/Wallets/Receive/ReceiveQr.swift  | 24 ++++---
 .../Views/Wallets/Receive/ReceiveSheet.swift  | 18 +++++-
 .../Views/Wallets/Send/SendAmountView.swift   | 23 +++++--
 Bitkit/Views/Wallets/Sheets/ReceivedTx.swift  |  8 ++-
 Bitkit/Views/Wallets/UsdtNetworkPicker.swift  | 43 +++++++++++++
 .../Views/Wallets/UsdtReceiveAmountView.swift |  4 +-
 Bitkit/Views/Wallets/UsdtReceiveView.swift    | 35 ++++-------
 Bitkit/Views/Wallets/UsdtSendView.swift       | 51 +++++++++------
 BitkitTests/AddressTypeSettingsTests.swift    | 17 +++++
 .../PaykitPaymentRequestServiceTests.swift    |  6 ++
 BitkitTests/ShopPaymentRequestTests.swift     |  2 +
 BitkitTests/UsdtWalletManagerTests.swift      | 29 +++++++++
 BitkitUITests/UsdtWalletUITests.swift         |  4 ++
 Docs/USDT-QA.md                               |  2 +
 Docs/USDT.md                                  |  8 ++-
 changelog.d/next/884.added.md                 |  2 +-
 journeys/paykit-quoted-usdt.xml               |  1 +
 journeys/usdt-bridge-amount-errors.xml        |  1 +
 journeys/usdt-bridge-support.xml              |  1 +
 journeys/usdt-opt-in.xml                      | 14 +++++
 journeys/usdt-payment-links-and-scans.xml     |  1 +
 journeys/usdt-receive-amount-and-units.xml    |  1 +
 journeys/usdt-send-review-and-details.xml     |  3 +-
 journeys/usdt-wallet-navigation.xml           |  1 +
 45 files changed, 584 insertions(+), 101 deletions(-)
 create mode 100644 Bitkit/Assets.xcassets/usdt-settings.imageset/Contents.json
 create mode 100644 Bitkit/Assets.xcassets/usdt-settings.imageset/usdt-settings.svg
 create mode 100644 Bitkit/Managers/TimedSheets/UsdtIntroTimedSheet.swift
 create mode 100644 Bitkit/Models/UsdtPreference.swift
 create mode 100644 Bitkit/Views/Sheets/UsdtIntroSheet.swift
 create mode 100644 Bitkit/Views/Wallets/UsdtNetworkPicker.swift
 create mode 100644 journeys/usdt-opt-in.xml

diff --git a/Bitkit/AppScene.swift b/Bitkit/AppScene.swift
index 6572da50e..ccb98024c 100644
--- a/Bitkit/AppScene.swift
+++ b/Bitkit/AppScene.swift
@@ -659,6 +659,14 @@ struct AppScene: View {
 
     private var appEventContent: some View {
         paykitEventContent
+            .onChange(of: settings.usdtPreference) { _, _ in
+                PublicPaykitService.setCleanupPending(true)
+                Task {
+                    await retryPendingPaykitEndpointRemoval()
+                    let keys = contactsManager.contacts.map(\.publicKey)
+                    await PrivatePaykitService.shared.refreshSavedContactEndpoints(for: keys, savedPublicKeys: keys, wallet: wallet)
+                }
+            }
             .onChange(of: sheets.activeSheetConfiguration?.id) { _, activeSheetId in
                 guard activeSheetId == nil, !sheets.isReplacingSheet else { return }
                 scheduleNextIncomingPaykitItemPresentation()
diff --git a/Bitkit/Assets.xcassets/usdt-settings.imageset/Contents.json b/Bitkit/Assets.xcassets/usdt-settings.imageset/Contents.json
new file mode 100644
index 000000000..64cdec364
--- /dev/null
+++ b/Bitkit/Assets.xcassets/usdt-settings.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "usdt-settings.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/Bitkit/Assets.xcassets/usdt-settings.imageset/usdt-settings.svg b/Bitkit/Assets.xcassets/usdt-settings.imageset/usdt-settings.svg
new file mode 100644
index 000000000..1739da6cd
--- /dev/null
+++ b/Bitkit/Assets.xcassets/usdt-settings.imageset/usdt-settings.svg
@@ -0,0 +1,5 @@
+<svg preserveAspectRatio="none" overflow="visible" style="display: block;" width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g id="Dollar">
+<path id="$" d="M7.73598 15V13.5935C6.40576 13.5171 5.37539 13.1628 4.64486 12.5304C3.91433 11.8871 3.53271 11.0148 3.5 9.91355H5.7243C5.80062 10.4914 5.99688 10.933 6.31308 11.2383C6.64019 11.5327 7.11449 11.7126 7.73598 11.778V8.67056C7.69237 8.67056 7.66511 8.66511 7.65421 8.65421C7.17445 8.54517 6.78193 8.44704 6.47664 8.35981C6.17134 8.27259 5.82788 8.14174 5.44626 7.96729C5.07555 7.78193 4.78115 7.58567 4.56308 7.3785C4.35592 7.16044 4.17601 6.87695 4.02336 6.52804C3.88162 6.16822 3.81075 5.7648 3.81075 5.31776C3.81075 4.29283 4.16511 3.49143 4.87383 2.91355C5.59346 2.33567 6.54751 2.01947 7.73598 1.96495V1H8.71729V1.98131C9.82944 2.07944 10.7072 2.42835 11.3505 3.02804C12.0047 3.61682 12.3699 4.42368 12.4463 5.4486H10.271C10.162 4.55452 9.64408 4.0148 8.71729 3.82944V6.65888C8.7391 6.66978 8.77181 6.67523 8.81542 6.67523C9.41511 6.79517 9.92212 6.92601 10.3364 7.06776C10.7508 7.2095 11.1542 7.40576 11.5467 7.65654C11.9393 7.90732 12.2336 8.23442 12.4299 8.63785C12.6262 9.04128 12.7243 9.52103 12.7243 10.0771C12.7243 11.1456 12.3536 11.9907 11.6121 12.6121C10.8816 13.2227 9.91667 13.5553 8.71729 13.6098V15H7.73598ZM10.4346 10.3551C10.4346 9.96262 10.2928 9.66277 10.0093 9.45561C9.73676 9.24844 9.30607 9.06854 8.71729 8.91589V11.778C9.22975 11.7235 9.64408 11.5818 9.96028 11.3528C10.2765 11.1129 10.4346 10.7804 10.4346 10.3551ZM6.5257 4.20561C6.23131 4.42368 6.08411 4.71262 6.08411 5.07243C6.08411 5.43224 6.2095 5.71573 6.46028 5.9229C6.72196 6.11916 7.1472 6.29361 7.73598 6.44626V3.78037C7.22352 3.83489 6.82009 3.97664 6.5257 4.20561Z" fill="#FF4400"/>
+</g>
+</svg>
diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 9712038ef..45c41635f 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -215,6 +215,11 @@ struct MainNavView: View {
         ) {
             config in SecuritySheet(config: config)
         }
+        .sheet(item: $sheets.usdtIntroSheetItem, onDismiss: {
+            sheets.hideSheetIfActive(.usdtIntro, reason: "USDT intro dismissed")
+        }) { config in
+            UsdtIntroSheet(config: config)
+        }
         .sheet(
             item: $sheets.quickpaySheetItem,
             onDismiss: {
diff --git a/Bitkit/Managers/TimedSheets/TimedSheetManager.swift b/Bitkit/Managers/TimedSheets/TimedSheetManager.swift
index 2d5a771e8..30595ec31 100644
--- a/Bitkit/Managers/TimedSheets/TimedSheetManager.swift
+++ b/Bitkit/Managers/TimedSheets/TimedSheetManager.swift
@@ -71,6 +71,8 @@ class TimedSheetManager: ObservableObject {
         )
         registerSheet(notificationsSheet)
 
+        registerSheet(UsdtIntroTimedSheet(wallet: walletViewModel, settings: settingsViewModel))
+
         let quickpaySheet = QuickpayTimedSheet(appViewModel: appViewModel, walletViewModel: walletViewModel)
         registerSheet(quickpaySheet)
 
diff --git a/Bitkit/Managers/TimedSheets/UsdtIntroTimedSheet.swift b/Bitkit/Managers/TimedSheets/UsdtIntroTimedSheet.swift
new file mode 100644
index 000000000..63a3f02cf
--- /dev/null
+++ b/Bitkit/Managers/TimedSheets/UsdtIntroTimedSheet.swift
@@ -0,0 +1,17 @@
+import Foundation
+
+struct UsdtIntroTimedSheet: TimedSheetItem {
+    let id = SheetID.usdtIntro
+    let priority = TimedSheetPriority.medium
+    let sheetItem: any SheetItem = UsdtIntroSheetItem()
+    let wallet: WalletViewModel
+    let settings: SettingsViewModel
+
+    @MainActor
+    func shouldShow() async -> Bool {
+        Env.isUsdtEnabled && wallet.walletExists == true && settings.usdtPreference == .undecided
+    }
+
+    func onShown() {}
+    func onDismissed() {}
+}
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index 618f73aa2..6ec1999ba 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -5,6 +5,7 @@ import Observation
 
 enum UsdtWalletError: Error {
     case selfSend
+    case cannotDisable
 }
 
 @Observable @MainActor
@@ -41,6 +42,34 @@ final class UsdtWalletManager {
         Env.isUsdtEnabled
     }
 
+    var hasProtectedFunds: Bool {
+        UsdtPreference.protectsFunds(balance: balance, transfers: transfers)
+    }
+
+    func checkCanDisable() async throws {
+        try beginOperation()
+        defer { finishOperation() }
+        guard !isSendPresented else { throw UsdtWalletError.cannotDisable }
+        let wallet = try await wallet()
+        balance = try await wallet.balance()
+        transfers = try await wallet.refreshTransfers()
+        guard !hasProtectedFunds else { throw UsdtWalletError.cannotDisable }
+        if depositsConfigured {
+            var offset: UInt32 = 0
+            repeat {
+                let page = try await depositHistory(offset: offset)
+                for deposit in page.deposits where UsdtPreference.hasPendingDeposit(deposit.status) {
+                    let detail = try await depositDetail(id: deposit.id, offset: offset)
+                    guard !UsdtPreference.hasPendingDeposit(detail.order?.status ?? detail.deposit.status) else {
+                        throw UsdtWalletError.cannotDisable
+                    }
+                }
+                guard let next = page.nextOffset, next > offset else { break }
+                offset = next
+            } while true
+        }
+    }
+
     var networkName: String {
         "Arbitrum One"
     }
@@ -370,7 +399,9 @@ final class UsdtWalletManager {
     }
 
     static func message(for error: Error) -> String {
-        if error is UsdtWalletError { return t("usdt__error_self_send") }
+        if let error = error as? UsdtWalletError {
+            return t(error == .selfSend ? "usdt__error_self_send" : "usdt__disable_unavailable")
+        }
         guard let error = error as? UsdtError else { return t("usdt__error_network") }
         switch error {
         case .NotConfigured: return t("usdt__error_configuration")
diff --git a/Bitkit/Models/SettingsBackupConfig.swift b/Bitkit/Models/SettingsBackupConfig.swift
index c899e678c..ca9412d48 100644
--- a/Bitkit/Models/SettingsBackupConfig.swift
+++ b/Bitkit/Models/SettingsBackupConfig.swift
@@ -37,6 +37,7 @@ enum SettingsBackupConfig {
     ]
 
     static let settingsKeyTypes: [String: SettingKeyType] = [
+        UsdtPreference.key: .string(optional: true),
         "primaryDisplay": .string(optional: true),
         "bitcoinDisplayUnit": .string(optional: true),
         "selectedCurrency": .string(optional: true),
diff --git a/Bitkit/Models/UsdtPreference.swift b/Bitkit/Models/UsdtPreference.swift
new file mode 100644
index 000000000..4f11a8f36
--- /dev/null
+++ b/Bitkit/Models/UsdtPreference.swift
@@ -0,0 +1,27 @@
+import BitkitCore
+import Foundation
+
+enum UsdtPreference: String {
+    case undecided
+    case disabled
+    case enabled
+
+    static let key = "usdtPreference"
+
+    static func isEnabled(defaults: UserDefaults = .standard) -> Bool {
+        defaults.string(forKey: key) == enabled.rawValue
+    }
+
+    static func protectsFunds(balance: UInt64?, transfers: [UsdtTransfer]) -> Bool {
+        (balance ?? 0) > 0 || (balance == nil && !transfers.isEmpty) || transfers.contains { transfer in
+            switch transfer.status {
+            case .pending, .bridging, .bridgeNeedsAttention, .bridgeFailed: true
+            case .confirmed, .failed, .replaced, .bridgeRefunded: false
+            }
+        }
+    }
+
+    static func hasPendingDeposit(_ status: String) -> Bool {
+        !["completed", "refunded", "waiting", "awaiting_deposit", "expired"].contains(status)
+    }
+}
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 7b57ada51..b6519a0fd 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1961,3 +1961,12 @@
 "usdt__to_address" = "To address";
 
 "usdt__you_send" = "You send";
+
+"usdt__disable_unavailable" = "USDT must stay enabled while you have a balance or a pending transfer. Please wait for transfers to finish and check your balance before turning it off.";
+"usdt__enable" = "Enable USDT";
+"usdt__intro_description" = "Bitcoin at heart. Dollars when you need them. Enable USDT (Tether) to send and receive digital dollars with Bitkit.";
+"usdt__intro_headline" = "<accent>DOLLARS?</accent>\nYOUR CALL";
+"usdt__intro_title" = "New: USDT";
+"usdt__no_thanks" = "No Thanks";
+"usdt__send_network_note" = "Choose the network your recipient uses.";
+"usdt__settings_title" = "USDT (Tether)";
diff --git a/Bitkit/Services/PublicPaykitService.swift b/Bitkit/Services/PublicPaykitService.swift
index e7bae7c00..8f3aac182 100644
--- a/Bitkit/Services/PublicPaykitService.swift
+++ b/Bitkit/Services/PublicPaykitService.swift
@@ -472,7 +472,7 @@ enum PublicPaykitService {
     }
 
     static func isUsdtPaymentOptionEnabled(defaults: UserDefaults = .standard) -> Bool {
-        Env.isUsdtEnabled && (defaults.object(forKey: usdtPaymentOptionEnabledKey) as? Bool ?? true)
+        Env.isUsdtEnabled && UsdtPreference.isEnabled(defaults: defaults) && (defaults.object(forKey: usdtPaymentOptionEnabledKey) as? Bool ?? true)
     }
 
     static func hasLightningRouteHints(bolt11: String) -> Bool {
diff --git a/Bitkit/Styles/SheetStyles.swift b/Bitkit/Styles/SheetStyles.swift
index af8e4724b..30b6dd201 100644
--- a/Bitkit/Styles/SheetStyles.swift
+++ b/Bitkit/Styles/SheetStyles.swift
@@ -1,5 +1,21 @@
 import SwiftUI
 
+struct SheetBackgroundPreferenceKey: PreferenceKey {
+    static let defaultValue: Color? = nil
+
+    static func reduce(value: inout Color?, nextValue: () -> Color?) {
+        value = nextValue() ?? value
+    }
+}
+
+struct SheetDragIndicatorInsetPreferenceKey: PreferenceKey {
+    static let defaultValue: CGFloat? = nil
+
+    static func reduce(value: inout CGFloat?, nextValue: () -> CGFloat?) {
+        value = nextValue() ?? value
+    }
+}
+
 extension View {
     /// Applies the standard sheet gradient over the given base color. Default base is black;
     func sheetBackground(base: Color = .black) -> some View {
diff --git a/Bitkit/Styles/TextStyle.swift b/Bitkit/Styles/TextStyle.swift
index 574999f72..5e19e3f1d 100644
--- a/Bitkit/Styles/TextStyle.swift
+++ b/Bitkit/Styles/TextStyle.swift
@@ -13,6 +13,7 @@ struct DisplayText: View {
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
     var fillsWidth: Bool
+    var kerning: CGFloat
 
     private let fontSize: CGFloat = 44
 
@@ -22,7 +23,8 @@ struct DisplayText: View {
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
         accentAction: (() -> Void)? = nil,
-        fillsWidth: Bool = true
+        fillsWidth: Bool = true,
+        kerning: CGFloat = -1
     ) {
         self.text = text
         self.textColor = textColor
@@ -30,6 +32,7 @@ struct DisplayText: View {
         self.accentFont = accentFont
         self.accentAction = accentAction
         self.fillsWidth = fillsWidth
+        self.kerning = kerning
     }
 
     var body: some View {
@@ -41,7 +44,7 @@ struct DisplayText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
-        .kerning(-1)
+        .kerning(kerning)
         .environment(\._lineHeightMultiple, 0.83)
         .textCase(.uppercase)
         .padding(.bottom, -9)
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index 07ae48dfb..4dc697432 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -37,10 +37,10 @@ struct ContactPaymentContext: Equatable {
             incomingPaymentRequest.map { $0.amount.asset != .btc || $0.pricing.conversion != nil } == true
     }
 
-    func prefersUsdt(onchainBalanceSats: UInt64) -> Bool {
-        endpoints.contains { $0.methodId == .usdtArbitrum } &&
-            (incomingPaymentRequest.map { $0.amount.asset != .btc } == true ||
-                !endpoints.contains { $0.methodId != .usdtArbitrum } || onchainBalanceSats == 0)
+    func prefersUsdt(onchainBalanceSats: UInt64, isUsdtEnabled: Bool = true) -> Bool {
+        guard endpoints.contains(where: { $0.methodId == .usdtArbitrum }) else { return false }
+        if !endpoints.contains(where: { $0.methodId != .usdtArbitrum }) { return true }
+        return isUsdtEnabled && (incomingPaymentRequest.map { $0.amount.asset != .btc } == true || onchainBalanceSats == 0)
     }
 
     init(
@@ -675,7 +675,8 @@ extension AppViewModel {
                 }
                 try ensureScannedDataHandlingOwnership(handlingId, claimedContactPaymentContext: context)
             }
-            paykitUsesUsdt = context.prefersUsdt(onchainBalanceSats: lightningService.balances?.spendableOnchainBalanceSats ?? 0) ||
+            paykitUsesUsdt = context.prefersUsdt(onchainBalanceSats: lightningService.balances?.spendableOnchainBalanceSats ?? 0,
+                                                 isUsdtEnabled: SettingsViewModel.shared.isUsdtEnabled) ||
                 context.incomingPaymentRequest.map { PaykitUsdtPaymentService.shared.hasBinding(for: $0.id) } == true
             selectedWalletToPayFrom = scannedLightningInvoice != nil || lnurlPayData != nil ? .lightning : .onchain
             return
diff --git a/Bitkit/ViewModels/SettingsViewModel.swift b/Bitkit/ViewModels/SettingsViewModel.swift
index 214bda019..2bfd20894 100644
--- a/Bitkit/ViewModels/SettingsViewModel.swift
+++ b/Bitkit/ViewModels/SettingsViewModel.swift
@@ -99,6 +99,8 @@ class SettingsViewModel: NSObject, ObservableObject {
 
     @AppStorage("defaultTransactionSpeed") var defaultTransactionSpeed: TransactionSpeed = .normal
     @AppStorage("hideBalance") var hideBalance: Bool = false
+    @AppStorage(UsdtPreference.key) var usdtPreference: UsdtPreference = .undecided
+
     @AppStorage("hideBalanceOnOpen") var hideBalanceOnOpen: Bool = false
     @AppStorage("readClipboard") var readClipboard: Bool = false
     @AppStorage("warnWhenSendingOver100") var warnWhenSendingOver100: Bool = false
@@ -213,6 +215,7 @@ class SettingsViewModel: NSObject, ObservableObject {
         _swipeBalanceToHide = true
         defaultTransactionSpeed = .normal
         hideBalance = false
+        usdtPreference = .undecided
         hideBalanceOnOpen = false
         readClipboard = false
         warnWhenSendingOver100 = false
@@ -246,6 +249,10 @@ class SettingsViewModel: NSObject, ObservableObject {
 
     // MARK: - Computed Properties
 
+    var isUsdtEnabled: Bool {
+        Env.isUsdtEnabled && usdtPreference == .enabled
+    }
+
     var electrumHasEdited: Bool {
         let formHost = electrumHost.trimmingCharacters(in: .whitespaces)
         let formPort = electrumPort.trimmingCharacters(in: .whitespaces)
@@ -866,6 +873,7 @@ class SettingsViewModel: NSObject, ObservableObject {
 
     /// Re-read UserDefaults into @AppStorage properties after a direct defaults write.
     private func syncAppStorageFromDefaults() {
+        usdtPreference = UsdtPreference(rawValue: defaults.string(forKey: UsdtPreference.key) ?? "") ?? .undecided
         _swipeBalanceToHide = defaults.object(forKey: "swipeBalanceToHide") as? Bool ?? true
         defaultTransactionSpeed = TransactionSpeed(rawValue: defaults.string(forKey: "defaultTransactionSpeed") ?? "")
         hideBalance = defaults.bool(forKey: "hideBalance")
diff --git a/Bitkit/ViewModels/SheetViewModel.swift b/Bitkit/ViewModels/SheetViewModel.swift
index 710e186cc..c84b5bdec 100644
--- a/Bitkit/ViewModels/SheetViewModel.swift
+++ b/Bitkit/ViewModels/SheetViewModel.swift
@@ -17,6 +17,7 @@ enum SheetID: String, CaseIterable {
     case paymentRequests
     case subscription
     case quickpay
+    case usdtIntro
     case receive
     case receivedTx
     case btcpayConnection
@@ -318,6 +319,14 @@ class SheetViewModel: ObservableObject {
         }
     }
 
+    var usdtIntroSheetItem: UsdtIntroSheetItem? {
+        get {
+            guard activeSheetConfiguration?.id == .usdtIntro else { return nil }
+            return UsdtIntroSheetItem()
+        }
+        set { if newValue == nil { activeSheetConfiguration = nil } }
+    }
+
     var quickpaySheetItem: QuickpaySheetItem? {
         get {
             guard let config = activeSheetConfiguration, config.id == .quickpay else { return nil }
diff --git a/Bitkit/Views/Home/HomeWalletView.swift b/Bitkit/Views/Home/HomeWalletView.swift
index 94185ad6a..7a97c3242 100644
--- a/Bitkit/Views/Home/HomeWalletView.swift
+++ b/Bitkit/Views/Home/HomeWalletView.swift
@@ -11,15 +11,20 @@ struct HomeWalletView: View {
     @Environment(UsdtWalletManager.self) private var usdt
     @Environment(HwWalletManager.self) private var hwWalletManager
 
+    private var showsUsdt: Bool {
+        usdt.isConfigured && (settings.isUsdtEnabled || usdt.hasProtectedFunds)
+    }
+
     var hasActivity: Bool {
-        return activity.latestActivities?.isEmpty == false || !usdt.transfers.isEmpty
+        return activity.latestActivities?.isEmpty == false || (showsUsdt && !usdt.transfers.isEmpty)
     }
 
     /// Headline total including watch-only hardware-wallet balances (keeps `totalBalanceSats`
     /// semantics unchanged for send/transfer logic; only the headline folds hardware in).
     private var headlineSats: Int {
         let hw = Int(clamping: hwWalletManager.totalSats)
-        let usdtSats = usdt.balance.flatMap { usdtDisplaySats(amount: usdtFormatAmount(amount: $0), rate: currency.paykitRate) } ?? 0
+        let usdtSats = (showsUsdt ? usdt.balance : nil)
+            .flatMap { usdtDisplaySats(amount: usdtFormatAmount(amount: $0), rate: currency.paykitRate) } ?? 0
         return wallet.totalBalanceSats.saturatingAdd(hw).saturatingAdd(usdtSats)
     }
 
@@ -54,10 +59,10 @@ struct HomeWalletView: View {
                 }
             }
             .frame(height: 50)
-            .padding(.bottom, usdt.isConfigured && hwWalletManager.wallets.isEmpty ? 24 : 32)
+            .padding(.bottom, showsUsdt && hwWalletManager.wallets.isEmpty ? 24 : 32)
 
-            if !hwWalletManager.wallets.isEmpty || usdt.isConfigured {
-                HardwareWalletsGrid(wallets: hwWalletManager.wallets, showAdditionalWallet: usdt.isConfigured) { hwWallet in
+            if !hwWalletManager.wallets.isEmpty || showsUsdt {
+                HardwareWalletsGrid(wallets: hwWalletManager.wallets, showAdditionalWallet: showsUsdt) { hwWallet in
                     navigation.navigate(.hardwareWallet(walletId: hwWallet.id))
                 } additionalWallet: {
                     Button { navigation.navigate(.usdtWallet) } label: {
diff --git a/Bitkit/Views/Settings/GeneralSettingsView.swift b/Bitkit/Views/Settings/GeneralSettingsView.swift
index a5cdf28f8..b1effbe5d 100644
--- a/Bitkit/Views/Settings/GeneralSettingsView.swift
+++ b/Bitkit/Views/Settings/GeneralSettingsView.swift
@@ -6,6 +6,9 @@ struct GeneralSettingsView: View {
     @AppStorage(PrivatePaykitService.publishingEnabledKey) private var sharesPrivatePaykitEndpoints = false
     @AppStorage(PublicPaykitService.publishingEnabledKey) private var sharesPublicPaykitEndpoints = false
 
+    @Environment(UsdtWalletManager.self) private var usdt
+    @State private var isUpdatingUsdt = false
+
     @Environment(HwWalletManager.self) private var hwWalletManager
 
     @EnvironmentObject var app: AppViewModel
@@ -101,17 +104,6 @@ struct GeneralSettingsView: View {
                 }
                 .accessibilityIdentifier("TransactionSpeedSettings")
 
-                if isPaykitUIActive, pubkyProfile.isAuthenticated {
-                    SettingsRow(
-                        title: t("profile__pay_contacts_toggle"),
-                        iconName: "list-dashes",
-                        rightIcon: nil,
-                        toggle: contactPaymentsToggle,
-                        disabled: isUpdatingContactPayments,
-                        testIdentifier: "ContactPaymentsToggle"
-                    )
-                }
-
                 NavigationLink(value: app.hasSeenQuickpayIntro ? Route.quickpay : Route.quickpayIntro) {
                     SettingsRow(
                         title: t("settings__quickpay__nav_title"),
@@ -138,6 +130,28 @@ struct GeneralSettingsView: View {
                     )
                 }
                 .accessibilityIdentifier("HardwareWalletsSettings")
+
+                if isPaykitUIActive, pubkyProfile.isAuthenticated {
+                    SettingsRow(
+                        title: t("profile__pay_contacts_toggle"),
+                        iconName: "list-dashes",
+                        rightIcon: nil,
+                        toggle: contactPaymentsToggle,
+                        disabled: isUpdatingContactPayments,
+                        testIdentifier: "ContactPaymentsToggle"
+                    )
+                }
+
+                if usdt.isConfigured {
+                    SettingsRow(
+                        title: t("usdt__settings_title"),
+                        iconName: "usdt-settings",
+                        rightIcon: nil,
+                        toggle: Binding(get: { settings.isUsdtEnabled }, set: { enabled in Task { await updateUsdt(enabled) } }),
+                        disabled: isUpdatingUsdt,
+                        testIdentifier: "UsdtSettingsToggle"
+                    )
+                }
             }
             .padding(.top, 16)
             .padding(.horizontal, 16)
@@ -156,6 +170,19 @@ struct GeneralSettingsView: View {
         }
     }
 
+    private func updateUsdt(_ enabled: Bool) async {
+        guard !isUpdatingUsdt else { return }
+        isUpdatingUsdt = true
+        defer { isUpdatingUsdt = false }
+        do {
+            if !enabled { try await usdt.checkCanDisable() }
+            settings.usdtPreference = enabled ? .enabled : .disabled
+        } catch is CancellationError {
+        } catch {
+            app.toast(type: .warning, title: t("usdt__settings_title"), description: t("usdt__disable_unavailable"))
+        }
+    }
+
     private func updateContactPayments(_ enabled: Bool) async {
         guard !isUpdatingContactPayments else { return }
 
@@ -192,6 +219,7 @@ struct GeneralSettingsView: View {
             .environmentObject(AppViewModel())
             .environmentObject(WalletViewModel())
             .environment(HwWalletManager())
+            .environment(UsdtWalletManager())
     }
     .preferredColorScheme(.dark)
 }
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index 1f8283be2..1cfb882e5 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -82,7 +82,8 @@ struct PubkyAuthApprovalSheet: View {
     @State private var usdtAddress: String?
     @State private var usdtUnavailable = false
     @State private var showsUsdtAddress = false
-    @State private var shareUsdt = true
+    @State private var shareUsdt = false
+    @State private var showsUsdtEnablePrompt = false
 
     private var createsIdentity: Bool {
         Self.requiresIdentityCreation(for: config.request, profile: pubkyProfile)
@@ -143,13 +144,36 @@ struct PubkyAuthApprovalSheet: View {
 
     var body: some View {
         Sheet(id: .pubkyAuthApproval, data: config) {
-            if state == .watchOnlyConsent {
+            if showsUsdtEnablePrompt {
+                UsdtIntroContent(
+                    isEnablePrompt: true,
+                    onDecline: { showsUsdtEnablePrompt = false },
+                    onEnable: {
+                        settings.usdtPreference = .enabled
+                        shareUsdt = true
+                        showsUsdtEnablePrompt = false
+                        Task { await loadUsdtAddress() }
+                    }
+                )
+            } else if state == .watchOnlyConsent {
                 watchOnlyConsentContent
             } else {
                 authorizationFlowContent
             }
         }
-        .task { await loadUsdtAddress() }
+        .task {
+            shareUsdt = settings.isUsdtEnabled
+            showsUsdtEnablePrompt = config.request.bitkitClaim?.sharesUsdt == true
+                && config.request.bitkitClaim?.sharesBitcoin != true
+                && !settings.isUsdtEnabled
+            await loadUsdtAddress()
+        }
+        .onChange(of: settings.isUsdtEnabled) { _, enabled in
+            if !enabled {
+                shareUsdt = false
+                usdtAddress = nil
+            }
+        }
         .interactiveDismissDisabled(!state.canDismiss)
         .fullScreenCover(isPresented: $isShowingAuthCheck) {
             AuthCheck(
@@ -397,13 +421,22 @@ struct PubkyAuthApprovalSheet: View {
             }
             if config.request.bitkitClaim?.sharesUsdt == true {
                 VStack(alignment: .leading, spacing: 8) {
-                    Toggle(isOn: $shareUsdt) {
+                    Toggle(isOn: Binding(
+                        get: { shareUsdt },
+                        set: { share in
+                            if share, !settings.isUsdtEnabled {
+                                showsUsdtEnablePrompt = true
+                            } else {
+                                shareUsdt = share
+                            }
+                        }
+                    )) {
                         BodySSBText(t("pubky_auth__share_usdt_optional"), textColor: .usdtAccent)
                     }
                     .tint(.usdtAccent)
                     .disabled(state == .authorizing)
                     .accessibilityIdentifier("PubkyAuthShareUsdt")
-                    if let usdtAddress {
+                    if settings.isUsdtEnabled, let usdtAddress {
                         Button { showsUsdtAddress.toggle() } label: {
                             BodySText(showsUsdtAddress ? usdtAddress : String(usdtAddress.prefix(8)) + "…" + String(usdtAddress.suffix(6)))
                                 .multilineTextAlignment(.leading)
@@ -414,11 +447,11 @@ struct PubkyAuthApprovalSheet: View {
                                 .tint(.usdtAccent)
                                 .accessibilityIdentifier("PubkyAuthCopyUsdtAddress")
                         }
-                    } else if usdtUnavailable {
+                    } else if settings.isUsdtEnabled, usdtUnavailable {
                         BodySText(t("pubky_auth__usdt_unavailable"), textColor: .white64)
                         Button(t("common__retry")) { Task { await loadUsdtAddress() } }
                             .tint(.usdtAccent)
-                    } else {
+                    } else if settings.isUsdtEnabled {
                         ProgressView()
                     }
                     BodySText(t("pubky_auth__usdt_privacy"), textColor: .white64)
@@ -431,11 +464,13 @@ struct PubkyAuthApprovalSheet: View {
     }
 
     private func loadUsdtAddress() async {
-        guard config.request.bitkitClaim?.sharesUsdt == true else { return }
+        guard config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled else { return }
         usdtAddress = nil
         usdtUnavailable = false
         do {
-            usdtAddress = try await usdt.paymentEndpoint().value
+            let address = try await usdt.paymentEndpoint().value
+            guard settings.isUsdtEnabled else { return }
+            usdtAddress = address
         } catch {
             usdtAddress = nil
             usdtUnavailable = true
@@ -612,7 +647,7 @@ struct PubkyAuthApprovalSheet: View {
                 authUrl: config.request.rawUrl,
                 accountName: watchOnlyAccountName,
                 secretKeyHex: secretKey,
-                approvedUsdtAddress: shareUsdt ? usdtAddress : nil,
+                approvedUsdtAddress: shareUsdt && settings.isUsdtEnabled ? usdtAddress : nil,
                 usdtEndpoint: { try await usdt.paymentEndpoint() }
             )
 
diff --git a/Bitkit/Views/Sheets/Sheet.swift b/Bitkit/Views/Sheets/Sheet.swift
index 6bfbbfc28..bc8fef259 100644
--- a/Bitkit/Views/Sheets/Sheet.swift
+++ b/Bitkit/Views/Sheets/Sheet.swift
@@ -50,17 +50,26 @@ struct SheetHeader: View {
     let title: String
     let showBackButton: Bool
     let action: AnyView?
+    let topPadding: CGFloat
+    let bottomPadding: CGFloat
+    let dragIndicatorTopPadding: CGFloat?
     let onBack: (() -> Void)?
 
     init(
         title: String,
         showBackButton: Bool = false,
         action: AnyView? = nil,
+        topPadding: CGFloat = 32,
+        bottomPadding: CGFloat = 24,
+        dragIndicatorTopPadding: CGFloat? = nil,
         onBack: (() -> Void)? = nil
     ) {
         self.title = title
         self.showBackButton = showBackButton
         self.action = action
+        self.topPadding = topPadding
+        self.bottomPadding = bottomPadding
+        self.dragIndicatorTopPadding = dragIndicatorTopPadding
         self.onBack = onBack
     }
 
@@ -96,8 +105,9 @@ struct SheetHeader: View {
                     .frame(width: 24, height: 24)
             }
         }
-        .padding(.top, 32) // Make room for the drag indicator
-        .padding(.bottom, 24)
+        .padding(.top, topPadding)
+        .padding(.bottom, bottomPadding)
+        .preference(key: SheetDragIndicatorInsetPreferenceKey.self, value: dragIndicatorTopPadding)
     }
 }
 
@@ -110,9 +120,12 @@ protocol SheetItem: Identifiable {
 
 struct Sheet<Content: View>: View {
     @EnvironmentObject private var sheets: SheetViewModel
+    @State private var contentBackground: Color?
+    @State private var contentDragIndicatorInset: CGFloat?
     let configuration: SheetConfiguration
     let backgroundColor: Color
     let applyGradient: Bool
+    let dragIndicatorInset: CGFloat?
     let content: () -> Content
 
     init(
@@ -120,11 +133,13 @@ struct Sheet<Content: View>: View {
         data: (any SheetItem)? = nil,
         backgroundColor: Color = .black,
         applyGradient: Bool = true,
+        dragIndicatorInset: CGFloat? = nil,
         @ViewBuilder content: @escaping () -> Content
     ) {
         configuration = SheetConfiguration(id: id, data: data)
         self.backgroundColor = backgroundColor
         self.applyGradient = applyGradient
+        self.dragIndicatorInset = dragIndicatorInset
         self.content = content
     }
 
@@ -138,20 +153,23 @@ struct Sheet<Content: View>: View {
     var body: some View {
         ZStack(alignment: .top) {
             content()
-                .modifier(SheetBackgroundModifier(base: backgroundColor, applyGradient: applyGradient))
+                .modifier(SheetBackgroundModifier(base: contentBackground ?? backgroundColor,
+                                                  applyGradient: contentBackground == nil && applyGradient))
                 .bottomSafeAreaPadding()
 
             // Custom drag indicator - always on top
             RoundedRectangle(cornerRadius: 2)
                 .fill(Color.white32)
                 .frame(width: 32, height: 4)
-                .padding(.top, 12)
+                .padding(.top, dragIndicatorInset ?? contentDragIndicatorInset ?? 12)
         }
+        .onPreferenceChange(SheetBackgroundPreferenceKey.self) { contentBackground = $0 }
+        .onPreferenceChange(SheetDragIndicatorInsetPreferenceKey.self) { contentDragIndicatorInset = $0 }
         .presentationBackgroundInteraction(.disabled)
         // The system adds the bottom safe area to a fixed-height detent.
         .presentationDetents([.height(sheetSize.height - windowSafeAreaInsets.bottom)])
         .presentationDragIndicator(.hidden)
         .presentationCornerRadius(32)
-        .presentationBackground { backgroundColor }
+        .presentationBackground { contentBackground ?? backgroundColor }
     }
 }
diff --git a/Bitkit/Views/Sheets/UsdtIntroSheet.swift b/Bitkit/Views/Sheets/UsdtIntroSheet.swift
new file mode 100644
index 000000000..912ac620f
--- /dev/null
+++ b/Bitkit/Views/Sheets/UsdtIntroSheet.swift
@@ -0,0 +1,62 @@
+import SwiftUI
+
+struct UsdtIntroSheetItem: SheetItem {
+    let id: SheetID = .usdtIntro
+    let size: SheetSize = .large
+}
+
+struct UsdtIntroSheet: View {
+    @EnvironmentObject private var settings: SettingsViewModel
+    @EnvironmentObject private var sheets: SheetViewModel
+    let config: UsdtIntroSheetItem
+
+    var body: some View {
+        Sheet(id: .usdtIntro, data: config, backgroundColor: .gray7, applyGradient: false) {
+            UsdtIntroContent(onDecline: {
+                settings.usdtPreference = .disabled
+                sheets.hideSheet()
+            }, onEnable: {
+                settings.usdtPreference = .enabled
+                sheets.hideSheet()
+            })
+        }
+    }
+}
+
+struct UsdtIntroContent: View {
+    var isEnablePrompt = false
+    let onDecline: () -> Void
+    let onEnable: () -> Void
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            SheetHeader(title: t(isEnablePrompt ? "usdt__enable" : "usdt__intro_title"), topPadding: 28, bottomPadding: 22,
+                        dragIndicatorTopPadding: 8)
+            GeometryReader { geometry in
+                ScrollView(showsIndicators: false) {
+                    VStack(alignment: .leading, spacing: 32) {
+                        UsdtCoinIllustration().frame(maxWidth: .infinity)
+                        VStack(alignment: .leading, spacing: 8) {
+                            DisplayText(t("usdt__intro_headline"), accentColor: .usdtAccent, kerning: -2)
+                            BodyMText(t("usdt__intro_description"), textColor: .textSecondary)
+                        }
+                    }
+                    .frame(minHeight: geometry.size.height, alignment: .bottom)
+                }
+            }
+            HStack(spacing: 16) {
+                CustomButton(title: t(isEnablePrompt ? "common__cancel" : "usdt__no_thanks"), variant: .secondary, shouldExpand: true,
+                             action: onDecline)
+                    .accessibilityIdentifier(isEnablePrompt ? "UsdtEnablePromptCancel" : "UsdtIntroDecline")
+                CustomButton(title: t("usdt__enable"), shouldExpand: true, action: onEnable)
+                    .accessibilityIdentifier(isEnablePrompt ? "UsdtEnablePromptContinue" : "UsdtIntroEnable")
+            }
+            .padding(.top, 32)
+        }
+        .padding(.horizontal, 16)
+        .background(Color.gray7)
+        .preference(key: SheetBackgroundPreferenceKey.self, value: .gray7)
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier(isEnablePrompt ? "UsdtEnablePrompt" : "UsdtIntro")
+    }
+}
diff --git a/Bitkit/Views/Wallets/Receive/ReceiveQr.swift b/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
index 9beeeaa04..5c5945e95 100644
--- a/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
+++ b/Bitkit/Views/Wallets/Receive/ReceiveQr.swift
@@ -3,6 +3,7 @@ import SwiftUI
 struct ReceiveQr: View {
     @AppStorage(PaykitFeatureFlags.uiEnabledKey) private var isPaykitUIEnabled = PaykitFeatureFlags.uiEnabledByDefault
 
+    @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var app: AppViewModel
     @EnvironmentObject private var blocktank: BlocktankViewModel
     @EnvironmentObject private var wallet: WalletViewModel
@@ -13,6 +14,7 @@ struct ReceiveQr: View {
     let cjitInvoice: String?
     let tab: ReceiveTab?
     let hardwareWalletId: String?
+    let onUsdtSelectionChange: ((Bool) -> Void)?
 
     @State private var needsInvoiceRefresh: Bool
     @State private var invoiceRefreshFailed = false
@@ -34,12 +36,14 @@ struct ReceiveQr: View {
         navigationPath: Binding<[ReceiveRoute]>,
         cjitInvoice: String? = nil,
         tab: ReceiveTab? = nil,
-        hardwareWalletId: String? = nil
+        hardwareWalletId: String? = nil,
+        onUsdtSelectionChange: ((Bool) -> Void)? = nil
     ) {
         _navigationPath = navigationPath
         self.cjitInvoice = cjitInvoice
         self.tab = tab
         self.hardwareWalletId = hardwareWalletId
+        self.onUsdtSelectionChange = onUsdtSelectionChange
 
         // Default to unified tab if available, otherwise use provided tab or savings
         let defaultTab: ReceiveTab = if tab != nil {
@@ -85,7 +89,7 @@ struct ReceiveQr: View {
         if selectedHardwareWalletId != nil {
             items.insert(TabItem(.hardware, label: selectedHardwareWallet?.vendor.modelName), at: 0)
         }
-        if usdt.isConfigured, cjitInvoice == nil { items.append(TabItem(.usdt)) }
+        if settings.isUsdtEnabled, cjitInvoice == nil { items.append(TabItem(.usdt)) }
         return items
     }
 
@@ -118,6 +122,7 @@ struct ReceiveQr: View {
                 selectedTab = newTab
                 hasUserSelectedTab = true
                 hasAppliedDefaultTab = true
+                onUsdtSelectionChange?(newTab == .usdt)
             }
         )
     }
@@ -127,10 +132,15 @@ struct ReceiveQr: View {
     }
 
     var body: some View {
-        if selectedTab == .usdt {
-            UsdtReceiveView(tabs: availableTabItems, onSelectTab: { selectedTabBinding.wrappedValue = $0 }, contactAction: paymentRequestAction)
-        } else {
-            bitcoinContent
+        Group {
+            if selectedTab == .usdt, !settings.isUsdtEnabled {
+                UsdtIntroContent(isEnablePrompt: true, onDecline: { selectedTabBinding.wrappedValue = .savings },
+                                 onEnable: { settings.usdtPreference = .enabled })
+            } else if selectedTab == .usdt {
+                UsdtReceiveView(tabs: availableTabItems, onSelectTab: { selectedTabBinding.wrappedValue = $0 }, contactAction: paymentRequestAction)
+            } else {
+                bitcoinContent
+            }
         }
     }
 
@@ -157,7 +167,7 @@ struct ReceiveQr: View {
                     }
 
                     tabContent(for: .spending)
-                    if usdt.isConfigured, cjitInvoice == nil { Color.clear.tag(ReceiveTab.usdt) }
+                    if settings.isUsdtEnabled, cjitInvoice == nil { Color.clear.tag(ReceiveTab.usdt) }
                 }
                 .tabViewStyle(PageTabViewStyle(indexDisplayMode: .never))
                 .indexViewStyle(PageIndexViewStyle(backgroundDisplayMode: .always))
diff --git a/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift b/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
index fad6d5447..14afa98d0 100644
--- a/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
+++ b/Bitkit/Views/Wallets/Receive/ReceiveSheet.swift
@@ -57,9 +57,18 @@ struct ReceiveSheet: View {
     let config: ReceiveSheetItem
 
     @State private var navigationPath: [ReceiveRoute] = []
+    @State private var isUsdtSelected: Bool?
+
+    private var usesUsdtHeader: Bool {
+        switch navigationPath.last ?? config.initialRoute {
+        case .usdt: isUsdtSelected ?? true
+        case let .qr(_, tab): isUsdtSelected ?? (tab == .usdt)
+        default: false
+        }
+    }
 
     var body: some View {
-        Sheet(id: .receive, data: config) {
+        Sheet(id: .receive, data: config, dragIndicatorInset: usesUsdtHeader ? 8 : 12) {
             NavigationStack(path: $navigationPath) {
                 viewForRoute(config.initialRoute)
                     .navigationDestination(for: ReceiveRoute.self) { route in
@@ -102,13 +111,16 @@ struct ReceiveSheet: View {
     @ViewBuilder
     private func viewForRoute(_ route: ReceiveRoute) -> some View {
         switch route {
-        case .usdt: ReceiveQr(navigationPath: $navigationPath, tab: .usdt, hardwareWalletId: config.hardwareWalletId)
+        case .usdt:
+            ReceiveQr(navigationPath: $navigationPath, tab: .usdt, hardwareWalletId: config.hardwareWalletId,
+                      onUsdtSelectionChange: { isUsdtSelected = $0 })
         case let .qr(cjitInvoice, tab):
             ReceiveQr(
                 navigationPath: $navigationPath,
                 cjitInvoice: cjitInvoice,
                 tab: tab,
-                hardwareWalletId: config.hardwareWalletId
+                hardwareWalletId: config.hardwareWalletId,
+                onUsdtSelectionChange: { isUsdtSelected = $0 }
             )
         case let .edit(tab, onchainOnly, replacesCurrentQr):
             ReceiveEdit(navigationPath: $navigationPath, sourceTab: tab, onchainOnly: onchainOnly, replacesCurrentQr: replacesCurrentQr) { draft in
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index 3077db4d0..48e4462b7 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -8,6 +8,7 @@ enum SendFundingSource: Equatable {
 }
 
 struct SendAmountView: View {
+    @Environment(\.dismiss) private var dismiss
     @EnvironmentObject var app: AppViewModel
     @EnvironmentObject var currency: CurrencyViewModel
     @EnvironmentObject var settings: SettingsViewModel
@@ -51,7 +52,8 @@ struct SendAmountView: View {
                 return .hardware(walletId: hardwareWallet.walletId)
             })
         }
-        if app.contactPaymentContext?.endpoints.contains(where: { $0.methodId == .usdtArbitrum }) == true { sources.append(.usdt) }
+        if settings.isUsdtEnabled,
+           app.contactPaymentContext?.endpoints.contains(where: { $0.methodId == .usdtArbitrum }) == true { sources.append(.usdt) }
         return sources
     }
 
@@ -118,11 +120,23 @@ struct SendAmountView: View {
     }
 
     var body: some View {
+        if app.paykitUsesUsdt, !settings.isUsdtEnabled {
+            UsdtIntroContent(isEnablePrompt: true, onDecline: { dismiss() },
+                             onEnable: { settings.usdtPreference = .enabled })
+        } else {
+            content
+        }
+    }
+
+    private var content: some View {
         VStack(spacing: 0) {
             SheetHeader(
                 title: t("wallet__send_amount"),
                 showBackButton: true,
-                action: AnyView(SendContactHeaderAvatar())
+                action: AnyView(SendContactHeaderAvatar()),
+                topPadding: app.paykitUsesUsdt ? 28 : 32,
+                bottomPadding: app.paykitUsesUsdt ? 22 : 24,
+                dragIndicatorTopPadding: app.paykitUsesUsdt ? 8 : nil
             )
 
             VStack(alignment: .leading, spacing: 0) {
@@ -226,7 +240,8 @@ struct SendAmountView: View {
         .accessibilityIdentifier("SendAmount")
         .navigationBarHidden(true)
         .padding(.horizontal, 16)
-        .sheetBackground()
+        .modifier(SheetBackgroundModifier(base: app.paykitUsesUsdt ? .gray7 : .black, applyGradient: !app.paykitUsesUsdt))
+        .preference(key: SheetBackgroundPreferenceKey.self, value: app.paykitUsesUsdt ? .gray7 : nil)
         .onAppear {
             if !fundingSources.contains(selectedFundingSource), let firstSource = fundingSources.first {
                 selectFundingSource(firstSource)
@@ -404,7 +419,7 @@ struct SendAmountView: View {
     private var fundingSourceMenu: some View {
         let sources: [SendFundingSource] = [.savings, .spending] + hwWalletManager.wallets.map {
             .hardware(walletId: $0.walletId)
-        } + [.usdt]
+        } + (settings.isUsdtEnabled || app.paykitUsesUsdt ? [.usdt] : [])
         return VStack(alignment: .leading, spacing: 0) {
             ForEach(sources.indices, id: \.self) { index in
                 let source = sources[index]
diff --git a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
index 478d8c97c..df1730f22 100644
--- a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
+++ b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
@@ -33,7 +33,9 @@ struct ReceivedTx: View {
         let title = config.details.usdtAmount != nil ? t("usdt__payment_received")
             : isOnchain ? t("wallet__payment_received") : t("wallet__instant_payment_received")
 
-        Sheet(id: .receivedTx, data: config) {
+        Sheet(id: .receivedTx, data: config, backgroundColor: config.details.usdtAmount != nil ? .gray7 : .black,
+              applyGradient: config.details.usdtAmount == nil)
+        {
             ZStack {
                 PaymentCelebration(
                     isOnchain: isOnchain, isReceived: true,
@@ -41,7 +43,9 @@ struct ReceivedTx: View {
                 )
 
                 VStack(alignment: .leading, spacing: 0) {
-                    SheetHeader(title: title)
+                    SheetHeader(title: title, topPadding: config.details.usdtAmount != nil ? 28 : 32,
+                                bottomPadding: config.details.usdtAmount != nil ? 22 : 24,
+                                dragIndicatorTopPadding: config.details.usdtAmount != nil ? 8 : nil)
                     if let amount = config.details.usdtAmount {
                         UsdtAmountHeader(amount: usdtFormatAmount(amount: amount), displayAmount: usdtOverviewAmount(amount))
                             .accessibilityIdentifier("ReceivedTransaction")
diff --git a/Bitkit/Views/Wallets/UsdtNetworkPicker.swift b/Bitkit/Views/Wallets/UsdtNetworkPicker.swift
new file mode 100644
index 000000000..66b22cda2
--- /dev/null
+++ b/Bitkit/Views/Wallets/UsdtNetworkPicker.swift
@@ -0,0 +1,43 @@
+import SwiftUI
+
+struct UsdtNetworkRow: View {
+    let title: String
+    let selected: Bool
+    let identifier: String
+    let onSelect: () -> Void
+
+    var body: some View {
+        Button(action: onSelect) {
+            HStack(spacing: 16) {
+                Image("tether-circle").resizable().scaledToFit().frame(width: 40, height: 40)
+                BodyMSBText(title)
+                Spacer(minLength: 0)
+                if selected {
+                    Image("check-mark").resizable().scaledToFit().frame(width: 20, height: 20).foregroundColor(.usdtAccent)
+                }
+            }
+            .padding(16).background(Color.gray6).clipShape(RoundedRectangle(cornerRadius: 16))
+        }
+        .buttonStyle(.plain)
+        .accessibilityIdentifier(identifier)
+        .accessibilityAddTraits(selected ? .isSelected : [])
+    }
+}
+
+struct UsdtNetworkPicker<Rows: View>: View {
+    let note: String
+    @ViewBuilder var rows: () -> Rows
+
+    var body: some View {
+        ScrollView(showsIndicators: false) {
+            VStack(spacing: 8) {
+                rows()
+                BodySText(note, textColor: .textSecondary)
+                    .frame(maxWidth: .infinity, alignment: .leading).padding(.vertical, 16)
+                UsdtCoinIllustration()
+            }
+        }
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("UsdtNetworkPicker")
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
index 33fc5ee73..e2937213e 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
@@ -22,13 +22,13 @@ struct UsdtReceiveAmountView: View {
                         .padding(.bottom, 16)
                 }
             }
-            .frame(minHeight: 156, alignment: .top)
+            .frame(minHeight: 146, alignment: .top)
             .fixedSize(horizontal: false, vertical: true)
             Divider()
             NumberPad(type: .decimal, isDisabled: busy, onDeleteLongPress: { amount = "" }) { key in
                 amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
             }
-            .padding(.top, 24)
+            .padding(.top, 34)
             Spacer(minLength: 24)
             CustomButton(title: t("common__continue"), isDisabled: !canContinue, isLoading: busy, action: onContinue)
                 .accessibilityIdentifier("UsdtDepositCreate")
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index a245a2110..6efad8f9f 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -42,6 +42,7 @@ struct UsdtReceiveView: View {
     var body: some View {
         VStack(spacing: 0) {
             SheetHeader(title: title, showBackButton: page != .address, action: page == .address ? contactAction : nil,
+                        topPadding: 28, bottomPadding: 22, dragIndicatorTopPadding: 8,
                         onBack: {
                             if page == .amount { draftAmount = amount; error = nil }
                             if page == .fees { page = .amount }
@@ -72,6 +73,8 @@ struct UsdtReceiveView: View {
             }
         }
         .padding(.horizontal, 16)
+        .background(Color.gray7)
+        .preference(key: SheetBackgroundPreferenceKey.self, value: .gray7)
         .onReceive(usdt.receivedTxPublisher) { transfer in
             guard !historyBlocking, sheets.activeSheetConfiguration?.id == .receive else { return }
             sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: transfer.amount, usdtTransferId: transfer.id))
@@ -90,39 +93,27 @@ struct UsdtReceiveView: View {
     }
 
     private var networkList: some View {
-        ScrollView {
-            VStack(spacing: 8) {
+        VStack(spacing: 16) {
+            UsdtNetworkPicker(note: t("usdt__receive_network_note")) {
                 networkRow(nil)
                 ForEach(networks, id: \.self) { networkRow($0) }
-                BodySText(t("usdt__receive_network_note"), textColor: .textSecondary)
-                    .frame(maxWidth: .infinity, alignment: .leading).padding(.vertical, 16)
-                UsdtCoinIllustration()
-                if usdt.depositsConfigured {
-                    CustomButton(title: t("usdt__deposit_history"), variant: .tertiary) { page = .history }
-                        .accessibilityIdentifier("UsdtDepositHistory")
-                }
-                if let error { BodySText(error, textColor: .textSecondary) }
             }
+            if usdt.depositsConfigured {
+                CustomButton(title: t("usdt__deposit_history"), variant: .tertiary) { page = .history }
+                    .accessibilityIdentifier("UsdtDepositHistory")
+            }
+            if let error { BodySText(error, textColor: .textSecondary) }
         }
     }
 
     private func networkRow(_ item: UsdtDepositNetwork?) -> some View {
-        Button {
+        UsdtNetworkRow(title: item?.label ?? "Arbitrum One", selected: network == item,
+                       identifier: "UsdtNetwork-\(item?.label ?? "Arbitrum")")
+        {
             if network != item { deposit = nil; amount = ""; draftAmount = ""; error = nil }
             network = item
             page = item == nil || deposit != nil ? .address : .amount
-        } label: {
-            HStack(spacing: 16) {
-                Image("tether-circle").resizable().scaledToFit().frame(width: 40, height: 40)
-                BodyMSBText(item?.label ?? "Arbitrum One")
-                if item == nil { BodySText(t("common__default"), textColor: .textSecondary) }
-                Spacer()
-                if network == item { Image("check-mark").resizable().frame(width: 24, height: 24).foregroundColor(.usdtAccent) }
-            }
-            .padding(16).background(Color.gray6).clipShape(RoundedRectangle(cornerRadius: 16))
         }
-        .buttonStyle(.plain)
-        .accessibilityIdentifier("UsdtNetwork-\(item?.label ?? "Arbitrum")")
     }
 
     private var amountEntry: some View {
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 1f7a6b26e..70a4974f0 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -17,6 +17,7 @@ struct UsdtSendView: View {
     @EnvironmentObject private var settings: SettingsViewModel
     @Environment(\.dismiss) private var dismiss
     @Environment(\.scenePhase) private var scenePhase
+    @State private var showingNetworks = false
     @State private var recipient = ""
     @State private var amount = ""
     @State private var destination: UsdtDestination = .arbitrum
@@ -91,6 +92,7 @@ struct UsdtSendView: View {
     }
 
     private var title: String {
+        if showingNetworks { return t("usdt__receive_network_title") }
         if submitted, !busy {
             if submittedStatus == .confirmed { return t("usdt__payment_sent") }
             if submittedStatus == .bridgeRefunded { return t("usdt__deposit_refunded") }
@@ -103,17 +105,22 @@ struct UsdtSendView: View {
 
     var body: some View {
         Group {
-            if embedded { content }
+            if !settings.isUsdtEnabled, !submitted {
+                UsdtIntroContent(isEnablePrompt: true, onDecline: {
+                    if let onClose { onClose() } else { dismiss() }
+                }, onEnable: { settings.usdtPreference = .enabled })
+            } else if embedded { content }
             else { NavigationStack { content } }
         }
+        .preference(key: SheetBackgroundPreferenceKey.self, value: .gray7)
         .onAppear { usdt.isSendPresented = true }
         .onDisappear { usdt.isSendPresented = false }
-        .task {
+        .task(id: settings.isUsdtEnabled) {
             if !embedded {
                 do { destinations = try await usdt.sendDestinations() }
                 catch { Logger.warn("Could not load USDT bridge destinations", context: "UsdtSendView") }
             }
-            guard !initialRecipient.isEmpty, !initialAmount.isEmpty, quote == nil else { return }
+            guard settings.isUsdtEnabled, !initialRecipient.isEmpty, !initialAmount.isEmpty, quote == nil else { return }
             busy = true
             defer { busy = false }
             do { quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination) }
@@ -124,9 +131,11 @@ struct UsdtSendView: View {
     private var content: some View {
         VStack(alignment: .leading, spacing: 0) {
             SheetHeader(title: title, showBackButton: !submitted,
-                        action: paymentContext == nil ? nil : AnyView(SendContactHeaderAvatar(publicKey: paymentContext?.publicKey)), onBack: goBack)
+                        action: paymentContext == nil ? nil : AnyView(SendContactHeaderAvatar(publicKey: paymentContext?.publicKey)),
+                        topPadding: 28, bottomPadding: 22, dragIndicatorTopPadding: 8, onBack: goBack)
                 .disabled(busy)
-            if submitted, !busy { submittedContent }
+            if showingNetworks { networkPicker }
+            else if submitted, !busy { submittedContent }
             else if let quote { confirmation(quote) }
             else if editingAmount { amountContent }
             else if editingRecipient { manualContent }
@@ -139,7 +148,7 @@ struct UsdtSendView: View {
                 PaymentCelebration(isOnchain: true, isReceived: false, confettiColor: .usdtAccent)
             }
         }
-        .sheetBackground()
+        .background(Color.gray7)
         .navigationBarHidden(true)
         .navigationDestination(isPresented: $pin) {
             SendPinScreen(onCancel: { pin = false }, onPinVerified: {
@@ -184,9 +193,24 @@ struct UsdtSendView: View {
     }
 
     private var networkButton: some View {
-        Menu {
+        Button { recipientFocused = false; showingNetworks = true } label: {
+            HStack(spacing: 4) {
+                Image("usdt-network").resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(.usdtAccent)
+                CaptionBText(destination.label).lineLimit(1).minimumScaleFactor(0.8)
+            }
+            .padding(.horizontal, 8).frame(height: 28)
+            .background(Color.white06, in: Capsule())
+            .overlay(Capsule().stroke(Color.white10, lineWidth: 1))
+        }
+        .disabled(embedded || destinations.count < 2 || busy)
+        .accessibilityIdentifier("UsdtNetwork")
+    }
+
+    private var networkPicker: some View {
+        UsdtNetworkPicker(note: t("usdt__send_network_note")) {
             ForEach(destinations, id: \.self) { item in
-                Button(item.label) {
+                UsdtNetworkRow(title: item.label, selected: destination == item, identifier: "UsdtNetwork-\(item.label)") {
+                    showingNetworks = false
                     guard destination != item else { return }
                     destination = item
                     maximumQuote = nil
@@ -198,17 +222,7 @@ struct UsdtSendView: View {
                     }
                 }
             }
-        } label: {
-            HStack(spacing: 4) {
-                Image("usdt-network").resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(.usdtAccent)
-                CaptionBText(destination.label).lineLimit(1).minimumScaleFactor(0.8)
-            }
-            .padding(.horizontal, 8).frame(height: 28)
-            .background(Color.white06, in: Capsule())
-            .overlay(Capsule().stroke(Color.white10, lineWidth: 1))
         }
-        .disabled(embedded || destinations.count < 2 || busy)
-        .accessibilityIdentifier("UsdtNetwork")
     }
 
     private var recipientContent: some View {
@@ -479,6 +493,7 @@ struct UsdtSendView: View {
 
     private func goBack() {
         guard !busy else { return }
+        if showingNetworks { showingNetworks = false; return }
         if let onBack { onBack(); return }
         if quote != nil { quote = nil }
         else if editingAmount { editingAmount = false; editingRecipient = true }
diff --git a/BitkitTests/AddressTypeSettingsTests.swift b/BitkitTests/AddressTypeSettingsTests.swift
index 8f277d276..e322a973a 100644
--- a/BitkitTests/AddressTypeSettingsTests.swift
+++ b/BitkitTests/AddressTypeSettingsTests.swift
@@ -312,6 +312,23 @@ final class AddressTypeSettingsTests: XCTestCase {
         XCTAssertEqual(settings.quickpayAmount, 1)
     }
 
+    func testUsdtPreferenceSurvivesBackupAndMissingPreferenceRequiresConsent() {
+        for preference in [UsdtPreference.enabled, .disabled, .undecided] {
+            settings.usdtPreference = preference
+            let backup = settings.getSettingsDictionary()
+            XCTAssertEqual(backup[UsdtPreference.key] as? String, preference.rawValue)
+
+            settings.resetToDefaults()
+            settings.restoreSettingsDictionary(backup)
+            XCTAssertEqual(settings.usdtPreference, preference)
+        }
+
+        settings.usdtPreference = .enabled
+        settings.restoreSettingsDictionary([:])
+        XCTAssertEqual(settings.usdtPreference, .undecided)
+        XCTAssertFalse(UsdtPreference.isEnabled())
+    }
+
     func testRestoresDailyLimitMultiplierFromAndroidKey() {
         settings.restoreSettingsDictionary(["quickPayDailyLimitMultiplier": 3])
 
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index f022bedcd..b9e7cda7f 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -2268,6 +2268,9 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
     func testDollarSubscriptionRequiresUsdtReceivingAndFixesParityForFuturePayments() async throws {
         let now = Date(timeIntervalSince1970: 1_800_000_000)
         let publicKey = "pubky\(String(repeating: "y", count: 52))"
+        let originalPreference = UserDefaults.standard.object(forKey: UsdtPreference.key)
+        UserDefaults.standard.set(UsdtPreference.enabled.rawValue, forKey: UsdtPreference.key)
+        defer { UserDefaults.standard.set(originalPreference, forKey: UsdtPreference.key) }
         let key = PublicPaykitService.usdtPaymentOptionEnabledKey
         let original = UserDefaults.standard.object(forKey: key)
         defer { UserDefaults.standard.set(original, forKey: key) }
@@ -8310,6 +8313,9 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
     }
 
     func testProposalDefaultsToAvailableMethodsAndHonorsRestrictions() async throws {
+        let originalPreference = UserDefaults.standard.object(forKey: UsdtPreference.key)
+        UserDefaults.standard.set(UsdtPreference.enabled.rawValue, forKey: UsdtPreference.key)
+        defer { UserDefaults.standard.set(originalPreference, forKey: UsdtPreference.key) }
         let publicKey = "pubky\(String(repeating: "y", count: 52))"
         let onchain = PublicPaykitService.MethodId.onchainMethodId(network: Env.network, scriptType: .p2wpkh).rawValue
         let lightning = PublicPaykitService.MethodId.bitcoinLightningBolt11.rawValue
diff --git a/BitkitTests/ShopPaymentRequestTests.swift b/BitkitTests/ShopPaymentRequestTests.swift
index 6f1f99eb1..b0f7034df 100644
--- a/BitkitTests/ShopPaymentRequestTests.swift
+++ b/BitkitTests/ShopPaymentRequestTests.swift
@@ -182,6 +182,8 @@ final class ShopPaymentRequestTests: XCTestCase {
         XCTAssertFalse(both.prefersUsdt(onchainBalanceSats: 100_000))
         XCTAssertTrue(both.prefersUsdt(onchainBalanceSats: 0))
         XCTAssertFalse(btcOnly.prefersUsdt(onchainBalanceSats: 0))
+        XCTAssertFalse(both.prefersUsdt(onchainBalanceSats: 0, isUsdtEnabled: false))
+        XCTAssertTrue(usdtOnly.prefersUsdt(onchainBalanceSats: 0, isUsdtEnabled: false))
     }
 
     func testUsdtContactPaymentCanBePreparedAndCleared() async throws {
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 97e2e3518..b24eb2d98 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -4,6 +4,35 @@ import XCTest
 
 @MainActor
 final class UsdtWalletManagerTests: XCTestCase {
+    func testUsdtOptInDoesNotImplicitlyPublishOrHideExistingFunds() throws {
+        let defaults = try XCTUnwrap(UserDefaults(suiteName: UUID().uuidString))
+        XCTAssertFalse(UsdtPreference.isEnabled(defaults: defaults))
+        XCTAssertFalse(PublicPaykitService.isUsdtPaymentOptionEnabled(defaults: defaults))
+        defaults.set(UsdtPreference.disabled.rawValue, forKey: UsdtPreference.key)
+        XCTAssertFalse(UsdtPreference.isEnabled(defaults: defaults))
+        XCTAssertTrue(UsdtPreference.protectsFunds(balance: 1, transfers: []))
+        for status: UsdtTransferStatus in [.pending, .bridging, .bridgeNeedsAttention, .bridgeFailed] {
+            XCTAssertTrue(UsdtPreference.protectsFunds(balance: 0, transfers: [transfer("pending", status: status)]))
+        }
+        XCTAssertFalse(UsdtPreference.protectsFunds(balance: 0, transfers: [transfer("completed")]))
+        XCTAssertTrue(UsdtPreference.protectsFunds(balance: nil, transfers: [transfer("completed")]))
+        XCTAssertFalse(UsdtPreference.isEnabled(defaults: defaults))
+        defaults.set(UsdtPreference.enabled.rawValue, forKey: UsdtPreference.key)
+        XCTAssertTrue(UsdtPreference.isEnabled(defaults: defaults))
+        XCTAssertEqual(PublicPaykitService.isUsdtPaymentOptionEnabled(defaults: defaults), Env.isUsdtEnabled)
+        defaults.set(false, forKey: PublicPaykitService.usdtPaymentOptionEnabledKey)
+        XCTAssertFalse(PublicPaykitService.isUsdtPaymentOptionEnabled(defaults: defaults))
+    }
+
+    func testUnresolvedBridgeDepositsPreventDisablingUsdt() {
+        for status in ["held", "processing", "refunding", "refund_requested", "failed", "unknown"] {
+            XCTAssertTrue(UsdtPreference.hasPendingDeposit(status), status)
+        }
+        for status in ["completed", "refunded", "waiting", "awaiting_deposit", "expired"] {
+            XCTAssertFalse(UsdtPreference.hasPendingDeposit(status), status)
+        }
+    }
+
     func testBridgeCostErrorsAskForALargerAmountWithoutInventingAMinimum() {
         let error = UsdtError.BridgeAmountTooSmall
         XCTAssertEqual(UsdtWalletManager.message(for: error), t("usdt__error_bridge_amount"))
diff --git a/BitkitUITests/UsdtWalletUITests.swift b/BitkitUITests/UsdtWalletUITests.swift
index 13c351df0..6ae138492 100644
--- a/BitkitUITests/UsdtWalletUITests.swift
+++ b/BitkitUITests/UsdtWalletUITests.swift
@@ -21,6 +21,8 @@ final class UsdtWalletUITests: XCTestCase {
             XCTAssertTrue(app.buttons["NewWallet"].waitForExistence(timeout: 5))
             app.buttons["NewWallet"].tap()
         }
+        XCTAssertTrue(app.otherElements["TotalBalance-primary"].waitForExistence(timeout: 90))
+        if app.buttons["UsdtIntroEnable"].waitForExistence(timeout: 10) { app.buttons["UsdtIntroEnable"].tap() }
         XCTAssertTrue(app.buttons["UsdtWallet"].waitForExistence(timeout: 90))
         capture(app, "USDT home")
         app.buttons["UsdtWallet"].tap()
@@ -125,6 +127,8 @@ final class UsdtWalletUITests: XCTestCase {
             XCTAssertTrue(app.buttons["NewWallet"].waitForExistence(timeout: 5))
             app.buttons["NewWallet"].tap()
         }
+        XCTAssertTrue(app.otherElements["TotalBalance-primary"].waitForExistence(timeout: 90))
+        if app.buttons["UsdtIntroEnable"].waitForExistence(timeout: 10) { app.buttons["UsdtIntroEnable"].tap() }
         XCTAssertTrue(app.buttons["UsdtWallet"].waitForExistence(timeout: 90), app.debugDescription)
         app.buttons["UsdtWallet"].tap()
         XCTAssertTrue(app.buttons["UsdtReceive"].waitForExistence(timeout: 5))
diff --git a/Docs/USDT-QA.md b/Docs/USDT-QA.md
index 39c2a6821..02d9464aa 100644
--- a/Docs/USDT-QA.md
+++ b/Docs/USDT-QA.md
@@ -4,6 +4,8 @@ The journey environment does not provide funded Arbitrum or cross-network accoun
 
 The repository has a local Arbitrum fork payment fixture at `bitkit-core/tests/usdt-fork`, exercised by `UsdtWalletUITests.testPaymentUsesUsdtOnLocalArbitrumFork`. It does not provide the VSS outage, cross-platform restore, bridge-provider, or billing-clock controls below.
 
+Enable USDT through its introduction or Settings before starting payment checks. The opt-in, disable safeguards and disabled-link paths are covered by `journeys/usdt-opt-in.xml`.
+
 ## usdt bridge quotes
 
 A funded Arbitrum wallet uses the real gateway with USDT0 and Orchestra enabled. This journey obtains quotes only; do not swipe to pay or create any funded order.
diff --git a/Docs/USDT.md b/Docs/USDT.md
index d52bea43f..38776fc71 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -1,6 +1,6 @@
 # USDT configuration
 
-Normal builds use published bitkit-core `0.8.0-rc4`, including its matching native libraries and generated bindings. MAX requires the USDT gateway to allow Core's pinned balance override during gas estimation; it never applies to signing or submission.
+Normal builds use published bitkit-core `0.8.0-rc5`, including its matching native libraries and generated bindings. MAX requires the USDT gateway to allow Core's pinned balance override during gas estimation; it never applies to signing or submission.
 
 USDT uses Arbitrum One regardless of the Bitcoin network setting. Builds use the credential-free Bitkit gateway by default:
 
@@ -23,6 +23,12 @@ Protocol and recovery behavior belong to bitkit-core's USDT module documentation
 
 History catch-up is deferred while the USDT send sheet is open. Balance and pending-payment recovery continue; a history scan already in progress is allowed to finish. Unknown deposit-provider statuses require attention instead of appearing as ordinary pending deposits. Cross-network payment details label the recipient amount as expected until delivery is confirmed.
 
+## Enabling USDT
+
+USDT starts off. The introductory sheet offers Enable USDT and No Thanks; dismissing it without a choice allows it to return next launch. Settings > General > Payments > USDT (Tether) changes the choice later.
+
+When off, new USDT payment choices, Paykit offers and optional address sharing are hidden. Opening an explicit USDT link or request asks to enable it before continuing. Disabling requires a fresh empty balance and no unresolved transfers or deposits. Existing funds, pending payments and restored history with an unknown balance remain visible; payment tracking, history and encrypted backups continue. Previously shared addresses cannot be revoked.
+
 ## Paykit
 
 USDT request sends pass the earlier of the approved conversion quote expiry and request payment deadline to Core as the original precise timestamp. Core persists that cutoff with the signed operation and enforces it before the initial submission and recovery retries. Expired pending operations remain tracked for settlement evidence. Operations created before deadline support have no stored cutoff and retain their existing recovery behavior.
diff --git a/changelog.d/next/884.added.md b/changelog.d/next/884.added.md
index 9c01713d0..b2899ea9a 100644
--- a/changelog.d/next/884.added.md
+++ b/changelog.d/next/884.added.md
@@ -1 +1 @@
-Send and receive USDT with fees paid in USDT, Paykit contact payments and requests, subscriptions, cross-network deposits, optional Earn address sharing, and encrypted payment recovery backups.
+Opt in to USDT in Settings to send and receive with fees paid in USDT, Paykit contact payments and requests, subscriptions, cross-network deposits, optional Earn address sharing, and encrypted payment recovery backups.
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index 60ec33688..bd84fdf54 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -1,6 +1,7 @@
 <journey name="paykit quoted usdt requests">
   <description>Two linked Bitkit wallets with Paykit and USDT enabled, sharing enabled by their owners, and a fresh BTC/USD rate. These request-creation and amount-screen checks need no funds and stop before payment review. Funded Arbitrum review, paid history, controlled rates and proof verification are manual tests in Docs/USDT-QA.md; a Bitcoin regtest balance does not fund USDT.</description>
   <actions>
+    <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
     <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
diff --git a/journeys/usdt-bridge-amount-errors.xml b/journeys/usdt-bridge-amount-errors.xml
index bb456a55b..f365fbc79 100644
--- a/journeys/usdt-bridge-amount-errors.xml
+++ b/journeys/usdt-bridge-amount-errors.xml
@@ -1,6 +1,7 @@
 <journey name="usdt bridge amount errors">
   <description>Use an onboarded USDT wallet and a gateway fixture that rejects outbound quotes and inbound estimates with xchain_amount_too_small. No payment is submitted. The error describes live bridge costs rather than inventing a fixed network minimum.</description>
   <actions>
+    <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open USDT Send, select Tron and enter a valid external Tron address. Enter 3.5 USDT and continue. Verify the amount screen remains visible, payment review does not open, and the error says Amount too small to cover bridge costs. Try a larger amount.</action>
     <action>Return to USDT Receive, select Tron and enter an expected deposit amount of 3.5 USDT. Continue. Verify the same actionable error is shown and no deposit QR is presented. Verify the error does not claim that the provider's advertised minimum guarantees acceptance.</action>
     <action>Change the fixture to provide a valid quote or estimate, increase the amount and continue. Verify the error clears and the flow advances. Stop before approving a payment or sharing a deposit request.</action>
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
index 0ad7ea4d9..0a159188a 100644
--- a/journeys/usdt-bridge-support.xml
+++ b/journeys/usdt-bridge-support.xml
@@ -1,6 +1,7 @@
 <journey name="usdt bridge support">
   <description>Use an onboarded wallet with an outbound cross-network transfer and an Orchestra deposit in its history. Existing history or a provider fixture is sufficient; do not submit a payment or support request.</description>
   <actions>
+    <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open USDT from Home, then open a cross-network transfer in Activity.</action>
     <action>Tap Details (id "UsdtActivityDetails"), then verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
diff --git a/journeys/usdt-opt-in.xml b/journeys/usdt-opt-in.xml
new file mode 100644
index 000000000..a312a5901
--- /dev/null
+++ b/journeys/usdt-opt-in.xml
@@ -0,0 +1,14 @@
+<journey name="USDT Opt In">
+  <description>Use a fresh onboarded wallet with USDT services configured. The wallet has no USDT balance or pending transfers. Use owned payment links and existing requests; no payment is submitted.</description>
+  <actions>
+    <action>On Home, verify the New: USDT sheet (id "UsdtIntro") shows the Tether coin, DOLLARS? YOUR CALL heading, No Thanks and Enable USDT.</action>
+    <action>Swipe the intro sheet down. Verify Home shows Savings and Spending without a USDT tile. Open Receive and verify there is no USDT tab, then close it.</action>
+    <action>Terminate and relaunch the app. Verify the USDT intro returns. Tap No Thanks (id "UsdtIntroDecline"), relaunch again, and verify the intro does not return.</action>
+    <action>Open Settings, General, Payments. Verify USDT (Tether) (id "UsdtSettingsToggle") is off. Enable it, return Home, and verify the USDT tile appears. Open Receive and verify the USDT tab appears.</action>
+    <action>Open USDT Send and its network pill. Verify the USDT Network picker (id "UsdtNetworkPicker") uses rounded rows with Tether icons, a teal selection check, the recipient-network explanation and Tether coin illustration. Choose another supported network and verify the pill updates.</action>
+    <action>Return to Settings and turn USDT off while the wallet is empty and all transfers are complete. Verify the USDT tile, receive tab and new Paykit receiving option disappear. Existing payment history remains stored.</action>
+    <action>Open an owned USDT payment link while USDT is off. Verify the Enable USDT prompt (id "UsdtEnablePrompt"). Cancel and verify USDT stays off. Open the link again, enable USDT (id "UsdtEnablePromptContinue"), and verify the recipient and exact amount continue into the payment flow. Cancel without paying.</action>
+    <action>With a funded wallet or an unresolved transfer, try turning USDT off in Settings. Verify the change is blocked with an explanation and the wallet and pending payment remain accessible. Restore the original setting after this check.</action>
+    <action>Restore an owned funded wallet whose USDT preference is absent or off. Verify its USDT wallet remains visible without enabling new Paykit receiving options. Open Receive, enable USDT when asked, and verify it opens the USDT tab. No payment is submitted.</action>
+  </actions>
+</journey>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index d8f8bcbdb..bb3030853 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -1,6 +1,7 @@
 <journey name="usdt payment links and scans">
   <description>Use an onboarded wallet with USDT configured and another owned wallet's Arbitrum receive URI. No payment is submitted. Hardware-wallet send remains Bitcoin-only.</description>
   <actions>
+    <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount screen preserves the recipient and exact input 0.010001 USDT; the review rounds its displayed value to $0.01. Verify no payment occurs without approval.</action>
     <action>On iOS, copy the USDT receive URI, return to Home and accept the clipboard prompt. Verify the USDT amount screen opens with the copied recipient and amount. Cancel without paying. Repeat with a wrong-chain URI and verify no payment prompt appears.</action>
     <action>Cancel the send, then reopen the identical URI. Verify the amount or review screen opens again. Cancel and open a different owned recipient and amount, verifying only the new values appear.</action>
diff --git a/journeys/usdt-receive-amount-and-units.xml b/journeys/usdt-receive-amount-and-units.xml
index 7e083ae68..282e7436a 100644
--- a/journeys/usdt-receive-amount-and-units.xml
+++ b/journeys/usdt-receive-amount-and-units.xml
@@ -1,6 +1,7 @@
 <journey name="usdt receive amount and units">
   <description>Use an onboarded wallet with USDT configured and a fresh BTC/USD rate. No payment is submitted. Cross-network estimates require a live enabled provider and are covered by the manual USDT checks.</description>
   <actions>
+    <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open USDT from Home. Verify the USDT balance, teal Tether icon and existing activity rows.</action>
     <action>Open Receive. Verify Receive Dollars, the USDT tab and Network: Arbitrum One on the QR screen.</action>
     <action>Tap Edit, enter 5 and tap Back. Verify the QR has no uint256 amount.</action>
diff --git a/journeys/usdt-send-review-and-details.xml b/journeys/usdt-send-review-and-details.xml
index 7266d1611..2d7b5fd0c 100644
--- a/journeys/usdt-send-review-and-details.xml
+++ b/journeys/usdt-send-review-and-details.xml
@@ -1,8 +1,9 @@
 <journey name="usdt send review and details">
   <description>Use an onboarded wallet with USDT, a fresh BTC/USD rate, an owned recipient and existing sent/received activity. Quotes require the service with MAX support. No payment is submitted.</description>
   <actions>
+    <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open USDT Send and enter the owned recipient. On Amount, verify the BTC equivalent above the dollar amount, 32-point gap before Available balance, USDT badge, MAX and network pill. Enter a six-decimal amount and verify no precision is lost.</action>
-    <action>Open the network pill and select another EVM network. Verify the amount and valid recipient remain. Change to Solana with an EVM recipient and verify recipient entry is required. Enter an owned plain Solana address and verify the previous amount remains. Return to Arbitrum, enter the owned EVM address and verify the amount still remains.</action>
+    <action>Open the network pill and verify the full USDT Network picker, Tether rows and selected teal check. Select another EVM network. Verify the amount and valid recipient remain. Change to Solana with an EVM recipient and verify recipient entry is required. Enter an owned plain Solana address and verify the previous amount remains. Return to Arbitrum, enter the owned EVM address and verify the amount still remains.</action>
     <action>From recipient entry with another network selected, paste an explicit Arbitrum USDT URI. Verify the selected network becomes Arbitrum and the link amount is retained. A plain 0x address preserves the selected network.</action>
     <action>Tap MAX. Verify it fills a positive amount below the balance and remains on Amount. Continue and verify the payment plus maximum fee fits within the balance. Back out without swiping.</action>
     <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note in the scrollable details. Displayed amounts round to cents; nonzero values below one cent show &lt;0.01. Hide Details restores the illustration. Cancel without paying.</action>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index 0bd6019dd..4176ccbad 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -1,6 +1,7 @@
 <journey name="usdt wallet navigation">
   <description>Use an onboarded wallet in an E2E build with USDT RPC and bundler URLs configured. No chain funding or live provider is required. A network error may be visible when services are offline; no payment is submitted.</description>
   <actions>
+    <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>On Home, verify the Savings/Spending and USDT balance dividers align vertically, including any hardware wallet rows. With an odd number of paired hardware wallets, verify USDT fills the last row’s empty cell; with an even number, it starts the next row.</action>
     <action>Verify USDT balances and activity amounts show at most two decimals; a nonzero amount below one cent shows &lt;0.01. Open USDT from Home and verify the wallet screen uses the same balance, action buttons and activity layout as the Bitcoin wallet, with its Tether coin illustration anchored at the upper right.</action>
     <action>Open Receive. Verify the network is Arbitrum One. Open details, verify the address starts with 0x, and verify Details Copy contains only the address. Return to the QR and verify Copy contains the full USDT payment URI including the network and token. On Android, system Back from Details returns to the USDT QR; Back from the QR closes Receive without switching to Savings.</action>

From ae666ab76f3847205e6655f329705731a22ce64e Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 10:33:30 -0500
Subject: [PATCH 38/62] fix: align USDT screens and payment recovery

---
 .../Contents.json                             |  21 +++
 .../usdt-coins-received.png                   | Bin 0 -> 703586 bytes
 .../permission-folder.imageset/Contents.json  |  16 ++
 .../permission-folder.svg                     |   7 +
 Bitkit/Components/PaymentCelebration.swift    |  19 ++-
 Bitkit/Components/Scanner.swift               |  14 +-
 .../Localization/en.lproj/Localizable.strings |   2 +
 .../Services/PaykitUsdtPaymentService.swift   | 134 +++++++++++------
 Bitkit/Styles/TextStyle.swift                 |  49 ++++--
 .../PubkyAuthApprovalSheet.swift              |  34 +++--
 Bitkit/Views/Sheets/Sheet.swift               |   5 +-
 Bitkit/Views/Sheets/UsdtIntroSheet.swift      |   4 +-
 .../Views/Wallets/Send/SendAmountView.swift   |   7 +-
 Bitkit/Views/Wallets/Sheets/ReceivedTx.swift  |   3 +-
 Bitkit/Views/Wallets/UsdtNetworkPicker.swift  |   4 +-
 Bitkit/Views/Wallets/UsdtSendView.swift       |  90 +++++++----
 .../PaykitPaymentRequestServiceTests.swift    |  87 +++++++++++
 .../PaykitPaymentStateBackupTests.swift       | 142 ++++++++++++++++++
 journeys/usdt-send-review-and-details.xml     |   4 +-
 19 files changed, 531 insertions(+), 111 deletions(-)
 create mode 100644 Bitkit/Assets.xcassets/Illustrations/usdt-coins-received.imageset/Contents.json
 create mode 100644 Bitkit/Assets.xcassets/Illustrations/usdt-coins-received.imageset/usdt-coins-received.png
 create mode 100644 Bitkit/Assets.xcassets/icons/permission-folder.imageset/Contents.json
 create mode 100644 Bitkit/Assets.xcassets/icons/permission-folder.imageset/permission-folder.svg

diff --git a/Bitkit/Assets.xcassets/Illustrations/usdt-coins-received.imageset/Contents.json b/Bitkit/Assets.xcassets/Illustrations/usdt-coins-received.imageset/Contents.json
new file mode 100644
index 000000000..eae357c80
--- /dev/null
+++ b/Bitkit/Assets.xcassets/Illustrations/usdt-coins-received.imageset/Contents.json
@@ -0,0 +1,21 @@
+{
+  "images": [
+    {
+      "idiom": "universal",
+      "scale": "1x"
+    },
+    {
+      "idiom": "universal",
+      "scale": "2x"
+    },
+    {
+      "idiom": "universal",
+      "scale": "3x",
+      "filename": "usdt-coins-received.png"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  }
+}
diff --git a/Bitkit/Assets.xcassets/Illustrations/usdt-coins-received.imageset/usdt-coins-received.png b/Bitkit/Assets.xcassets/Illustrations/usdt-coins-received.imageset/usdt-coins-received.png
new file mode 100644
index 0000000000000000000000000000000000000000..d1e4b67219fbcd58f4b6db0367653569c5a0f493
GIT binary patch
literal 703586
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%0Aj^RR9Y&3551$@V
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%0A-w%mfY;
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%0Dtd_rEdecU)u-Zs~jUO7RsGrUIn3Q0Q=S
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
A?f?J)

literal 0
HcmV?d00001

diff --git a/Bitkit/Assets.xcassets/icons/permission-folder.imageset/Contents.json b/Bitkit/Assets.xcassets/icons/permission-folder.imageset/Contents.json
new file mode 100644
index 000000000..fba6b5ba1
--- /dev/null
+++ b/Bitkit/Assets.xcassets/icons/permission-folder.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "permission-folder.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/Bitkit/Assets.xcassets/icons/permission-folder.imageset/permission-folder.svg b/Bitkit/Assets.xcassets/icons/permission-folder.imageset/permission-folder.svg
new file mode 100644
index 000000000..c5605220d
--- /dev/null
+++ b/Bitkit/Assets.xcassets/icons/permission-folder.imageset/permission-folder.svg
@@ -0,0 +1,7 @@
+<svg preserveAspectRatio="none" overflow="visible" style="display: block;" width="13" height="11" viewBox="0 0 13 11" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g id="Folder">
+<path id="Vector" opacity="0.2" d="M4.64645 0.646447L6.5 2.5H0.5V1C0.5 0.867392 0.552679 0.740215 0.646447 0.646447C0.740215 0.552679 0.867392 0.5 1 0.5H4.29289C4.35855 0.5 4.42357 0.512933 4.48424 0.53806C4.5449 0.563188 4.60002 0.600018 4.64645 0.646447Z" fill="white"/>
+<path id="Vector (Stroke)" fill-rule="evenodd" clip-rule="evenodd" d="M0 2.5C0 2.22386 0.223858 2 0.5 2H12C12.2652 2 12.5196 2.10536 12.7071 2.29289C12.8946 2.48043 13 2.73478 13 3V10.0556C13 10.306 12.9005 10.5463 12.7234 10.7234C12.5463 10.9005 12.306 11 12.0556 11H0.961539L0.960075 11C0.705677 10.9993 0.461911 10.8979 0.282024 10.718C0.102137 10.5381 0.000746757 10.2943 2.14577e-06 10.0399L0 10.0385V2.5ZM12 10H1V3H12V10Z" fill="white"/>
+<path id="Vector (Stroke)_2" fill-rule="evenodd" clip-rule="evenodd" d="M0.292893 0.292893C0.480429 0.105357 0.734783 0 1 0H4.29289C4.42421 0 4.55425 0.0258653 4.67558 0.0761205C4.7969 0.126376 4.90714 0.200036 5 0.292894L6.85355 2.14645C7.04882 2.34171 7.04882 2.65829 6.85355 2.85355C6.65829 3.04882 6.34171 3.04882 6.14645 2.85355L4.29289 1L1 1L1 2.5C1 2.77614 0.776142 3 0.5 3C0.223858 3 0 2.77614 0 2.5V1C0 0.734783 0.105357 0.480429 0.292893 0.292893Z" fill="white"/>
+</g>
+</svg>
diff --git a/Bitkit/Components/PaymentCelebration.swift b/Bitkit/Components/PaymentCelebration.swift
index 4e10e0fd2..7d12b2aa9 100644
--- a/Bitkit/Components/PaymentCelebration.swift
+++ b/Bitkit/Components/PaymentCelebration.swift
@@ -5,9 +5,14 @@ struct PaymentCelebration: View {
     let isOnchain: Bool
     let isReceived: Bool
     var confettiColor: Color?
+    var isUsdt = false
 
     var body: some View {
         ZStack {
+            if isUsdt {
+                Color.black.ignoresSafeArea(edges: .bottom)
+            }
+
             LottieView(animation: .named(isOnchain ? "confetti-orange" : "confetti-purple"))
                 .configure { animationView in
                     let keypath = AnimationKeypath(keypath: "**.Color")
@@ -21,7 +26,19 @@ struct PaymentCelebration: View {
                 .scaleEffect(1.9)
                 .frame(maxWidth: .infinity, maxHeight: .infinity)
 
-            if isReceived {
+            if isUsdt {
+                LinearGradient(colors: [Color(hex: 0x8E8E93).opacity(0.16), .clear], startPoint: .top, endPoint: .bottom)
+                    .ignoresSafeArea(edges: .bottom)
+            }
+
+            if isReceived, isUsdt {
+                // The artwork includes overflow beyond Figma's centered 256pt frame.
+                Image("usdt-coins-received")
+                    .resizable()
+                    .frame(width: 348.5, height: 520)
+                    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .bottom)
+                    .offset(x: 13.25, y: windowSafeAreaInsets.bottom - 36)
+            } else if isReceived {
                 Image("coins-received")
                     .resizable()
                     .aspectRatio(contentMode: .fit)
diff --git a/Bitkit/Components/Scanner.swift b/Bitkit/Components/Scanner.swift
index 13a8f22ba..e7df5dd64 100644
--- a/Bitkit/Components/Scanner.swift
+++ b/Bitkit/Components/Scanner.swift
@@ -226,6 +226,8 @@ private struct ScannerCornerButtons: View {
 // MARK: - Scanner Component
 
 struct Scanner: View {
+    var accentColor: Color = .brandAccent
+    var permissionDescription: String = t("other__camera_no_text")
     @Environment(CameraManager.self) private var cameraManager
 
     let onScan: (QRCodePayload) async -> Void
@@ -254,7 +256,11 @@ struct Scanner: View {
                     }
                 )
             } else {
-                ScannerPermissionRequest(onRequestPermission: cameraManager.requestPermission)
+                ScannerPermissionRequest(
+                    accentColor: accentColor,
+                    description: permissionDescription,
+                    onRequestPermission: cameraManager.requestPermission
+                )
             }
         }
         .cornerRadius(16)
@@ -266,6 +272,8 @@ struct Scanner: View {
 }
 
 struct ScannerPermissionRequest: View {
+    var accentColor: Color = .brandAccent
+    var description: String = t("other__camera_no_text")
     let onRequestPermission: () -> Void
 
     var body: some View {
@@ -273,9 +281,9 @@ struct ScannerPermissionRequest: View {
             .frame(maxWidth: .infinity, maxHeight: .infinity)
             .overlay {
                 VStack(spacing: 0) {
-                    DisplayText(t("other__camera_no_title"), accentColor: .brandAccent)
+                    DisplayText(t("other__camera_no_title"), accentColor: accentColor)
                         .padding(.bottom, 8)
-                    BodyMText(t("other__camera_no_text"))
+                    BodyMText(description)
                         .padding(.bottom, 32)
                     CustomButton(
                         title: t("other__camera_no_button"),
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index b6519a0fd..87fd0d0e8 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1970,3 +1970,5 @@
 "usdt__no_thanks" = "No Thanks";
 "usdt__send_network_note" = "Choose the network your recipient uses.";
 "usdt__settings_title" = "USDT (Tether)";
+
+"usdt__camera_permission" = "Allow camera access to scan USDT payment requests and pay more quickly.";
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
index c5e039c52..9055cdd7d 100644
--- a/Bitkit/Services/PaykitUsdtPaymentService.swift
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -77,7 +77,9 @@ final class PaykitUsdtPaymentService {
     private var activeIdentity: String?
     private var reconciling = false
     private var preparing = false
+    private var restoreGeneration = 0
     private(set) var resumableRequests: Set<PaykitPaymentRequest.ID> = []
+    private var unsubmittedAttempts: [Attempt] = []
 
     private nonisolated(unsafe) static let stateChanged = PassthroughSubject<Void, Never>()
     nonisolated static var walletBackupDataChangedPublisher: AnyPublisher<Void, Never> {
@@ -91,6 +93,9 @@ final class PaykitUsdtPaymentService {
     }
 
     func restoreBackup(_ backup: PaykitUsdtStateBackup) throws {
+        restoreGeneration &+= 1
+        unsubmittedAttempts = []
+        resumableRequests = []
         var state = try load()
         for attempt in try backup.attempts.map({ try $0.restored() }) {
             if let index = state.attempts.firstIndex(where: { $0.wallet == attempt.wallet && $0.quoteId == attempt.quoteId }) {
@@ -169,10 +174,12 @@ final class PaykitUsdtPaymentService {
     private func publish(_ state: State) {
         attempts = state.attempts.filter { $0.wallet == activeWallet && $0.identity == activeIdentity }
         receipts = state.receipts.filter { $0.wallet == activeWallet && $0.identity == activeIdentity }
+        unsubmittedAttempts.removeAll { !attempts.contains($0) }
     }
 
     func hasBinding(for requestId: PaykitPaymentRequest.ID) -> Bool {
-        attempts.contains { $0.requestId == requestId }
+        guard let state = try? load() else { return true }
+        return state.attempts.contains { $0.requestId == requestId && !unsubmittedAttempts.contains($0) }
     }
 
     func paymentProtection(identity: String) throws
@@ -305,59 +312,100 @@ final class PaykitUsdtPaymentService {
     }
 
     func reconcile(wallet: UsdtWalletManager) async {
-        guard !reconciling, wallet.isConfigured else { return }
+        guard wallet.isConfigured else {
+            unsubmittedAttempts = []
+            resumableRequests = []
+            return
+        }
+        await reconcile(
+            context: {
+                guard let identity = try await self.currentIdentity() else { return nil }
+                _ = try await wallet.paymentEndpoint()
+                return (wallet.address.lowercased(), identity)
+            },
+            storedTransfer: { try await wallet.storedTransfer($0) },
+            paymentProof: { try await wallet.paymentProof(quoteId: $0, binding: $1) },
+            submitProof: { await PaykitPaymentProofService.shared.submitUsdtProof($0) },
+            paymentRequests: { try await PaykitSdkService.shared.paymentRequests() },
+            verifyPayment: { try await wallet.verifyPayment(binding: $0, proof: $1) }
+        )
+    }
+
+    func reconcile(
+        context: () async throws -> (owner: String, identity: String)?,
+        storedTransfer: (String) async throws -> UsdtTransfer?,
+        paymentProof: (String, UsdtPaymentProofBinding) async throws -> UsdtPaymentProof?,
+        submitProof: (PendingPaykitPaymentProof) async -> Bool,
+        paymentRequests: () async throws -> [Paykit.PaymentRequestRecord],
+        verifyPayment: (UsdtPaymentProofBinding, UsdtPaymentProof) async throws -> UsdtVerifiedPayment?
+    ) async {
+        guard !reconciling else { return }
+        let generation = restoreGeneration
         reconciling = true
         defer { reconciling = false }
+        unsubmittedAttempts = []
+        resumableRequests = []
         do {
-            guard let identity = try await currentIdentity() else { return }
-            _ = try await wallet.paymentEndpoint()
-            let owner = wallet.address.lowercased()
+            try Task.checkCancellation()
+            guard let (owner, identity) = try await context() else { return }
             activeWallet = owner
             activeIdentity = identity
             let state = try load()
             publish(state)
             var resumable: [Attempt] = []
+            var unsubmitted: [Attempt] = []
             for attempt in state.attempts where attempt.wallet == owner && attempt.identity == identity {
-                guard attempt.requestId != nil else { continue }
-                let transfer = try await wallet.storedTransfer(attempt.quoteId)
-                if (transfer == nil && !attempt.paymentStarted) || transfer?.status == .failed || transfer?
-                    .status == .replaced { resumable.append(attempt) }
-            }
-            guard activeWallet == owner, activeIdentity == identity else { return }
-            let currentAttempts = try load().attempts
-            resumableRequests = Set(resumable.filter { currentAttempts.contains($0) }.compactMap(\.requestId))
-            for attempt in state.attempts where attempt.wallet == owner && attempt.identity == identity && !attempt.proofQueued {
-                guard let requestId = attempt.requestId, let binding = attempt.binding else { continue }
-                let transfer = try await wallet.storedTransfer(attempt.quoteId)
-                guard attempt.proof != nil || transfer?.status == .confirmed else { continue }
-                let proof: Proof
-                if let saved = attempt.proof { proof = saved }
-                else {
-                    guard let signed = try await wallet.paymentProof(quoteId: attempt.quoteId, binding: binding) else { continue }
-                    proof = Proof(signed)
-                    var current = try load()
-                    guard let index = current.attempts.firstIndex(where: { $0.quoteId == attempt.quoteId && $0.wallet == owner }) else { continue }
-                    current.attempts[index].proof = proof
-                    try save(current)
-                }
-                let encoder = JSONEncoder()
-                encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes]
-                let data = try String(decoding: encoder.encode(proof), as: UTF8.self)
-                let pending = PendingPaykitPaymentProof(identity: identity, requestId: requestId,
-                                                        paymentAppId: binding.paymentAppId,
-                                                        paymentEndpointIdentifier: binding.paymentEndpointIdentifier,
-                                                        kind: .usdt, billingPeriod: attempt.billingPeriod,
-                                                        paymentIdentifier: attempt.quoteId, proofData: data,
-                                                        conversionQuoteId: binding.conversionQuoteId.isEmpty ? nil : binding.conversionQuoteId)
-                if await PaykitPaymentProofService.shared.submitUsdtProof(pending) {
-                    var current = try load()
-                    if let index = current.attempts.firstIndex(where: { $0.quoteId == attempt.quoteId && $0.wallet == owner }) {
-                        current.attempts[index].proofQueued = true
+                guard let requestId = attempt.requestId else { continue }
+                do {
+                    try Task.checkCancellation()
+                    let transfer = try await storedTransfer(attempt.quoteId)
+                    if (transfer == nil && !attempt.paymentStarted) || transfer?.status == .failed || transfer?
+                        .status == .replaced { resumable.append(attempt) }
+                    if transfer == nil, !attempt.paymentStarted, attempt.proof == nil, !attempt.proofQueued {
+                        unsubmitted.append(attempt)
+                    }
+                    guard !attempt.proofQueued, let binding = attempt.binding else { continue }
+                    guard attempt.proof != nil || transfer?.status == .confirmed else { continue }
+                    let proof: Proof
+                    if let saved = attempt.proof { proof = saved }
+                    else {
+                        guard let signed = try await paymentProof(attempt.quoteId, binding) else { continue }
+                        proof = Proof(signed)
+                        var current = try load()
+                        guard let index = current.attempts.firstIndex(where: { $0.quoteId == attempt.quoteId && $0.wallet == owner })
+                        else { continue }
+                        current.attempts[index].proof = proof
                         try save(current)
                     }
+                    let encoder = JSONEncoder()
+                    encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes]
+                    let data = try String(decoding: encoder.encode(proof), as: UTF8.self)
+                    let pending = PendingPaykitPaymentProof(identity: identity, requestId: requestId,
+                                                            paymentAppId: binding.paymentAppId,
+                                                            paymentEndpointIdentifier: binding.paymentEndpointIdentifier,
+                                                            kind: .usdt, billingPeriod: attempt.billingPeriod,
+                                                            paymentIdentifier: attempt.quoteId, proofData: data,
+                                                            conversionQuoteId: binding.conversionQuoteId.isEmpty ? nil : binding.conversionQuoteId)
+                    if await submitProof(pending) {
+                        var current = try load()
+                        if let index = current.attempts.firstIndex(where: { $0.quoteId == attempt.quoteId && $0.wallet == owner }) {
+                            current.attempts[index].proofQueued = true
+                            try save(current)
+                        }
+                    }
+                } catch is CancellationError {
+                    throw CancellationError()
+                } catch {
+                    try Task.checkCancellation()
+                    Logger.warn("Unable to reconcile Paykit USDT payment attempt: \(error)", context: "PaykitUsdt")
                 }
             }
-            for record in try await PaykitSdkService.shared.paymentRequests() where record.localRole == .payee {
+            guard restoreGeneration == generation, activeWallet == owner, activeIdentity == identity else { return }
+            let currentAttempts = try load().attempts
+            resumableRequests = Set(resumable.filter { currentAttempts.contains($0) }.compactMap(\.requestId))
+            unsubmittedAttempts = unsubmitted.filter { currentAttempts.contains($0) }
+            try Task.checkCancellation()
+            for record in try await paymentRequests() where record.localRole == .payee {
                 for submission in record.paymentProofs
                     where submission.paymentEndpointIdentifier == PublicPaykitService.MethodId.usdtArbitrum.rawValue
                 {
@@ -381,7 +429,7 @@ final class PaykitUsdtPaymentService {
                         period: submission.billingPeriod
                     )
                     do {
-                        guard let payment = try await wallet.verifyPayment(binding: binding, proof: proof.coreValue) else {
+                        guard let payment = try await verifyPayment(binding, proof.coreValue) else {
                             try invalidateReceipt(proofEventId: submission.eventId, requestId: request.id, owner: owner, identity: identity)
                             continue
                         }
@@ -408,6 +456,8 @@ final class PaykitUsdtPaymentService {
                     } catch is PaykitAmountError { continue }
                 }
             }
+        } catch is CancellationError {
+            return
         } catch {
             Logger.warn("Unable to reconcile Paykit USDT payments: \(error)", context: "PaykitUsdt")
         }
diff --git a/Bitkit/Styles/TextStyle.swift b/Bitkit/Styles/TextStyle.swift
index 5e19e3f1d..0536d4e06 100644
--- a/Bitkit/Styles/TextStyle.swift
+++ b/Bitkit/Styles/TextStyle.swift
@@ -134,6 +134,7 @@ struct SubtitleText: View {
     var accentColor: Color = .brandAccent
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
+    var kerning: CGFloat
 
     private let fontSize: CGFloat = 17
 
@@ -142,13 +143,15 @@ struct SubtitleText: View {
         textColor: Color = .textPrimary,
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
-        accentAction: (() -> Void)? = nil
+        accentAction: (() -> Void)? = nil,
+        kerning: CGFloat = 0.4
     ) {
         self.text = text
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
         self.accentAction = accentAction
+        self.kerning = kerning
     }
 
     var body: some View {
@@ -160,16 +163,19 @@ struct SubtitleText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
-        .kerning(0.4)
+        .kerning(kerning)
     }
 }
 
 struct BodyMText: View {
+    @Environment(\._lineHeightMultiple) private var inheritedLineHeightMultiple
     let text: String
     var textColor: Color = .textSecondary
     var accentColor: Color = .white
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
+    var kerning: CGFloat
+    var lineHeight: CGFloat?
 
     private let fontSize: CGFloat = 17
 
@@ -178,13 +184,17 @@ struct BodyMText: View {
         textColor: Color = .textSecondary,
         accentColor: Color = .white,
         accentFont: ((CGFloat) -> Font)? = nil,
-        accentAction: (() -> Void)? = nil
+        accentAction: (() -> Void)? = nil,
+        kerning: CGFloat = 0.4,
+        lineHeight: CGFloat? = nil
     ) {
         self.text = text
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
         self.accentAction = accentAction
+        self.kerning = kerning
+        self.lineHeight = lineHeight
     }
 
     var body: some View {
@@ -196,7 +206,10 @@ struct BodyMText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
-        .kerning(0.4)
+        .kerning(kerning)
+        .environment(\._lineHeightMultiple, lineHeight.map {
+            $0 / (UIFont(name: Fonts.regular, size: fontSize)?.lineHeight ?? fontSize)
+        } ?? inheritedLineHeightMultiple)
     }
 }
 
@@ -206,6 +219,7 @@ struct BodyMSBText: View {
     var accentColor: Color = .brandAccent
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
+    var kerning: CGFloat
 
     private let fontSize: CGFloat = 17
 
@@ -214,13 +228,15 @@ struct BodyMSBText: View {
         textColor: Color = .textPrimary,
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
-        accentAction: (() -> Void)? = nil
+        accentAction: (() -> Void)? = nil,
+        kerning: CGFloat = 0.4
     ) {
         self.text = text
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
         self.accentAction = accentAction
+        self.kerning = kerning
     }
 
     var body: some View {
@@ -232,7 +248,7 @@ struct BodyMSBText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
-        .kerning(0.4)
+        .kerning(kerning)
     }
 }
 
@@ -273,11 +289,14 @@ struct BodyMBoldText: View {
 }
 
 struct BodySText: View {
+    @Environment(\._lineHeightMultiple) private var inheritedLineHeightMultiple
     let text: String
     var textColor: Color = .textSecondary
     var accentColor: Color = .brandAccent
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
+    var kerning: CGFloat
+    var lineHeight: CGFloat?
 
     private let fontSize: CGFloat = 15
 
@@ -286,13 +305,17 @@ struct BodySText: View {
         textColor: Color = .textSecondary,
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
-        accentAction: (() -> Void)? = nil
+        accentAction: (() -> Void)? = nil,
+        kerning: CGFloat = 0.4,
+        lineHeight: CGFloat? = nil
     ) {
         self.text = text
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
         self.accentAction = accentAction
+        self.kerning = kerning
+        self.lineHeight = lineHeight
     }
 
     var body: some View {
@@ -304,7 +327,10 @@ struct BodySText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
-        .kerning(0.4)
+        .kerning(kerning)
+        .environment(\._lineHeightMultiple, lineHeight.map {
+            $0 / (UIFont(name: Fonts.regular, size: fontSize)?.lineHeight ?? fontSize)
+        } ?? inheritedLineHeightMultiple)
     }
 }
 
@@ -386,6 +412,7 @@ struct CaptionBText: View {
     var accentColor: Color = .brandAccent
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
+    var kerning: CGFloat
 
     private let fontSize: CGFloat = 13
 
@@ -394,13 +421,15 @@ struct CaptionBText: View {
         textColor: Color = .textSecondary,
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
-        accentAction: (() -> Void)? = nil
+        accentAction: (() -> Void)? = nil,
+        kerning: CGFloat = 0.4
     ) {
         self.text = text
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
         self.accentAction = accentAction
+        self.kerning = kerning
     }
 
     var body: some View {
@@ -412,7 +441,7 @@ struct CaptionBText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
-        .kerning(0.4)
+        .kerning(kerning)
     }
 }
 
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index 1cfb882e5..08b6235a8 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -143,7 +143,7 @@ struct PubkyAuthApprovalSheet: View {
     }
 
     var body: some View {
-        Sheet(id: .pubkyAuthApproval, data: config) {
+        Sheet(id: .pubkyAuthApproval, data: config, backgroundColor: .gray7, applyGradient: false) {
             if showsUsdtEnablePrompt {
                 UsdtIntroContent(
                     isEnablePrompt: true,
@@ -217,6 +217,7 @@ struct PubkyAuthApprovalSheet: View {
             SheetHeader(
                 title: headerTitle,
                 showBackButton: showsBackButton,
+                topPadding: 28, bottomPadding: 22, dragIndicatorTopPadding: 8,
                 onBack: onBack
             )
 
@@ -335,8 +336,8 @@ struct PubkyAuthApprovalSheet: View {
 
                     if config.request.bitkitClaim?.includesPaykitAccess == true {
                         VStack(alignment: .leading, spacing: 8) {
-                            CaptionMText(t("pubky_auth__details"), textColor: .white64)
-                            BodySText(t("pubky_auth__paykit_access_description"), textColor: .textPrimary)
+                            CaptionMText(t("pubky_auth__details"), textColor: .white64).frame(minHeight: 18)
+                            BodySText(t("pubky_auth__paykit_access_description"), textColor: .textPrimary, kerning: 0, lineHeight: 20)
                                 .fixedSize(horizontal: false, vertical: true)
                         }
                         .padding(.top, 32)
@@ -344,8 +345,6 @@ struct PubkyAuthApprovalSheet: View {
                         .accessibilityIdentifier("PubkyAuthPaykitAccess")
                     }
 
-                    Spacer().frame(height: 32)
-
                     trustWarning
                         .padding(.bottom, 16)
 
@@ -387,9 +386,9 @@ struct PubkyAuthApprovalSheet: View {
                 ? t("pubky_auth__description_prefix") + "<accent>" + serviceText + "</accent>" + t("pubky_auth__description_suffix")
                 : pubkyAuthFilledText(t("pubky_auth__description_named"), variables: ["clientId": requesterText, "service": serviceText]),
             accentColor: .textPrimary,
-            accentFont: Fonts.bold
+            accentFont: Fonts.bold,
+            kerning: 0, lineHeight: 22
         )
-        .lineSpacing(4)
     }
 
     private var introTitleKey: String {
@@ -508,14 +507,14 @@ struct PubkyAuthApprovalSheet: View {
                     variables: ["pubky": truncatedPublicKey, "clientId": requesterText, "service": serviceText]
                 ),
             accentColor: .textPrimary,
-            accentFont: Fonts.bold
+            accentFont: Fonts.bold,
+            kerning: 0, lineHeight: 22
         )
-        .lineSpacing(4)
     }
 
     private var permissionsSection: some View {
         VStack(alignment: .leading, spacing: 8) {
-            CaptionMText(t("pubky_auth__requested_permissions"), textColor: .white64)
+            CaptionMText(t("pubky_auth__requested_permissions"), textColor: .white64).frame(minHeight: 18)
 
             ForEach(Array(config.request.permissions.enumerated()), id: \.offset) { _, permission in
                 permissionRow(permission)
@@ -525,8 +524,11 @@ struct PubkyAuthApprovalSheet: View {
 
     private func permissionRow(_ permission: PubkyAuthPermission) -> some View {
         HStack(spacing: 4) {
-            Image(systemName: "folder")
-                .font(.system(size: 16))
+            Image("permission-folder")
+                .resizable()
+                .scaledToFit()
+                .frame(width: 13, height: 11)
+                .frame(width: 16, height: 16)
                 .foregroundColor(.white)
 
             BodySSBText(permission.displayPath)
@@ -535,13 +537,13 @@ struct PubkyAuthApprovalSheet: View {
             Spacer()
 
             CaptionMText(permission.displayAccess, textColor: .gray1)
-        }
+        }.frame(minHeight: 20)
     }
 
     private var trustWarning: some View {
         VStack(alignment: .leading, spacing: 8) {
-            CaptionMText(t("pubky_auth__before_you_continue"), textColor: .white64)
-            BodySText(t("pubky_auth__trust_warning"))
+            CaptionMText(t("pubky_auth__before_you_continue"), textColor: .white64).frame(minHeight: 18)
+            BodySText(t("pubky_auth__trust_warning"), kerning: 0, lineHeight: 20)
                 .fixedSize(horizontal: false, vertical: true)
         }
     }
@@ -570,7 +572,7 @@ struct PubkyAuthApprovalSheet: View {
                 )
                 .lineLimit(1)
 
-                BodyMSBText(pubkyProfile.displayName ?? "")
+                BodyMSBText(pubkyProfile.displayName ?? "", kerning: 0)
                     .lineLimit(1)
                     .truncationMode(.tail)
             }
diff --git a/Bitkit/Views/Sheets/Sheet.swift b/Bitkit/Views/Sheets/Sheet.swift
index bc8fef259..b6b715f22 100644
--- a/Bitkit/Views/Sheets/Sheet.swift
+++ b/Bitkit/Views/Sheets/Sheet.swift
@@ -53,6 +53,7 @@ struct SheetHeader: View {
     let topPadding: CGFloat
     let bottomPadding: CGFloat
     let dragIndicatorTopPadding: CGFloat?
+    let titleKerning: CGFloat
     let onBack: (() -> Void)?
 
     init(
@@ -62,6 +63,7 @@ struct SheetHeader: View {
         topPadding: CGFloat = 32,
         bottomPadding: CGFloat = 24,
         dragIndicatorTopPadding: CGFloat? = nil,
+        titleKerning: CGFloat = 0.4,
         onBack: (() -> Void)? = nil
     ) {
         self.title = title
@@ -70,6 +72,7 @@ struct SheetHeader: View {
         self.topPadding = topPadding
         self.bottomPadding = bottomPadding
         self.dragIndicatorTopPadding = dragIndicatorTopPadding
+        self.titleKerning = titleKerning
         self.onBack = onBack
     }
 
@@ -95,7 +98,7 @@ struct SheetHeader: View {
                     .frame(width: 24, height: 24)
             }
 
-            SubtitleText(title)
+            SubtitleText(title, kerning: titleKerning)
                 .frame(maxWidth: .infinity, alignment: .center)
 
             if let action {
diff --git a/Bitkit/Views/Sheets/UsdtIntroSheet.swift b/Bitkit/Views/Sheets/UsdtIntroSheet.swift
index 912ac620f..05ebed152 100644
--- a/Bitkit/Views/Sheets/UsdtIntroSheet.swift
+++ b/Bitkit/Views/Sheets/UsdtIntroSheet.swift
@@ -31,14 +31,14 @@ struct UsdtIntroContent: View {
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
             SheetHeader(title: t(isEnablePrompt ? "usdt__enable" : "usdt__intro_title"), topPadding: 28, bottomPadding: 22,
-                        dragIndicatorTopPadding: 8)
+                        dragIndicatorTopPadding: 8, titleKerning: 0)
             GeometryReader { geometry in
                 ScrollView(showsIndicators: false) {
                     VStack(alignment: .leading, spacing: 32) {
                         UsdtCoinIllustration().frame(maxWidth: .infinity)
                         VStack(alignment: .leading, spacing: 8) {
                             DisplayText(t("usdt__intro_headline"), accentColor: .usdtAccent, kerning: -2)
-                            BodyMText(t("usdt__intro_description"), textColor: .textSecondary)
+                            BodyMText(t("usdt__intro_description"), textColor: .textSecondary, kerning: 0, lineHeight: 22)
                         }
                     }
                     .frame(minHeight: geometry.size.height, alignment: .bottom)
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index 48e4462b7..da1ec546a 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -156,7 +156,8 @@ struct SendAmountView: View {
                     if app.paykitUsesUsdt {
                         VStack(alignment: .leading, spacing: 4) {
                             CaptionMText(t("wallet__send_available"))
-                            BodySSBText(settings.hideBalance ? "•••••" : "$ " + (usdt.balance.map { usdtOverviewAmount($0) } ?? "—"))
+                            BodySSBText(settings.hideBalance ? "•••••" : "<accent>$</accent> " + (usdt.balance.map { usdtOverviewAmount($0) } ?? "—"),
+                                        accentColor: .textSecondary)
                         }
                     } else {
                         AvailableAmount(
@@ -209,7 +210,7 @@ struct SendAmountView: View {
                         .accessibilityIdentifier("SendNumberPadUnit")
                     }
                 }
-                .padding(.bottom, 12)
+                .padding(.bottom, app.paykitUsesUsdt ? 16 : 12)
 
                 Divider()
 
@@ -448,7 +449,7 @@ struct SendAmountView: View {
                             }
                             Spacer(minLength: 0)
                             if source == selectedFundingSource {
-                                Image("check").resizable().scaledToFit().frame(width: 16, height: 16)
+                                Image("check-mark").resizable().scaledToFit().frame(width: 16, height: 16)
                                     .foregroundStyle(fundingSourceColor(source))
                             }
                         }
diff --git a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
index df1730f22..00dd1ad2e 100644
--- a/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
+++ b/Bitkit/Views/Wallets/Sheets/ReceivedTx.swift
@@ -39,7 +39,8 @@ struct ReceivedTx: View {
             ZStack {
                 PaymentCelebration(
                     isOnchain: isOnchain, isReceived: true,
-                    confettiColor: config.details.usdtAmount != nil ? .usdtAccent : nil
+                    confettiColor: config.details.usdtAmount != nil ? .usdtAccent : nil,
+                    isUsdt: config.details.usdtAmount != nil
                 )
 
                 VStack(alignment: .leading, spacing: 0) {
diff --git a/Bitkit/Views/Wallets/UsdtNetworkPicker.swift b/Bitkit/Views/Wallets/UsdtNetworkPicker.swift
index 66b22cda2..ae506be2d 100644
--- a/Bitkit/Views/Wallets/UsdtNetworkPicker.swift
+++ b/Bitkit/Views/Wallets/UsdtNetworkPicker.swift
@@ -10,7 +10,7 @@ struct UsdtNetworkRow: View {
         Button(action: onSelect) {
             HStack(spacing: 16) {
                 Image("tether-circle").resizable().scaledToFit().frame(width: 40, height: 40)
-                BodyMSBText(title)
+                BodyMSBText(title, kerning: 0)
                 Spacer(minLength: 0)
                 if selected {
                     Image("check-mark").resizable().scaledToFit().frame(width: 20, height: 20).foregroundColor(.usdtAccent)
@@ -32,7 +32,7 @@ struct UsdtNetworkPicker<Rows: View>: View {
         ScrollView(showsIndicators: false) {
             VStack(spacing: 8) {
                 rows()
-                BodySText(note, textColor: .textSecondary)
+                BodySText(note, textColor: .textSecondary, kerning: 0, lineHeight: 20)
                     .frame(maxWidth: .infinity, alignment: .leading).padding(.vertical, 16)
                 UsdtCoinIllustration()
             }
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 70a4974f0..ec0a127d8 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -145,7 +145,7 @@ struct UsdtSendView: View {
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         .background {
             if submitted, !busy, submittedStatus == .confirmed {
-                PaymentCelebration(isOnchain: true, isReceived: false, confettiColor: .usdtAccent)
+                PaymentCelebration(isOnchain: true, isReceived: false, confettiColor: .usdtAccent, isUsdt: true)
             }
         }
         .background(Color.gray7)
@@ -194,13 +194,13 @@ struct UsdtSendView: View {
 
     private var networkButton: some View {
         Button { recipientFocused = false; showingNetworks = true } label: {
-            HStack(spacing: 4) {
+            HStack(spacing: 8) {
                 Image("usdt-network").resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(.usdtAccent)
-                CaptionBText(destination.label).lineLimit(1).minimumScaleFactor(0.8)
+                CaptionBText(destination.label, kerning: 0).lineLimit(1).minimumScaleFactor(0.8)
             }
-            .padding(.horizontal, 8).frame(height: 28)
-            .background(Color.white06, in: Capsule())
-            .overlay(Capsule().stroke(Color.white10, lineWidth: 1))
+            .padding(.horizontal, 12).frame(height: 28)
+            .background(Color.white01, in: RoundedRectangle(cornerRadius: 12))
+            .overlay(RoundedRectangle(cornerRadius: 12).stroke(Color.white16, lineWidth: 1))
         }
         .disabled(embedded || destinations.count < 2 || busy)
         .accessibilityIdentifier("UsdtNetwork")
@@ -228,8 +228,13 @@ struct UsdtSendView: View {
     private var recipientContent: some View {
         VStack(spacing: 8) {
             networkSelector.padding(.bottom, 8)
-            Scanner(onScan: { payload in if let value = payload.string { useRecipient(value) } }, onImageSelection: readImage)
-                .frame(maxWidth: .infinity, maxHeight: .infinity)
+            Scanner(
+                accentColor: .usdtAccent,
+                permissionDescription: t("usdt__camera_permission"),
+                onScan: { payload in if let value = payload.string { useRecipient(value) } },
+                onImageSelection: readImage
+            )
+            .frame(maxWidth: .infinity, maxHeight: .infinity)
             RectangleButton(
                 icon: "clipboard", iconColor: .usdtAccent, title: t("common__paste"), testID: "UsdtPaste"
             ) {
@@ -273,21 +278,18 @@ struct UsdtSendView: View {
             if let error {
                 BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError").padding(.bottom, 16)
             }
-            HStack(alignment: .bottom) {
-                VStack(alignment: .leading, spacing: 8) {
-                    CaptionMText(t("wallet__send_available"))
-                    BodySSBText(settings.hideBalance ? " • • • • •" : "$ " + (usdt.balance.map { usdtOverviewAmount($0) } ?? "—"))
+            ViewThatFits(in: .horizontal) {
+                HStack(alignment: .bottom) {
+                    availableBalance
+                    Spacer(minLength: 8)
+                    amountActions
                 }
-                Spacer()
-                NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
-                if !embedded {
-                    NumberPadActionButton(text: t("common__max"), color: .usdtAccent, disabled: busy,
-                                          isLoading: preparingMaximum)
-                    {
-                        Task { await useMaximum() }
+                VStack(alignment: .leading, spacing: 16) {
+                    availableBalance
+                    HStack {
+                        Spacer(minLength: 0)
+                        amountActions
                     }
-                    .accessibilityIdentifier("UsdtMax")
-                    networkButton
                 }
             }
             .padding(.bottom, 16)
@@ -321,6 +323,41 @@ struct UsdtSendView: View {
         }
     }
 
+    private var availableBalance: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            CaptionMText(t("wallet__send_available"))
+            BodySSBText(settings.hideBalance ? " • • • • •" : "<accent>$</accent> " + (usdt.balance.map { usdtOverviewAmount($0) } ?? "—"),
+                        accentColor: .textSecondary)
+        }
+        .fixedSize(horizontal: true, vertical: false)
+    }
+
+    private var amountActions: some View {
+        HStack(spacing: 8) {
+            NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
+            if !embedded {
+                NumberPadActionButton(text: t("common__max"), color: .usdtAccent, disabled: busy,
+                                      isLoading: preparingMaximum)
+                {
+                    Task { await useMaximum() }
+                }
+                .accessibilityIdentifier("UsdtMax")
+                networkButton
+            }
+        }
+        .fixedSize(horizontal: true, vertical: false)
+    }
+
+    private var reviewDetailsButton: some View {
+        CustomButton(
+            title: t(showDetails ? "common__hide_details" : "common__show_details"), size: .small,
+            icon: Image(showDetails ? "eye-slash" : "speed-normal").resizable().frame(width: 16, height: 16)
+                .foregroundColor(.usdtAccent), background: Color.white06
+        ) { showDetails.toggle() }
+            .frame(maxWidth: .infinity)
+            .accessibilityIdentifier("UsdtReviewDetails")
+    }
+
     private func confirmation(_ quote: UsdtQuote) -> some View {
         VStack(alignment: .leading, spacing: 0) {
             GeometryReader { geometry in
@@ -359,13 +396,9 @@ struct UsdtSendView: View {
                                 .multilineTextAlignment(.center).frame(maxWidth: .infinity).padding(.top, 16)
                         }
                         if let error { BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtError") }
-                        CustomButton(
-                            title: t(showDetails ? "common__hide_details" : "common__show_details"), size: .small,
-                            icon: Image(showDetails ? "eye-slash" : "speed-normal").resizable().frame(width: 16, height: 16)
-                                .foregroundColor(.usdtAccent), background: Color.white06
-                        ) { showDetails.toggle() }
-                            .frame(maxWidth: .infinity).padding(.vertical, 24)
-                            .accessibilityIdentifier("UsdtReviewDetails")
+                        if quote.destination == .arbitrum {
+                            reviewDetailsButton.padding(.vertical, 24)
+                        }
                         if showDetails { Spacer(minLength: 0) }
                     }
                     .frame(minHeight: geometry.size.height, alignment: .top)
@@ -373,6 +406,7 @@ struct UsdtSendView: View {
                 .id(showDetails)
             }
             if quote.destination != .arbitrum {
+                reviewDetailsButton.padding(.top, 12)
                 SendSectionView(t("usdt__maximum_total")) {
                     BodySSBText(usdtOverviewAmount(quote.amount + quote.maximumFee) + " USDT")
                 }
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index b9e7cda7f..b1bfdc3c3 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -8488,6 +8488,93 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         )))
     }
 
+    func testUsdtProofFailureDoesNotBlockLaterProofsOrReceiptVerification() async throws {
+        defer { try? Keychain.delete(key: .paykitUsdtPayments) }
+        let identity = "pubky1rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg"
+        let contact = "pubky3rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg"
+        let endpoint = PublicPaykitService.MethodId.usdtArbitrum.rawValue
+        let proof = UsdtPaymentProof(chainId: "42161", transactionHash: "transaction", receiptLogIndex: "0", signature: "signature")
+        let attempts = try (0 ... 1).map { index in
+            let record = try paymentRequestRecord(id: "550e8400-e29b-41d4-a716-44665544000\(index)", counterparty: contact,
+                                                  amount: "0.05", asset: "usdt", endpoints: [endpoint])
+            let request = try XCTUnwrap(PaykitPaymentRequest(historyRecord: record, now: Date()))
+            let binding = try PaykitUsdtPaymentService.binding(request: request, identity: identity, paymentAppId: "bitkit",
+                                                               quoteId: nil, period: nil)
+            return PaykitUsdtPaymentService.Attempt(quoteId: "quote-\(index)", wallet: "wallet", identity: identity,
+                                                    contact: contact, requestId: request.id, binding: binding, billingPeriod: nil)
+        }
+        let receivedProof = try PaymentProofRecord(
+            eventId: "750e8400-e29b-41d4-a716-446655440000", outboundMessageId: nil, outboundStatus: nil, streamItemId: 2,
+            paymentReference: PaymentReference(text: "invoice-123"), billingPeriod: nil, paymentAppId: "bitkit",
+            paymentEndpointIdentifier: endpoint, allowanceId: nil, conversionQuoteId: nil,
+            proof: PrivateJsonObject(text: String(decoding: JSONEncoder().encode(PaykitUsdtPaymentService.Proof(proof)), as: UTF8.self)),
+            recordedAt: "2027-01-15T08:01:00Z"
+        )
+        let received = try paymentRequestRecord(id: "550e8400-e29b-41d4-a716-446655440002", counterparty: contact,
+                                                state: .proofSubmitted, role: .payee, amount: "0.05", asset: "usdt",
+                                                endpoints: [endpoint], paymentProofs: [receivedProof])
+        for generationFails in [true, false] {
+            try Keychain.delete(key: .paykitUsdtPayments)
+            let service = PaykitUsdtPaymentService()
+            try service.restoreBackup(PaykitUsdtStateBackup(attempts: attempts.map(PaykitUsdtStateBackup.Attempt.init), receipts: []))
+            var verified = 0
+            for _ in 0 ... 1 {
+                await service.reconcile(
+                    context: { ("wallet", identity) },
+                    storedTransfer: { id in self.usdtTransfer(id, status: .confirmed) },
+                    paymentProof: { id, _ in
+                        if generationFails, id == "quote-0" { throw UsdtError.InvalidCredentials }
+                        return proof
+                    },
+                    submitProof: { $0.paymentIdentifier != "quote-0" },
+                    paymentRequests: { [received] },
+                    verifyPayment: { _, _ in
+                        verified += 1
+                        return UsdtVerifiedPayment(paymentId: "42161:transaction:0", transferId: "transaction:0", sender: contact,
+                                                   recipient: "wallet", amount: 50000, timestamp: 1_800_000_000)
+                    }
+                )
+                XCTAssertFalse(try XCTUnwrap(service.attempts.first { $0.quoteId == "quote-0" }).proofQueued)
+                XCTAssertTrue(try XCTUnwrap(service.attempts.first { $0.quoteId == "quote-1" }).proofQueued)
+                XCTAssertEqual(service.receipts.count, 1)
+                XCTAssertTrue(try XCTUnwrap(service.receipts.first).satisfied)
+            }
+            XCTAssertEqual(verified, 2)
+        }
+    }
+
+    func testUsdtProofCancellationStopsLaterAttemptsAndReceiptVerification() async throws {
+        defer { try? Keychain.delete(key: .paykitUsdtPayments) }
+        let identity = "pubky1rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg"
+        let contact = "pubky3rsduhcxpw74snwyct86m38c63j3pq8x4ycqikxg64roik8yw5xg"
+        let record = try paymentRequestRecord(counterparty: contact, amount: "0.05", asset: "usdt",
+                                              endpoints: [PublicPaykitService.MethodId.usdtArbitrum.rawValue])
+        let request = try XCTUnwrap(PaykitPaymentRequest(historyRecord: record, now: Date()))
+        let binding = try PaykitUsdtPaymentService.binding(request: request, identity: identity, paymentAppId: "bitkit", quoteId: nil, period: nil)
+        let attempt = PaykitUsdtPaymentService.Attempt(quoteId: "quote", wallet: "wallet", identity: identity, contact: contact,
+                                                       requestId: request.id, binding: binding, billingPeriod: nil)
+        let service = PaykitUsdtPaymentService()
+        try service.restoreBackup(PaykitUsdtStateBackup(attempts: [.init(attempt)], receipts: []))
+        var submitted = false
+        var loadedReceipts = false
+        await service.reconcile(
+            context: { ("wallet", identity) }, storedTransfer: { id in self.usdtTransfer(id, status: .confirmed) },
+            paymentProof: { _, _ in throw CancellationError() },
+            submitProof: { _ in submitted = true; return true },
+            paymentRequests: { loadedReceipts = true; return [] }, verifyPayment: { _, _ in nil }
+        )
+        XCTAssertFalse(submitted)
+        XCTAssertFalse(loadedReceipts)
+        XCTAssertFalse(try XCTUnwrap(service.attempts.first).proofQueued)
+        XCTAssertTrue(service.hasBinding(for: request.id))
+    }
+
+    private func usdtTransfer(_ id: String, status: UsdtTransferStatus) -> UsdtTransfer {
+        UsdtTransfer(sender: nil, id: id, txHash: nil, userOperationHash: nil, bridgeGuid: nil, orchestra: nil,
+                     recipient: "recipient", destination: .arbitrum, amount: 50000, receivedAmount: 50000,
+                     fee: nil, isIncoming: false, status: status, timestamp: 1)
+    }
+
     private func paymentRequestRecord(
         id: String = "550e8400-e29b-41d4-a716-446655440000",
         counterparty: String = "pubkypayee",
diff --git a/BitkitTests/PaykitPaymentStateBackupTests.swift b/BitkitTests/PaykitPaymentStateBackupTests.swift
index 256a1423e..fa00ae9ee 100644
--- a/BitkitTests/PaykitPaymentStateBackupTests.swift
+++ b/BitkitTests/PaykitPaymentStateBackupTests.swift
@@ -148,6 +148,148 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         XCTAssertTrue(try service.satisfiedProofs(identity: counterparty).isEmpty)
     }
 
+    @MainActor
+    func testUnsubmittedUsdtBindingRequiresCurrentJournalEvidenceAfterRestart() async throws {
+        let service = PaykitUsdtPaymentService()
+        let attempt = unsubmittedUsdtAttempt()
+        let requestId = try XCTUnwrap(attempt.requestId)
+        try saveUsdtAttempts([attempt])
+        XCTAssertTrue(service.hasBinding(for: requestId))
+        await reconcileUsdt(service)
+        XCTAssertFalse(service.hasBinding(for: requestId))
+
+        let restarted = PaykitUsdtPaymentService()
+        XCTAssertTrue(restarted.hasBinding(for: requestId))
+        await reconcileUsdt(restarted)
+        XCTAssertFalse(restarted.hasBinding(for: requestId))
+        await reconcileUsdt(restarted) { _ in throw PaykitPaymentStateBackupTestError.restoreFailed }
+        XCTAssertTrue(restarted.hasBinding(for: requestId))
+
+        for status in [UsdtTransferStatus.pending, .confirmed, .bridging] {
+            await reconcileUsdt(restarted)
+            XCTAssertFalse(restarted.hasBinding(for: requestId))
+            await reconcileUsdt(restarted) { id in
+                UsdtTransfer(sender: nil, id: id, txHash: nil, userOperationHash: nil, bridgeGuid: nil, orchestra: nil,
+                             recipient: "recipient", destination: .arbitrum, amount: 50000, receivedAmount: 50000,
+                             fee: nil, isIncoming: false, status: status, timestamp: 1)
+            }
+            XCTAssertTrue(restarted.hasBinding(for: requestId))
+        }
+    }
+
+    @MainActor
+    func testChangedUsdtAttemptsAndUnreadablePersistenceInvalidateReleaseEvidence() async throws {
+        let service = PaykitUsdtPaymentService()
+        let attempt = unsubmittedUsdtAttempt()
+        let requestId = try XCTUnwrap(attempt.requestId)
+        var started = attempt
+        started.paymentStarted = true
+        var proved = attempt
+        proved.proof = PaykitUsdtPaymentService.Proof(UsdtPaymentProof(chainId: "42161", transactionHash: "transaction",
+                                                                       receiptLogIndex: "0", signature: "signature"))
+        var queued = attempt
+        queued.proofQueued = true
+        let replacement = PaykitUsdtPaymentService.Attempt(quoteId: "replacement", wallet: attempt.wallet, identity: identity,
+                                                           contact: attempt.contact, requestId: requestId, binding: nil, billingPeriod: nil)
+        for changed in [started, proved, queued, replacement] {
+            try saveUsdtAttempts([attempt])
+            await reconcileUsdt(service)
+            XCTAssertFalse(service.hasBinding(for: requestId))
+            try saveUsdtAttempts([changed])
+            XCTAssertTrue(service.hasBinding(for: requestId))
+            if changed != replacement {
+                await reconcileUsdt(service)
+                XCTAssertTrue(service.hasBinding(for: requestId))
+            }
+        }
+        try saveUsdtAttempts([attempt])
+        await reconcileUsdt(service)
+        try Keychain.upsert(key: .paykitUsdtPayments, data: Data("unreadable".utf8))
+        XCTAssertTrue(service.hasBinding(for: requestId))
+        await reconcileUsdt(service)
+        XCTAssertTrue(service.hasBinding(for: requestId))
+    }
+
+    @MainActor
+    func testUsdtRestoreInvalidatesReleaseEvidenceBeforeReconciliation() async throws {
+        let service = PaykitUsdtPaymentService()
+        var attempt = unsubmittedUsdtAttempt()
+        let requestId = try XCTUnwrap(attempt.requestId)
+        try saveUsdtAttempts([attempt])
+        await reconcileUsdt(service)
+        XCTAssertFalse(service.hasBinding(for: requestId))
+        try service.restoreBackup(PaykitUsdtStateBackup(attempts: [.init(attempt)], receipts: []))
+        XCTAssertTrue(service.hasBinding(for: requestId))
+        XCTAssertTrue(service.resumableRequests.isEmpty)
+        await reconcileUsdt(service) { id in
+            UsdtTransfer(sender: nil, id: id, txHash: nil, userOperationHash: nil, bridgeGuid: nil, orchestra: nil,
+                         recipient: "recipient", destination: .arbitrum, amount: 50000, receivedAmount: 50000,
+                         fee: nil, isIncoming: false, status: .pending, timestamp: 1)
+        }
+        XCTAssertTrue(service.hasBinding(for: requestId))
+        await reconcileUsdt(service)
+        XCTAssertFalse(service.hasBinding(for: requestId))
+        attempt.paymentStarted = true
+        try service.restoreBackup(PaykitUsdtStateBackup(attempts: [.init(attempt)], receipts: []))
+        XCTAssertTrue(service.hasBinding(for: requestId))
+        await reconcileUsdt(service)
+        XCTAssertTrue(service.hasBinding(for: requestId))
+    }
+
+    @MainActor
+    func testUsdtRestoreInvalidatesSuspendedReconciliationEvidence() async throws {
+        let service = PaykitUsdtPaymentService()
+        let attempt = unsubmittedUsdtAttempt()
+        let requestId = try XCTUnwrap(attempt.requestId)
+        try saveUsdtAttempts([attempt])
+        let entered = expectation(description: "journal read started")
+        let gate = AsyncStream<Void>.makeStream()
+        defer { gate.continuation.finish() }
+        let reconciliation = Task {
+            await reconcileUsdt(service) { _ in
+                entered.fulfill()
+                for await _ in gate.stream {
+                    break
+                }
+                return nil
+            }
+        }
+        await fulfillment(of: [entered], timeout: 2)
+        try service.restoreBackup(PaykitUsdtStateBackup(attempts: [.init(attempt)], receipts: []))
+        gate.continuation.yield(())
+        gate.continuation.finish()
+        await reconciliation.value
+        XCTAssertTrue(service.hasBinding(for: requestId))
+        XCTAssertTrue(service.resumableRequests.isEmpty)
+        await reconcileUsdt(service)
+        XCTAssertFalse(service.hasBinding(for: requestId))
+    }
+
+    @MainActor
+    private func unsubmittedUsdtAttempt() -> PaykitUsdtPaymentService.Attempt {
+        let id = PaykitPaymentRequest.ID(paymentRequestId: "request", counterparty: "counterparty")
+        return PaykitUsdtPaymentService.Attempt(quoteId: "quote", wallet: "wallet", identity: identity, contact: id.counterparty,
+                                                requestId: id, binding: nil, billingPeriod: nil)
+    }
+
+    @MainActor
+    private func saveUsdtAttempts(_ attempts: [PaykitUsdtPaymentService.Attempt]) throws {
+        struct State: Encodable {
+            let attempts: [PaykitUsdtPaymentService.Attempt]
+            let receipts: [PaykitUsdtPaymentService.Receipt] = []
+        }
+        try Keychain.upsert(key: .paykitUsdtPayments, data: JSONEncoder().encode(State(attempts: attempts)))
+    }
+
+    @MainActor
+    private func reconcileUsdt(_ service: PaykitUsdtPaymentService,
+                               storedTransfer: (String) async throws -> UsdtTransfer? = { _ in nil }) async
+    {
+        await service.reconcile(context: { ("wallet", self.identity) }, storedTransfer: storedTransfer,
+                                paymentProof: { _, _ in nil }, submitProof: { _ in false }, paymentRequests: { [] },
+                                verifyPayment: { _, _ in nil })
+    }
+
     func testWalletBackupWritesWaitForEarlierUploadAndRecoverAfterFailure() async throws {
         let writer = WalletBackupWriter()
         let entered = expectation(description: "upload started")
diff --git a/journeys/usdt-send-review-and-details.xml b/journeys/usdt-send-review-and-details.xml
index 2d7b5fd0c..1edb96b80 100644
--- a/journeys/usdt-send-review-and-details.xml
+++ b/journeys/usdt-send-review-and-details.xml
@@ -2,12 +2,12 @@
   <description>Use an onboarded wallet with USDT, a fresh BTC/USD rate, an owned recipient and existing sent/received activity. Quotes require the service with MAX support. No payment is submitted.</description>
   <actions>
     <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
-    <action>Open USDT Send and enter the owned recipient. On Amount, verify the BTC equivalent above the dollar amount, 32-point gap before Available balance, USDT badge, MAX and network pill. Enter a six-decimal amount and verify no precision is lost.</action>
+    <action>Open USDT Send and enter the owned recipient. On Amount, verify the BTC equivalent above the dollar amount, 32-point gap before Available balance, USDT badge, MAX and network pill. Enter a six-decimal amount and verify no precision is lost. With a large available balance and BNB Smart Chain selected, verify both values remain fully readable; the controls may wrap onto a second row.</action>
     <action>Open the network pill and verify the full USDT Network picker, Tether rows and selected teal check. Select another EVM network. Verify the amount and valid recipient remain. Change to Solana with an EVM recipient and verify recipient entry is required. Enter an owned plain Solana address and verify the previous amount remains. Return to Arbitrum, enter the owned EVM address and verify the amount still remains.</action>
     <action>From recipient entry with another network selected, paste an explicit Arbitrum USDT URI. Verify the selected network becomes Arbitrum and the link amount is retained. A plain 0x address preserves the selected network.</action>
     <action>Tap MAX. Verify it fills a positive amount below the balance and remains on Amount. Continue and verify the payment plus maximum fee fits within the balance. Back out without swiping.</action>
     <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note in the scrollable details. Displayed amounts round to cents; nonzero values below one cent show &lt;0.01. Hide Details restores the illustration. Cancel without paying.</action>
-    <action>Prepare a cross-network payment and continue. Verify You send labels the entered amount and Recipient gets appears directly beneath it, with an approximation marker for Orchestra. Verify the recipient amount follows the quote rather than assuming it equals the sent amount. Without scrolling, verify Maximum total debit (id "UsdtMaximumTotal") and its value are fully visible above Swipe To Pay. Show Details and verify the maximum remains visible, Payment is labelled You send, and the fee note can be read by scrolling without overlapping the pinned total. For Orchestra, also verify the deducted bridge cost is fully readable when scrolled into view. Cancel without paying.</action>
+    <action>Prepare a cross-network payment and continue. Verify You send labels the entered amount and Recipient gets appears directly beneath it, with an approximation marker for Orchestra. Verify the recipient amount follows the quote rather than assuming it equals the sent amount. Without scrolling, verify Show Details (id "UsdtReviewDetails"), Maximum total debit (id "UsdtMaximumTotal") and its value are fully visible above Swipe To Pay. Show Details and verify Hide Details remains visible above the maximum, Payment is labelled You send, and the fee note can be read by scrolling without overlapping the pinned total. For Orchestra, also verify the deducted bridge cost is fully readable when scrolled into view. Cancel without paying.</action>
     <action>Open an existing sent USDT activity. Verify the heading is Sent USDT, the signed amount includes the actual fee, and summary rows show Status/Network, Date/Time and Payment/Fee with teal icons. Open Details and verify transaction ID, known sender, recipient and source/destination networks; Open Block Explorer stays at the bottom.</action>
     <action>Open an existing received activity. Verify Received USDT and a positive amount. Verify Details shows the verified sender when available and does not invent one for older unknown records. Check pending, failed and transferring rows use their matching icons, and transferring shows its destination.</action>
     <action>Prepare a contact payment that accepts multiple payment methods. Open the payment-source button and verify the balance menu shows Savings, Spending, any paired hardware wallet and USDT. Unsupported methods are disabled. Select a supported method and verify its label, available balance and payable amount update. Cancel without paying.</action>

From d7cc4a52734fd7b152328b2754b201efc2d1e0f7 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 11:36:14 -0500
Subject: [PATCH 39/62] fix: respect usdt opt-in across payment flows

---
 Bitkit/AppScene.swift                         |   3 +
 .../PaymentReviewIllustration.swift           |   2 +
 Bitkit/MainNavView.swift                      |   3 +-
 Bitkit/Managers/UsdtWalletManager.swift       |  24 +++-
 Bitkit/Models/PubkyAuthRequest.swift          |   4 +
 .../Localization/en.lproj/Localizable.strings |   6 +-
 Bitkit/Services/PubkyService.swift            |  17 ++-
 Bitkit/Utilities/ClipboardPrompt.swift        |   5 +-
 Bitkit/ViewModels/SettingsViewModel.swift     |   4 +
 .../Views/Settings/GeneralSettingsView.swift  |  19 ++-
 .../PubkyAuthApprovalSheet.swift              |  88 +++++++-------
 .../Views/Wallets/Send/SendAmountView.swift   |   5 +
 Bitkit/Views/Wallets/UsdtActivityDetail.swift |   4 +-
 .../Views/Wallets/UsdtReceiveAmountView.swift |   4 +-
 Bitkit/Views/Wallets/UsdtSendView.swift       |  24 +++-
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |   8 +-
 .../ClipboardPromptValidatorTests.swift       |  26 ++--
 BitkitTests/PubkyAuthApprovalSheetTests.swift | 112 +++++++++++++++++-
 BitkitTests/UsdtDisplayTests.swift            |   8 ++
 BitkitTests/UsdtPaymentLinkTests.swift        |  12 ++
 BitkitTests/UsdtWalletManagerTests.swift      |  59 +++++++++
 Docs/USDT.md                                  |   4 +-
 .../pubky-auth/share-receiving-details.xml    |   9 +-
 journeys/usdt-opt-in.xml                      |   8 +-
 journeys/usdt-payment-links-and-scans.xml     |   5 +-
 25 files changed, 383 insertions(+), 80 deletions(-)

diff --git a/Bitkit/AppScene.swift b/Bitkit/AppScene.swift
index ccb98024c..3af01935a 100644
--- a/Bitkit/AppScene.swift
+++ b/Bitkit/AppScene.swift
@@ -659,6 +659,9 @@ struct AppScene: View {
 
     private var appEventContent: some View {
         paykitEventContent
+            .onChange(of: wallet.usdtWallet.hasProtectedFunds, initial: true) { _, hasProtectedFunds in
+                settings.protectUsdtFunds(hasProtectedFunds)
+            }
             .onChange(of: settings.usdtPreference) { _, _ in
                 PublicPaykitService.setCleanupPending(true)
                 Task {
diff --git a/Bitkit/Components/PaymentReviewIllustration.swift b/Bitkit/Components/PaymentReviewIllustration.swift
index d42265a26..92ab60da6 100644
--- a/Bitkit/Components/PaymentReviewIllustration.swift
+++ b/Bitkit/Components/PaymentReviewIllustration.swift
@@ -3,11 +3,13 @@ import SwiftUI
 struct PaymentReviewIllustration: View {
     var swipeProgress: CGFloat = 0
     var maximumHeight: CGFloat?
+    var imageSize: CGFloat?
 
     var body: some View {
         Image("coin-stack-4")
             .resizable()
             .aspectRatio(contentMode: .fit)
+            .frame(width: imageSize, height: imageSize)
             .frame(maxHeight: maximumHeight)
             .frame(width: UIScreen.main.bounds.width * 0.8)
             .frame(maxWidth: .infinity)
diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 45c41635f..38e34cc39 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -724,7 +724,8 @@ struct MainNavView: View {
                 await ClipboardPromptValidator.isSupportedURI(
                     uri,
                     ownPublicKey: pubkyProfile.publicKey,
-                    contacts: contactsManager.contacts
+                    contacts: contactsManager.contacts,
+                    isUsdtEnabled: settings.isUsdtEnabled
                 )
             } else {
                 false
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index 6ec1999ba..ba84e2fc7 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -23,6 +23,7 @@ final class UsdtWalletManager {
         didSet { if oldValue != transfers { Self.backupStateChanged.send() } }
     }
 
+    private var pendingDepositIds: Set<String> = []
     private(set) var historyComplete = false
     private(set) var refreshing = false
     var errorMessage: String?
@@ -43,7 +44,7 @@ final class UsdtWalletManager {
     }
 
     var hasProtectedFunds: Bool {
-        UsdtPreference.protectsFunds(balance: balance, transfers: transfers)
+        UsdtPreference.protectsFunds(balance: balance, transfers: transfers) || !pendingDepositIds.isEmpty
     }
 
     func checkCanDisable() async throws {
@@ -53,7 +54,7 @@ final class UsdtWalletManager {
         let wallet = try await wallet()
         balance = try await wallet.balance()
         transfers = try await wallet.refreshTransfers()
-        guard !hasProtectedFunds else { throw UsdtWalletError.cannotDisable }
+        guard !UsdtPreference.protectsFunds(balance: balance, transfers: transfers) else { throw UsdtWalletError.cannotDisable }
         if depositsConfigured {
             var offset: UInt32 = 0
             repeat {
@@ -68,6 +69,13 @@ final class UsdtWalletManager {
                 offset = next
             } while true
         }
+        guard !hasProtectedFunds else { throw UsdtWalletError.cannotDisable }
+    }
+
+    func recordDepositStatus(id: String, status: String) {
+        guard !wiping else { return }
+        if UsdtPreference.hasPendingDeposit(status) { pendingDepositIds.insert(id) }
+        else { pendingDepositIds.remove(id) }
     }
 
     var networkName: String {
@@ -175,6 +183,7 @@ final class UsdtWalletManager {
         defer { finishOperation() }
         let wallet = try await wallet()
         try await wallet.restoreBackup(snapshot: snapshot)
+        pendingDepositIds.removeAll()
         transfers = try wallet.history()
         historyComplete = false
     }
@@ -289,15 +298,21 @@ final class UsdtWalletManager {
     }
 
     func depositHistory(offset: UInt32) async throws -> UsdtDepositPage {
-        try await withDeposits { client, mnemonic, passphrase in
+        let page = try await withDeposits { client, mnemonic, passphrase in
             try await client.history(offset: offset, mnemonic: mnemonic, passphrase: passphrase)
         }
+        for deposit in page.deposits {
+            recordDepositStatus(id: deposit.id, status: deposit.status)
+        }
+        return page
     }
 
     func depositDetail(id: String, offset: UInt32) async throws -> UsdtDepositDetail {
-        try await withDeposits { client, mnemonic, passphrase in
+        let detail = try await withDeposits { client, mnemonic, passphrase in
             try await client.detail(depositId: id, offset: offset, mnemonic: mnemonic, passphrase: passphrase)
         }
+        recordDepositStatus(id: id, status: detail.order?.status ?? detail.deposit.status)
+        return detail
     }
 
     func refundDeposit(_ deposit: UsdtDeposit, offset: UInt32, address: String) async throws {
@@ -339,6 +354,7 @@ final class UsdtWalletManager {
         address = ""
         receiveUri = ""
         transfers = []
+        pendingDepositIds.removeAll()
         historyComplete = false
         errorMessage = nil
         let directory = storageDirectory
diff --git a/Bitkit/Models/PubkyAuthRequest.swift b/Bitkit/Models/PubkyAuthRequest.swift
index 77cf81f49..2fb72d7ab 100644
--- a/Bitkit/Models/PubkyAuthRequest.swift
+++ b/Bitkit/Models/PubkyAuthRequest.swift
@@ -55,6 +55,10 @@ struct PubkyAuthClaim: Equatable {
         sharesBitcoin || sharesUsdt
     }
 
+    var requiresUsdtAddress: Bool {
+        sharesUsdt && !sharesBitcoin && !includesPaykitAccess
+    }
+
     func unsignedPayload(account: WatchOnlyAccountRecord?, usdtEndpoint: PublicPaykitService.Endpoint?) throws -> Data? {
         guard sharesUsdt else {
             return try account.map { try WatchOnlyAccountClaimCodec.encode(record: $0) }
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 87fd0d0e8..100eef940 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1909,7 +1909,7 @@
 "pubky_auth__usdt_intro_title" = "<accent>EARN USDT</accent>\nFROM YOUR\nCONTENT";
 "pubky_auth__usdt_intro_description" = "Share your existing USDT address on Arbitrum One to receive earnings directly in Bitkit. The service cannot spend your funds.";
 "pubky_auth__usdt_privacy" = "This is your existing USDT account. The service can see its balance and transaction history, but cannot spend your funds.";
-"pubky_auth__usdt_unavailable" = "Your USDT address is unavailable. You can retry or continue without sharing it.";
+"pubky_auth__usdt_unavailable" = "Your USDT address is unavailable. Please try again.";
 "pubky_auth__shared_usdt" = "Your USDT receiving address was shared.";
 "pubky_auth__shared_bitcoin" = "Your Bitcoin watch-only account was shared.";
 "pubky_auth__shared_both" = "Your Bitcoin watch-only account and USDT receiving address were shared.";
@@ -1938,7 +1938,7 @@
 "usdt__receive_fee" = "Fees";
 "usdt__receive_fees_title" = "Estimated Fees";
 
-"usdt__receive_network_note" = "Regardless of the receiving network, your USDT is credited to your Arbitrum One balance.";
+"usdt__receive_network_note" = "Note: Regardless of the network used to receive, your USDT will be credited as Arbitrum One balance.";
 
 "usdt__receive_network" = "Network: {network}";
 
@@ -1972,3 +1972,5 @@
 "usdt__settings_title" = "USDT (Tether)";
 
 "usdt__camera_permission" = "Allow camera access to scan USDT payment requests and pay more quickly.";
+
+"usdt__disabled" = "USDT is turned off.";
diff --git a/Bitkit/Services/PubkyService.swift b/Bitkit/Services/PubkyService.swift
index 8eb01f7aa..9dbbcac60 100644
--- a/Bitkit/Services/PubkyService.swift
+++ b/Bitkit/Services/PubkyService.swift
@@ -174,6 +174,7 @@ enum PubkyService {
         accountManager: WatchOnlyAccountManager? = nil,
         approvedUsdtAddress: String? = nil,
         usdtEndpoint: (() async throws -> PublicPaykitService.Endpoint)? = nil,
+        isUsdtEnabled: () -> Bool = { Env.isUsdtEnabled && UsdtPreference.isEnabled() },
         ordinaryApproval: @escaping OrdinaryAuthApproval = { authUrl, capabilities, clientID, secretKeyHex in
             try await approveAuth(
                 authUrl: authUrl,
@@ -193,12 +194,22 @@ enum PubkyService {
         }
     ) async throws {
         guard authUrl == request.rawUrl else { throw PubkyServiceError.invalidAuthUrl }
+        if request.bitkitClaim?.requiresUsdtAddress == true, !isUsdtEnabled() {
+            throw PubkyAuthRequestError.invalidPaymentDetails
+        }
         let endpoint: PublicPaykitService.Endpoint?
-        if request.bitkitClaim?.sharesUsdt == true, let approvedUsdtAddress {
+        if request.bitkitClaim?.sharesUsdt == true, isUsdtEnabled(), let approvedUsdtAddress {
             guard let usdtEndpoint else { throw PubkyAuthRequestError.invalidPaymentDetails }
             endpoint = try await usdtEndpoint()
             guard endpoint?.value == approvedUsdtAddress else { throw PubkyAuthRequestError.invalidPaymentDetails }
         } else { endpoint = nil }
+        func approvedEndpoint() throws -> PublicPaykitService.Endpoint? {
+            let currentEndpoint = isUsdtEnabled() ? endpoint : nil
+            if request.bitkitClaim?.requiresUsdtAddress == true, currentEndpoint == nil {
+                throw PubkyAuthRequestError.invalidPaymentDetails
+            }
+            return currentEndpoint
+        }
         if let claim = request.bitkitClaim, claim.includesWatchOnlyAccount {
             let accountManager = accountManager ?? .shared
             let preparedClaim = try await accountManager.prepareUnsignedClaim(
@@ -218,7 +229,7 @@ enum PubkyService {
             }
 
             do {
-                let payload = try claim.unsignedPayload(account: preparedClaim.0, usdtEndpoint: endpoint)
+                let payload = try claim.unsignedPayload(account: preparedClaim.0, usdtEndpoint: approvedEndpoint())
                 try await companionApproval(authUrl, request.clientID, claim, payload, secretKeyHex)
             } catch {
                 if !didDeliverCompanionClaim(error: error) {
@@ -232,7 +243,7 @@ enum PubkyService {
 
             try await accountManager.markSetupActive(attempt: authorizationAttempt)
         } else if let claim = request.bitkitClaim {
-            let payload = try claim.unsignedPayload(account: nil, usdtEndpoint: endpoint)
+            let payload = try claim.unsignedPayload(account: nil, usdtEndpoint: approvedEndpoint())
             try await companionApproval(authUrl, request.clientID, claim, payload, secretKeyHex)
         } else {
             try await ordinaryApproval(authUrl, request.capabilities, request.clientID, secretKeyHex)
diff --git a/Bitkit/Utilities/ClipboardPrompt.swift b/Bitkit/Utilities/ClipboardPrompt.swift
index 6ea1a3f70..dbb39080d 100644
--- a/Bitkit/Utilities/ClipboardPrompt.swift
+++ b/Bitkit/Utilities/ClipboardPrompt.swift
@@ -51,9 +51,12 @@ enum ClipboardPromptValidator {
         _ uri: String,
         ownPublicKey: String?,
         contacts: [PubkyContact],
-        isUsdtEnabled: Bool = Env.isUsdtEnabled,
+        isUsdtEnabled: Bool = Env.isUsdtEnabled && UsdtPreference.isEnabled(),
         decodeURI: (String) async -> Bool = { await (try? decode(invoice: $0)) != nil }
     ) async -> Bool {
+        if !isUsdtEnabled, (try? usdtParsePaymentRequest(value: uri.trimmingCharacters(in: .whitespacesAndNewlines))) != nil {
+            return false
+        }
         do {
             if try resolveUsdtPaymentRoute(input: uri, isEnabled: isUsdtEnabled) != nil {
                 return true
diff --git a/Bitkit/ViewModels/SettingsViewModel.swift b/Bitkit/ViewModels/SettingsViewModel.swift
index 2bfd20894..12cb58063 100644
--- a/Bitkit/ViewModels/SettingsViewModel.swift
+++ b/Bitkit/ViewModels/SettingsViewModel.swift
@@ -253,6 +253,10 @@ class SettingsViewModel: NSObject, ObservableObject {
         Env.isUsdtEnabled && usdtPreference == .enabled
     }
 
+    func protectUsdtFunds(_ hasProtectedFunds: Bool) {
+        if hasProtectedFunds { usdtPreference = .enabled }
+    }
+
     var electrumHasEdited: Bool {
         let formHost = electrumHost.trimmingCharacters(in: .whitespaces)
         let formPort = electrumPort.trimmingCharacters(in: .whitespaces)
diff --git a/Bitkit/Views/Settings/GeneralSettingsView.swift b/Bitkit/Views/Settings/GeneralSettingsView.swift
index b1effbe5d..05b826066 100644
--- a/Bitkit/Views/Settings/GeneralSettingsView.swift
+++ b/Bitkit/Views/Settings/GeneralSettingsView.swift
@@ -8,6 +8,8 @@ struct GeneralSettingsView: View {
 
     @Environment(UsdtWalletManager.self) private var usdt
     @State private var isUpdatingUsdt = false
+    @State private var isCheckingUsdt = false
+    @State private var usdtDisableBlocked = false
 
     @Environment(HwWalletManager.self) private var hwWalletManager
 
@@ -147,8 +149,9 @@ struct GeneralSettingsView: View {
                         title: t("usdt__settings_title"),
                         iconName: "usdt-settings",
                         rightIcon: nil,
-                        toggle: Binding(get: { settings.isUsdtEnabled }, set: { enabled in Task { await updateUsdt(enabled) } }),
-                        disabled: isUpdatingUsdt,
+                        toggle: Binding(get: { settings.isUsdtEnabled || usdt.hasProtectedFunds },
+                                        set: { enabled in Task { await updateUsdt(enabled) } }),
+                        disabled: isUpdatingUsdt || isCheckingUsdt || usdt.hasProtectedFunds || usdtDisableBlocked,
                         testIdentifier: "UsdtSettingsToggle"
                     )
                 }
@@ -157,6 +160,17 @@ struct GeneralSettingsView: View {
             .padding(.horizontal, 16)
             .bottomSafeAreaPadding()
         }
+        .task(id: settings.isUsdtEnabled) {
+            guard settings.isUsdtEnabled else { usdtDisableBlocked = false; return }
+            isCheckingUsdt = true
+            defer { isCheckingUsdt = false }
+            do {
+                try await usdt.checkCanDisable()
+                usdtDisableBlocked = false
+            } catch UsdtWalletError.cannotDisable {
+                usdtDisableBlocked = true
+            } catch {}
+        }
         .task {
             ContactPaymentsService.enableAllPaymentOptions()
             guard isPaykitUIActive,
@@ -179,6 +193,7 @@ struct GeneralSettingsView: View {
             settings.usdtPreference = enabled ? .enabled : .disabled
         } catch is CancellationError {
         } catch {
+            if case UsdtWalletError.cannotDisable = error { usdtDisableBlocked = true }
             app.toast(type: .warning, title: t("usdt__settings_title"), description: t("usdt__disable_unavailable"))
         }
     }
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index 08b6235a8..9721de065 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -83,7 +83,6 @@ struct PubkyAuthApprovalSheet: View {
     @State private var usdtUnavailable = false
     @State private var showsUsdtAddress = false
     @State private var shareUsdt = false
-    @State private var showsUsdtEnablePrompt = false
 
     private var createsIdentity: Bool {
         Self.requiresIdentityCreation(for: config.request, profile: pubkyProfile)
@@ -119,8 +118,12 @@ struct PubkyAuthApprovalSheet: View {
         _state = State(initialValue: Self.initialState(for: config.request))
     }
 
-    static func initialState(for request: PubkyAuthRequest) -> ApprovalState {
-        request.bitkitClaim?.sharesReceivingDetails == true ? .watchOnlyConsent : .authorize
+    static func initialState(
+        for request: PubkyAuthRequest,
+        isUsdtEnabled: Bool = Env.isUsdtEnabled && UsdtPreference.isEnabled()
+    ) -> ApprovalState {
+        let claim = request.bitkitClaim
+        return claim?.sharesBitcoin == true || (claim?.sharesUsdt == true && isUsdtEnabled) ? .watchOnlyConsent : .authorize
     }
 
     static func requiresIdentityCreation(for request: PubkyAuthRequest, profile: PubkyProfileManager) -> Bool {
@@ -138,40 +141,46 @@ struct PubkyAuthApprovalSheet: View {
         }
     }
 
+    private var hasReceivingDetails: Bool {
+        Self.initialState(for: config.request, isUsdtEnabled: settings.isUsdtEnabled) == .watchOnlyConsent
+    }
+
+    private var usdtAuthorizationUnavailable: Bool {
+        config.request.bitkitClaim?.requiresUsdtAddress == true && !settings.isUsdtEnabled
+    }
+
     private var showsBackButton: Bool {
         state == .authorize || state == .success
     }
 
     var body: some View {
         Sheet(id: .pubkyAuthApproval, data: config, backgroundColor: .gray7, applyGradient: false) {
-            if showsUsdtEnablePrompt {
-                UsdtIntroContent(
-                    isEnablePrompt: true,
-                    onDecline: { showsUsdtEnablePrompt = false },
-                    onEnable: {
-                        settings.usdtPreference = .enabled
-                        shareUsdt = true
-                        showsUsdtEnablePrompt = false
-                        Task { await loadUsdtAddress() }
-                    }
-                )
+            if usdtAuthorizationUnavailable {
+                VStack(alignment: .leading, spacing: 24) {
+                    SheetHeader(title: t("pubky_auth__title"), topPadding: 28, bottomPadding: 22, dragIndicatorTopPadding: 8)
+                    BodyMText(t("usdt__disabled"))
+                    Spacer()
+                    CustomButton(title: t("common__cancel")) { sheets.hideSheet() }
+                        .accessibilityIdentifier("PubkyAuthCancel")
+                }
+                .padding(.horizontal, 16)
+                .accessibilityElement(children: .contain)
+                .accessibilityIdentifier("PubkyAuthUsdtUnavailable")
             } else if state == .watchOnlyConsent {
                 watchOnlyConsentContent
             } else {
                 authorizationFlowContent
             }
         }
-        .task {
-            shareUsdt = settings.isUsdtEnabled
-            showsUsdtEnablePrompt = config.request.bitkitClaim?.sharesUsdt == true
-                && config.request.bitkitClaim?.sharesBitcoin != true
-                && !settings.isUsdtEnabled
+        .task(id: settings.isUsdtEnabled) {
+            shareUsdt = config.request.bitkitClaim?.sharesUsdt == true && settings.isUsdtEnabled
             await loadUsdtAddress()
         }
         .onChange(of: settings.isUsdtEnabled) { _, enabled in
             if !enabled {
                 shareUsdt = false
                 usdtAddress = nil
+                if state == .watchOnlyConsent, config.request.bitkitClaim?.sharesBitcoin != true { state = .authorize }
             }
         }
         .interactiveDismissDisabled(!state.canDismiss)
@@ -248,7 +257,8 @@ struct PubkyAuthApprovalSheet: View {
                 CustomButton(title: t("pubky_auth__title")) {
                     await onAuthorize()
                 }
-                .disabled(config.request.bitkitClaim?.sharesUsdt == true && shareUsdt && usdtAddress == nil)
+                .disabled((config.request.bitkitClaim?.requiresUsdtAddress == true && (!shareUsdt || usdtAddress == nil))
+                    || (config.request.bitkitClaim?.sharesUsdt == true && shareUsdt && usdtAddress == nil))
                 .accessibilityIdentifier("PubkyAuthAuthorize")
             }
         }
@@ -326,7 +336,7 @@ struct PubkyAuthApprovalSheet: View {
                             .padding(.bottom, 32)
                     }
 
-                    if config.request.bitkitClaim?.sharesReceivingDetails == true {
+                    if hasReceivingDetails {
                         paymentDetailsSection
                             .padding(.bottom, 24)
                     }
@@ -392,12 +402,12 @@ struct PubkyAuthApprovalSheet: View {
     }
 
     private var introTitleKey: String {
-        guard config.request.bitkitClaim?.sharesUsdt == true else { return "pubky_auth__watch_only_intro_title" }
+        guard config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled else { return "pubky_auth__watch_only_intro_title" }
         return config.request.bitkitClaim?.sharesBitcoin == true ? "pubky_auth__payment_details_intro_title" : "pubky_auth__usdt_intro_title"
     }
 
     private var introDescriptionKey: String {
-        guard config.request.bitkitClaim?.sharesUsdt == true else { return "pubky_auth__watch_only_intro_description" }
+        guard config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled else { return "pubky_auth__watch_only_intro_description" }
         return config.request.bitkitClaim?.sharesBitcoin == true ? "pubky_auth__payment_details_intro_description" : "pubky_auth__usdt_intro_description"
     }
 
@@ -418,23 +428,18 @@ struct PubkyAuthApprovalSheet: View {
                 }
                 .accessibilityIdentifier("PubkyAuthBitcoinDetails")
             }
-            if config.request.bitkitClaim?.sharesUsdt == true {
+            if config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled {
                 VStack(alignment: .leading, spacing: 8) {
-                    Toggle(isOn: Binding(
-                        get: { shareUsdt },
-                        set: { share in
-                            if share, !settings.isUsdtEnabled {
-                                showsUsdtEnablePrompt = true
-                            } else {
-                                shareUsdt = share
-                            }
+                    if config.request.bitkitClaim?.requiresUsdtAddress == true {
+                        BodySSBText("USDT", textColor: .usdtAccent)
+                    } else {
+                        Toggle(isOn: $shareUsdt) {
+                            BodySSBText(t("pubky_auth__share_usdt_optional"), textColor: .usdtAccent)
                         }
-                    )) {
-                        BodySSBText(t("pubky_auth__share_usdt_optional"), textColor: .usdtAccent)
+                        .tint(.usdtAccent)
+                        .disabled(state == .authorizing)
+                        .accessibilityIdentifier("PubkyAuthShareUsdt")
                     }
-                    .tint(.usdtAccent)
-                    .disabled(state == .authorizing)
-                    .accessibilityIdentifier("PubkyAuthShareUsdt")
                     if settings.isUsdtEnabled, let usdtAddress {
                         Button { showsUsdtAddress.toggle() } label: {
                             BodySText(showsUsdtAddress ? usdtAddress : String(usdtAddress.prefix(8)) + "…" + String(usdtAddress.suffix(6)))
@@ -470,6 +475,7 @@ struct PubkyAuthApprovalSheet: View {
             let address = try await usdt.paymentEndpoint().value
             guard settings.isUsdtEnabled else { return }
             usdtAddress = address
+            if config.request.bitkitClaim?.requiresUsdtAddress == true { shareUsdt = true }
         } catch {
             usdtAddress = nil
             usdtUnavailable = true
@@ -594,7 +600,7 @@ struct PubkyAuthApprovalSheet: View {
 
     @MainActor
     private func onAuthorize() async {
-        guard state.beginAuthorization() else { return }
+        guard !usdtAuthorizationUnavailable, state.beginAuthorization() else { return }
 
         switch resolvePubkyApprovalLocalAuthMode(
             isPinEnabled: settings.pinEnabled,
@@ -629,6 +635,7 @@ struct PubkyAuthApprovalSheet: View {
     private func performAuthorization() async {
         guard state == .authorizing else { return }
         do {
+            guard !usdtAuthorizationUnavailable else { throw PubkyAuthRequestError.invalidPaymentDetails }
             if createsIdentity {
                 try await pubkyProfile.approveSignupAuth(request: config.request)
                 guard sheets.pubkyAuthApprovalSheetItem?.request.rawUrl == config.request.rawUrl else {
@@ -650,7 +657,8 @@ struct PubkyAuthApprovalSheet: View {
                 accountName: watchOnlyAccountName,
                 secretKeyHex: secretKey,
                 approvedUsdtAddress: shareUsdt && settings.isUsdtEnabled ? usdtAddress : nil,
-                usdtEndpoint: { try await usdt.paymentEndpoint() }
+                usdtEndpoint: { try await usdt.paymentEndpoint() },
+                isUsdtEnabled: { settings.isUsdtEnabled }
             )
 
             state = .success
@@ -687,7 +695,7 @@ struct PubkyAuthApprovalSheet: View {
 
     private func onBack() {
         guard state.canDismiss else { return }
-        if state == .authorize, config.request.bitkitClaim?.sharesReceivingDetails == true {
+        if state == .authorize, hasReceivingDetails {
             state = .watchOnlyConsent
         } else {
             sheets.hideSheet()
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index da1ec546a..b81928ed9 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -216,6 +216,7 @@ struct SendAmountView: View {
 
                 NumberPad(
                     type: app.paykitUsesUsdt ? .decimal : amountViewModel.getNumberPadType(currency: currency),
+                    decimalSeparator: app.paykitUsesUsdt ? Locale.current.decimalSeparator ?? "." : ".",
                     errorKey: amountViewModel.errorKey,
                     isDisabled: !canEditAmount
                 ) { key in
@@ -447,6 +448,10 @@ struct SendAmountView: View {
                                 MoneyText(sats: Int(fundingSourceBalance(source)), forceUnit: .bitcoin, size: .bodyMSB,
                                           symbol: false, enableHide: true, fillsWidth: false)
                             }
+                            if source == .spending {
+                                Image("arrow-up-down").resizable().scaledToFit().frame(width: 16, height: 16)
+                                    .foregroundStyle(Color.white64)
+                            }
                             Spacer(minLength: 0)
                             if source == selectedFundingSource {
                                 Image("check-mark").resizable().scaledToFit().frame(width: 16, height: 16)
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index d896e67a0..597873ff5 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -162,7 +162,9 @@ struct UsdtActivityDetail: View {
         }
         SendSectionView(t("usdt__to_address")) { BodySSBText(transfer.recipient).textSelection(.enabled) }
         HStack(alignment: .top, spacing: 16) {
-            UsdtDetailCell(title: t("usdt__sender_network"), value: UsdtDestination.arbitrum.label, icon: "usdt-network")
+            if !transfer.isIncoming {
+                UsdtDetailCell(title: t("usdt__sender_network"), value: UsdtDestination.arbitrum.label, icon: "usdt-network")
+            }
             UsdtDetailCell(title: t("usdt__destination"), value: transfer.destination.label, icon: "usdt-network")
         }
         if let bridge = transfer.orchestra {
diff --git a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
index e2937213e..7cb860734 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
@@ -25,7 +25,9 @@ struct UsdtReceiveAmountView: View {
             .frame(minHeight: 146, alignment: .top)
             .fixedSize(horizontal: false, vertical: true)
             Divider()
-            NumberPad(type: .decimal, isDisabled: busy, onDeleteLongPress: { amount = "" }) { key in
+            NumberPad(type: .decimal, decimalSeparator: Locale.current.decimalSeparator ?? ".", isDisabled: busy,
+                      onDeleteLongPress: { amount = "" })
+            { key in
                 amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
             }
             .padding(.top, 34)
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index ec0a127d8..5566684f4 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -268,6 +268,7 @@ struct UsdtSendView: View {
             .accessibilityIdentifier("UsdtRecipientContinue")
         }
         .task { recipientFocused = true }
+        .onChange(of: recipient) { _, _ in error = nil }
     }
 
     private var amountContent: some View {
@@ -294,8 +295,14 @@ struct UsdtSendView: View {
             }
             .padding(.bottom, 16)
             CustomDivider()
-            NumberPad(type: .decimal, isDisabled: busy || embedded, onDeleteLongPress: { amount = ""; maximumQuote = nil }, onPress: enterAmount)
-                .frame(maxHeight: .infinity)
+            NumberPad(
+                type: .decimal,
+                decimalSeparator: Locale.current.decimalSeparator ?? ".",
+                isDisabled: busy || embedded,
+                onDeleteLongPress: { amount = ""; maximumQuote = nil },
+                onPress: enterAmount
+            )
+            .frame(maxHeight: .infinity)
             CustomButton(title: t("common__continue"), isDisabled: busy || amount.isEmpty, isLoading: busy && !preparingMaximum) {
                 guard !busy, quote == nil else { return }
                 busy = true
@@ -385,10 +392,14 @@ struct UsdtSendView: View {
                                 PaymentRequestSummary(contactName: contactName, note: requestNote, accentColor: .usdtAccent).padding(.bottom, 16)
                             }
                             Spacer(minLength: 0)
-                            PaymentReviewIllustration(swipeProgress: busy || paymentComplete ? 1 : swipeProgress, maximumHeight: 192)
-                                .padding(.top, 16).frame(height: 256)
+                            PaymentReviewIllustration(
+                                swipeProgress: busy || paymentComplete ? 1 : swipeProgress,
+                                maximumHeight: quote.destination == .arbitrum ? nil : 192,
+                                imageSize: quote.destination == .arbitrum ? 329 : nil
+                            )
+                            .padding(.top, 16).frame(height: 256)
                         }
-                        if showDetails {
+                        if showDetails, quote.destination != .arbitrum {
                             if quote.bridgeProvider == .orchestra {
                                 bridgeCost(quote).padding(.top, 16)
                             }
@@ -413,6 +424,9 @@ struct UsdtSendView: View {
                 .accessibilityElement(children: .contain)
                 .accessibilityIdentifier("UsdtMaximumTotal")
                 .padding(.vertical, 16)
+            } else if showDetails {
+                CaptionText(t("usdt__fee_note"))
+                    .multilineTextAlignment(.center).frame(maxWidth: .infinity).padding(.bottom, 16)
             }
             SwipeButton(
                 title: t("wallet__send_swipe"), accentColor: .usdtAccent, isDisabled: busy,
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index b45c660e1..13c76476e 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -136,7 +136,7 @@ struct UsdtAmountHeader: View {
                 CaptionMText("USDT", textColor: .textSecondary)
             }
             DisplayText(
-                "<accent>\(prefix)$</accent> " + (hideBalance ? " • • • • •" : displayAmount ?? amount),
+                "<accent>\(prefix)$</accent> " + (hideBalance ? " • • • • •" : displayAmount ?? usdtInputAmount(amount)),
                 accentColor: .textSecondary, accentFont: Fonts.extraBold
             )
             .lineLimit(1).minimumScaleFactor(0.5)
@@ -168,7 +168,7 @@ extension UsdtTransferStatus {
         case .pending: t("usdt__pending")
         case .confirmed: t("usdt__confirmed")
         case .failed: t("usdt__failed")
-        case .bridging: t("usdt__bridging")
+        case .bridging: t("wallet__activity_transferring")
         case .bridgeNeedsAttention, .bridgeFailed: t("usdt__bridge_attention")
         case .replaced: t("usdt__replaced")
         case .bridgeRefunded: t("usdt__deposit_refunded")
@@ -192,3 +192,7 @@ func usdtOverviewAmount(_ amount: UInt64, locale: Locale = .current) -> String {
     if amount > 0, amount < 10000 { return "<" + (Decimal(1) / 100).formatted(format) }
     return (Decimal(amount) / 1_000_000).formatted(format)
 }
+
+func usdtInputAmount(_ amount: String, locale: Locale = .current) -> String {
+    amount.replacingOccurrences(of: ".", with: locale.decimalSeparator ?? ".")
+}
diff --git a/BitkitTests/ClipboardPromptValidatorTests.swift b/BitkitTests/ClipboardPromptValidatorTests.swift
index ba85bbcb6..416133173 100644
--- a/BitkitTests/ClipboardPromptValidatorTests.swift
+++ b/BitkitTests/ClipboardPromptValidatorTests.swift
@@ -26,6 +26,18 @@ final class ClipboardPromptValidatorTests: XCTestCase {
         }
     }
 
+    func testDisabledUsdtAddressesAreIgnoredWithoutDecoding() async {
+        for value in ["0x1111111111111111111111111111111111111111", " 0x1111111111111111111111111111111111111111\n"] {
+            let supported = await ClipboardPromptValidator.isSupportedURI(
+                value, ownPublicKey: nil, contacts: [], isUsdtEnabled: false
+            ) { _ in
+                XCTFail("Disabled USDT addresses must not trigger a clipboard prompt or a decoder")
+                return true
+            }
+            XCTAssertFalse(supported)
+        }
+    }
+
     func testLightningAddressCandidatesDoNotInvokeNetworkDecoder() async {
         for uri in [
             "alice@corp.example",
@@ -36,7 +48,7 @@ final class ClipboardPromptValidatorTests: XCTestCase {
             "bitkit://lightning:alice@corp.example",
             "bitkit://lightning:bitkit://alice@corp.example",
         ] {
-            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: []) { _ in
+            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [], isUsdtEnabled: false) { _ in
                 XCTFail("Must not decode a network-resolved clipboard candidate before confirmation: '\(uri)'")
                 return false
             }
@@ -47,7 +59,7 @@ final class ClipboardPromptValidatorTests: XCTestCase {
     func testWrappedLnurlCandidatesDoNotInvokeNetworkDecoder() async {
         let lnurl = ClipboardLnurlEncoder.encode("http://127.0.0.1/lnurlp")
         for uri in wrappedLnurls(lnurl) {
-            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: []) { _ in
+            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [], isUsdtEnabled: false) { _ in
                 XCTFail("Must not decode a network-resolved clipboard candidate before confirmation: '\(uri)'")
                 return false
             }
@@ -65,7 +77,7 @@ final class ClipboardPromptValidatorTests: XCTestCase {
         let lnurl = ClipboardLnurlEncoder.encode("http://127.0.0.1:\(port)/lnurlp")
 
         for uri in wrappedLnurls(lnurl) {
-            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [])
+            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [], isUsdtEnabled: false)
             XCTAssertTrue(supported, uri)
         }
         XCTAssertEqual(probe.connections, 0, "Automatic inspection must not contact clipboard-derived endpoints")
@@ -91,7 +103,7 @@ final class ClipboardPromptValidatorTests: XCTestCase {
     func testLocalPaymentFormatsRemainSupported() async {
         let address = "mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn"
         for uri in [address, "bitcoin:\(address)?amount=0.001", "LIGHTNING:\(address)", "bitkit://\(address)", "bitkit://gift-test-1000"] {
-            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [])
+            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [], isUsdtEnabled: false)
             XCTAssertTrue(supported, uri)
         }
     }
@@ -99,13 +111,13 @@ final class ClipboardPromptValidatorTests: XCTestCase {
     func testBolt11InvoiceRemainsLocallyValidated() async {
         let invoice =
             "lnbcrt200n1p5hn4c8dqqnp4qwrgh4a03djj2sl34465uwnxhva0gtpjm4u8kvzgc5jergrkm9syypp55lwcgfpkdwuknmekjgted72n0ddl5qtaha7knk7c9n7yrjr4auassp5jgqw0a9w33e2ta4j7gyjrvsvu0lv844w895305nd8spnknq3f2hq9qyysgqcqzp2xqyz5vqrzjq29gjy9sqjrrp48tz7hj2e5vm4l2dukc4csf2mn6qm32u3hted5leapyqqqqqqqtcsqqqqlgqqqqqqgq2qd2gk64eg2kfxtdaryrlh98hvu97jdaxz2ma7aeyuy2uy9vkn9x5qft47p9taju297xnrehva20xcfml7wacuv737xv3xjjzyrtplcxqpfpu9dt"
-        let supported = await ClipboardPromptValidator.isSupportedURI(invoice, ownPublicKey: nil, contacts: [])
+        let supported = await ClipboardPromptValidator.isSupportedURI(invoice, ownPublicKey: nil, contacts: [], isUsdtEnabled: false)
         XCTAssertTrue(supported)
     }
 
     func testOrdinaryUnsupportedContentRemainsRejected() async {
         for uri in ["", "ordinary clipboard text", "https://example.com", "alice+invalid@corp.example", "Alice@corp.example", "lnurl1invalid"] {
-            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [])
+            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [], isUsdtEnabled: false)
             XCTAssertFalse(supported, uri)
         }
     }
@@ -137,7 +149,7 @@ final class ClipboardPromptValidatorTests: XCTestCase {
             key,
             "https://btcpay.example/plugins/store123/samrock/protocol?setup=btc-chain&otp=abc123",
         ] {
-            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: []) { _ in
+            let supported = await ClipboardPromptValidator.isSupportedURI(uri, ownPublicKey: nil, contacts: [], isUsdtEnabled: false) { _ in
                 XCTFail("Existing locally parsed candidates must not invoke the decoder")
                 return false
             }
diff --git a/BitkitTests/PubkyAuthApprovalSheetTests.swift b/BitkitTests/PubkyAuthApprovalSheetTests.swift
index 936aacca0..299933da4 100644
--- a/BitkitTests/PubkyAuthApprovalSheetTests.swift
+++ b/BitkitTests/PubkyAuthApprovalSheetTests.swift
@@ -54,11 +54,11 @@ final class PubkyAuthApprovalSheetTests: XCTestCase {
             let manager = Bitkit.WatchOnlyAccountManager(defaults: defaults, node: ApprovalFakeWatchOnlyAccountNode())
             let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: claim.rawValue)
             let request = try PubkyAuthRequest.parse(url: url)
-            XCTAssertEqual(PubkyAuthApprovalSheet.initialState(for: request), .watchOnlyConsent)
+            XCTAssertEqual(PubkyAuthApprovalSheet.initialState(for: request, isUsdtEnabled: true), .watchOnlyConsent)
             var shared: [String: Any]?
             try await PubkyService.approveAuthRequest(
                 request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret", accountManager: manager,
-                approvedUsdtAddress: endpoint.value, usdtEndpoint: { endpoint },
+                approvedUsdtAddress: endpoint.value, usdtEndpoint: { endpoint }, isUsdtEnabled: { true },
                 ordinaryApproval: { _, _, _, _ in XCTFail("A receiving-details request requires a companion claim") },
                 companionApproval: { _, _, type, payload, _ in
                     XCTAssertEqual(type, claim)
@@ -88,7 +88,7 @@ final class PubkyAuthApprovalSheetTests: XCTestCase {
             do {
                 try await PubkyService.approveAuthRequest(
                     request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret",
-                    approvedUsdtAddress: approvedAddress, usdtEndpoint: { endpoint },
+                    approvedUsdtAddress: approvedAddress, usdtEndpoint: { endpoint }, isUsdtEnabled: { true },
                     companionApproval: { _, _, _, _, _ in XCTFail("Unapproved details must not be sent") }
                 )
                 XCTFail("Expected approval to require the reviewed address")
@@ -119,6 +119,112 @@ final class PubkyAuthApprovalSheetTests: XCTestCase {
         XCTAssertEqual(access["secret"] as? String, "CwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCws")
     }
 
+    func testReceivingConsentMatchesTheAvailableRequestedAssets() throws {
+        let claims: [(String, PubkyAuthApprovalSheet.ApprovalState)] = [
+            (PubkyAuthClaim.watchOnlyAccountV1.rawValue, .watchOnlyConsent),
+            (PubkyAuthClaim.bitcoinAndUsdt.rawValue, .watchOnlyConsent),
+            (PubkyAuthClaim.usdtAddressV1.rawValue, .authorize),
+            ("paykit-access-v1.usdt-address-v1", .authorize),
+        ]
+        for (claim, disabledState) in claims {
+            let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: claim)
+            let request = try PubkyAuthRequest.parse(url: url)
+            XCTAssertEqual(PubkyAuthApprovalSheet.initialState(for: request, isUsdtEnabled: false), disabledState, claim)
+            XCTAssertEqual(PubkyAuthApprovalSheet.initialState(for: request, isUsdtEnabled: true), .watchOnlyConsent, claim)
+        }
+    }
+
+    @MainActor
+    func testDisabledUsdtIsOmittedFromCombinedReceivingDetails() async throws {
+        let defaults = try XCTUnwrap(UserDefaults(suiteName: UUID().uuidString))
+        let manager = Bitkit.WatchOnlyAccountManager(defaults: defaults, node: ApprovalFakeWatchOnlyAccountNode())
+        let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: PubkyAuthClaim.bitcoinAndUsdt.rawValue)
+        let request = try PubkyAuthRequest.parse(url: url)
+        var shared: [String: Any]?
+        try await PubkyService.approveAuthRequest(
+            request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret", accountManager: manager,
+            approvedUsdtAddress: "0x1111111111111111111111111111111111111111",
+            usdtEndpoint: { XCTFail("Disabled USDT must not load its address"); throw PubkyAuthRequestError.invalidPaymentDetails },
+            isUsdtEnabled: { false },
+            companionApproval: { _, _, _, payload, _ in
+                shared = try JSONSerialization.jsonObject(with: XCTUnwrap(payload)) as? [String: Any]
+            }
+        )
+        XCTAssertEqual(try Set(XCTUnwrap(shared).keys), ["bitcoin_account"])
+        XCTAssertEqual(manager.accounts.first?.setupState, .active)
+    }
+
+    @MainActor
+    func testStandaloneUsdtRequiresEnabledAndReviewedReceivingDetails() async throws {
+        let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: PubkyAuthClaim.usdtAddressV1.rawValue)
+        let request = try PubkyAuthRequest.parse(url: url)
+        for enabled in [false, true] {
+            do {
+                try await PubkyService.approveAuthRequest(
+                    request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret",
+                    usdtEndpoint: { XCTFail("No address was approved"); throw PubkyAuthRequestError.invalidPaymentDetails },
+                    isUsdtEnabled: { enabled },
+                    companionApproval: { _, _, _, _, _ in XCTFail("A standalone USDT authorization cannot succeed without its address") }
+                )
+                XCTFail("Expected unavailable authorization, enabled: \(enabled)")
+            } catch {
+                XCTAssertEqual(error as? PubkyAuthRequestError, .invalidPaymentDetails)
+            }
+        }
+    }
+
+    @MainActor
+    func testApprovalRechecksUsdtPreferenceAfterLoadingReceivingDetails() async throws {
+        let endpoint = try PaykitUsdt.endpoint(address: "0x1111111111111111111111111111111111111111")
+        for claim in [PubkyAuthClaim.usdtAddressV1, .bitcoinAndUsdt] {
+            let defaults = try XCTUnwrap(UserDefaults(suiteName: UUID().uuidString))
+            let manager = Bitkit.WatchOnlyAccountManager(defaults: defaults, node: ApprovalFakeWatchOnlyAccountNode())
+            let url = approvalTestAuthUrl().replacingOccurrences(of: "watch-only-account-v1", with: claim.rawValue)
+            let request = try PubkyAuthRequest.parse(url: url)
+            var enabled = true
+            var shared: [String: Any]?
+            do {
+                try await PubkyService.approveAuthRequest(
+                    request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret", accountManager: manager,
+                    approvedUsdtAddress: endpoint.value, usdtEndpoint: { enabled = false; return endpoint },
+                    isUsdtEnabled: { enabled },
+                    companionApproval: { _, _, _, payload, _ in
+                        shared = try JSONSerialization.jsonObject(with: XCTUnwrap(payload)) as? [String: Any]
+                    }
+                )
+                XCTAssertFalse(claim.requiresUsdtAddress)
+                XCTAssertEqual(try Set(XCTUnwrap(shared).keys), ["bitcoin_account"])
+                XCTAssertEqual(manager.accounts.first?.setupState, .active)
+            } catch {
+                XCTAssertTrue(claim.requiresUsdtAddress)
+                XCTAssertEqual(error as? PubkyAuthRequestError, .invalidPaymentDetails)
+                XCTAssertNil(shared)
+                XCTAssertTrue(manager.accounts.isEmpty)
+            }
+        }
+    }
+
+    @MainActor
+    func testBitcoinOnlyApprovalIsIndependentOfUsdtPreference() async throws {
+        for enabled in [false, true] {
+            let defaults = try XCTUnwrap(UserDefaults(suiteName: UUID().uuidString))
+            let manager = Bitkit.WatchOnlyAccountManager(defaults: defaults, node: ApprovalFakeWatchOnlyAccountNode())
+            let url = approvalTestAuthUrl()
+            let request = try PubkyAuthRequest.parse(url: url)
+            var shared: Data?
+            try await PubkyService.approveAuthRequest(
+                request: request, authUrl: url, accountName: "Earn", secretKeyHex: "secret", accountManager: manager,
+                usdtEndpoint: { XCTFail("Bitcoin authorization must not read USDT"); throw PubkyAuthRequestError.invalidPaymentDetails },
+                isUsdtEnabled: { enabled },
+                companionApproval: { _, _, _, payload, _ in
+                    shared = payload
+                }
+            )
+            XCTAssertEqual(shared, try Bitkit.WatchOnlyAccountClaimCodec.encode(record: XCTUnwrap(manager.accounts.first)))
+            XCTAssertEqual(manager.accounts.first?.setupState, .active)
+        }
+    }
+
     func testAuthDisplayPublicKeyOmitsPubkyPrefix() {
         XCTAssertEqual(pubkyAuthDisplayPublicKey("pubky3rsd123456789w5xg"), "3rsd...w5xg")
         XCTAssertEqual(pubkyAuthDisplayPublicKey("3rsd123456789w5xg"), "3rsd...w5xg")
diff --git a/BitkitTests/UsdtDisplayTests.swift b/BitkitTests/UsdtDisplayTests.swift
index 712f176e6..a3894f01e 100644
--- a/BitkitTests/UsdtDisplayTests.swift
+++ b/BitkitTests/UsdtDisplayTests.swift
@@ -14,6 +14,14 @@ final class UsdtDisplayTests: XCTestCase {
         XCTAssertNil(usdtDisplaySats(amount: "999999999999999999999999", rate: rate, now: now))
     }
 
+    func testAmountInputUsesLocaleSeparatorWithoutRoundingTypedPrecision() {
+        for amount in ["0", "0.", "0.000001", "1.230000", "1234567.890000"] {
+            XCTAssertEqual(usdtInputAmount(amount, locale: Locale(identifier: "en_US")), amount)
+            XCTAssertEqual(usdtInputAmount(amount, locale: Locale(identifier: "de_DE")), amount.replacingOccurrences(of: ".", with: ","))
+            XCTAssertEqual(usdtInputAmount(amount, locale: Locale(identifier: "fr_FR")), amount.replacingOccurrences(of: ".", with: ","))
+        }
+    }
+
     func testOverviewAmountsRoundToCentsWithoutHidingSmallBalances() {
         let locale = Locale(identifier: "en_US")
         for (amount, expected): (UInt64, String) in [
diff --git a/BitkitTests/UsdtPaymentLinkTests.swift b/BitkitTests/UsdtPaymentLinkTests.swift
index 3319da316..2af019373 100644
--- a/BitkitTests/UsdtPaymentLinkTests.swift
+++ b/BitkitTests/UsdtPaymentLinkTests.swift
@@ -16,6 +16,18 @@ final class UsdtPaymentLinkTests: XCTestCase {
                        .usdtPayment(recipient: recipient, amount: ""))
     }
 
+    @MainActor
+    func testExplicitUsdtLinkKeepsItsPaymentWhenOptInIsDisabled() async throws {
+        snapshotAppDefaults(UsdtPreference.key)
+        UserDefaults.standard.set(UsdtPreference.disabled.rawValue, forKey: UsdtPreference.key)
+        let input = uri + "&uint256=10001"
+        XCTAssertFalse(UsdtPreference.isEnabled())
+        XCTAssertEqual(try resolveUsdtPaymentRoute(input: input, isEnabled: true),
+                       .usdtPayment(recipient: recipient, amount: "0.010001"))
+        let clipboardSupported = await ClipboardPromptValidator.isSupportedURI(input, ownPublicKey: nil, contacts: [])
+        XCTAssertFalse(clipboardSupported)
+    }
+
     func testUnsupportedPaymentLinksCannotOpenTheWallet() {
         for input in [
             uri.replacingOccurrences(of: "@42161", with: "@1"),
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index b24eb2d98..712ebf1bc 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -4,6 +4,59 @@ import XCTest
 
 @MainActor
 final class UsdtWalletManagerTests: XCTestCase {
+    func testChangingUsdtPreferencePublishesForOpenPaymentAndAuthorizationViews() {
+        let settings = SettingsViewModel.shared
+        let original = settings.usdtPreference
+        defer { settings.usdtPreference = original }
+        settings.usdtPreference = .disabled
+        var changes = 0
+        let observation = settings.objectWillChange.sink { changes += 1 }
+        defer { observation.cancel() }
+        settings.usdtPreference = .enabled
+        XCTAssertGreaterThan(changes, 0)
+        XCTAssertTrue(settings.isUsdtEnabled)
+    }
+
+    func testRestoredFundsAndPendingTransfersKeepUsdtEnabledAcrossFeatures() {
+        let settings = SettingsViewModel.shared
+        let original = settings.usdtPreference
+        defer { settings.usdtPreference = original }
+        for preference: UsdtPreference in [.undecided, .disabled] {
+            settings.usdtPreference = preference
+            settings.protectUsdtFunds(UsdtPreference.protectsFunds(balance: 0, transfers: []))
+            XCTAssertEqual(settings.usdtPreference, preference)
+            for (balance, transfers): (UInt64, [UsdtTransfer]) in [
+                (1, []), (0, [transfer("pending", status: .pending)]), (0, [transfer("bridge", status: .bridging)]),
+            ] {
+                settings.usdtPreference = preference
+                settings.protectUsdtFunds(UsdtPreference.protectsFunds(balance: balance, transfers: transfers))
+                XCTAssertTrue(settings.isUsdtEnabled)
+                XCTAssertTrue(UsdtPreference.isEnabled())
+                settings.protectUsdtFunds(false)
+                XCTAssertTrue(settings.isUsdtEnabled, "Draining funds must not silently turn off an enabled wallet")
+            }
+        }
+    }
+
+    func testKnownInboundPaymentsProtectTheWalletUntilEachSettles() {
+        let manager = UsdtWalletManager(loadCredentials: { throw CancellationError() })
+        let settings = SettingsViewModel.shared
+        let original = settings.usdtPreference
+        defer { settings.usdtPreference = original }
+        settings.usdtPreference = .disabled
+        manager.recordDepositStatus(id: "waiting", status: "awaiting_deposit")
+        XCTAssertFalse(manager.hasProtectedFunds)
+        manager.recordDepositStatus(id: "first", status: "funded")
+        settings.protectUsdtFunds(manager.hasProtectedFunds)
+        XCTAssertTrue(settings.isUsdtEnabled)
+        manager.recordDepositStatus(id: "second", status: "refunding")
+        manager.recordDepositStatus(id: "first", status: "completed")
+        XCTAssertTrue(manager.hasProtectedFunds)
+        manager.recordDepositStatus(id: "second", status: "refunded")
+        XCTAssertFalse(manager.hasProtectedFunds)
+        XCTAssertTrue(settings.isUsdtEnabled)
+    }
+
     func testUsdtOptInDoesNotImplicitlyPublishOrHideExistingFunds() throws {
         let defaults = try XCTUnwrap(UserDefaults(suiteName: UUID().uuidString))
         XCTAssertFalse(UsdtPreference.isEnabled(defaults: defaults))
@@ -198,10 +251,16 @@ final class UsdtWalletManagerTests: XCTestCase {
         _ = try await manager.storedTransfer("missing")
         let snapshot = try await manager.backupSnapshot()
         let backup = try XCTUnwrap(snapshot)
+        manager.recordDepositStatus(id: "old-deposit", status: "funded")
+        XCTAssertTrue(manager.hasProtectedFunds)
         try await manager.restoreBackup(backup)
+        XCTAssertFalse(manager.hasProtectedFunds)
         XCTAssertEqual(credentialReads, 1)
 
+        manager.recordDepositStatus(id: "old-deposit", status: "funded")
         try await manager.wipe()
+        manager.recordDepositStatus(id: "late-response", status: "funded")
+        XCTAssertFalse(manager.hasProtectedFunds)
         do {
             _ = try await manager.paymentEndpoint()
             XCTFail("A wiped session must not read credentials or reopen its wallet")
diff --git a/Docs/USDT.md b/Docs/USDT.md
index 38776fc71..40f059a42 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -27,7 +27,9 @@ History catch-up is deferred while the USDT send sheet is open. Balance and pend
 
 USDT starts off. The introductory sheet offers Enable USDT and No Thanks; dismissing it without a choice allows it to return next launch. Settings > General > Payments > USDT (Tether) changes the choice later.
 
-When off, new USDT payment choices, Paykit offers and optional address sharing are hidden. Opening an explicit USDT link or request asks to enable it before continuing. Disabling requires a fresh empty balance and no unresolved transfers or deposits. Existing funds, pending payments and restored history with an unknown balance remain visible; payment tracking, history and encrypted backups continue. Previously shared addresses cannot be revoked.
+When off, USDT is hidden from new payment choices, Paykit offers and authorization details. Combined Bitcoin and USDT authorization continues with Bitcoin and omits the USDT address; a USDT-only authorization is unavailable. Authorization never asks to enable USDT. Automatic clipboard detection ignores USDT addresses and links while retaining Bitcoin and Lightning detection.
+
+Explicitly opening a USDT link or request, or scanning its QR, offers the USDT enable sheet. Enabling resumes the original flow; declining cancels it quietly. Funds or unresolved transfers keep USDT enabled, with the Settings switch on and greyed out. Disabling requires a fresh empty balance and no unresolved transfers or deposits. Tracking, history and encrypted backups continue, including after restore. Previously shared addresses cannot be revoked.
 
 ## Paykit
 
diff --git a/journeys/pubky-auth/share-receiving-details.xml b/journeys/pubky-auth/share-receiving-details.xml
index bba5a4605..2467ff4ae 100644
--- a/journeys/pubky-auth/share-receiving-details.xml
+++ b/journeys/pubky-auth/share-receiving-details.xml
@@ -1,5 +1,5 @@
 <journey name="review Earn receiving details">
-  <description>Use an onboarded wallet with a Pubky identity and configured USDT. Use a local test auth request; cancel before Authorize so no receiving details or session are exported.</description>
+  <description>Use an onboarded empty wallet with a Pubky identity and configured USDT. Enable USDT in Settings for the first checks. Use a local test auth request; cancel before Authorize so no receiving details or session are exported.</description>
   <actions>
     <action>Open the existing watch-only setup fixture with x-bitkit-claim=usdt-address-v1</action>
     <action>Verify the Earn USDT introduction, then tap Approve</action>
@@ -8,11 +8,16 @@
     <action>Cancel and verify no Bitcoin account was created</action>
     <action>Repeat with x-bitkit-claim=watch-only-account-v1.usdt-address-v1; verify Bitcoin and USDT appear together, then cancel</action>
     <action>Repeat with x-bitkit-claim=watch-only-account-v1; verify only Bitcoin is requested, then cancel</action>
-    <action>With USDT unavailable, verify sharing is off and authorization remains enabled; turn USDT sharing on and verify authorization is disabled until Retry loads the address</action>
+    <action>With USDT enabled but its address temporarily unavailable, open a combined Bitcoin and USDT request. Verify sharing is off and Bitcoin authorization remains available; turn USDT sharing on and verify authorization is disabled until Retry loads the address</action>
     <action>Open the setup fixture with x-bitkit-claim=paykit-access-v1.watch-only-account-v1.usdt-address-v1</action>
     <action>Continue to authorization; verify the named requester, exact requested permission paths and access, Bitcoin account, Paykit Details explanation, and optional USDT sharing toggle are shown</action>
     <action>Verify Before You Continue explains trusting the service, browser, and device. Verify the compact horizontal profile card (id "PubkyAuthProfile") shows the correct identity and name, with Cancel and Authorize reachable without overlap.</action>
     <action>Turn off PubkyAuthShareUsdt; verify authorization remains enabled, then cancel</action>
     <action>Open the auth fixture with only x-bitkit-claim=paykit-access-v1; verify Paykit permissions and Details are shown without an empty Payment Details to Share section, then cancel.</action>
+    <action>Turn USDT off in Settings, then open x-bitkit-claim=watch-only-account-v1.usdt-address-v1. Verify the introduction and authorization show Bitcoin only: no USDT sharing switch, address, privacy text or enable prompt. Cancel before Authorize.</action>
+    <action>With USDT still off, repeat with x-bitkit-claim=paykit-access-v1.watch-only-account-v1.usdt-address-v1. Verify Bitcoin and Paykit permissions remain available without any USDT content or enable prompt, then cancel.</action>
+    <action>With USDT still off, open x-bitkit-claim=paykit-access-v1.usdt-address-v1. Verify Paykit permissions appear without a receiving-details introduction or USDT content. Go back and verify the request closes without showing a Bitcoin introduction.</action>
+    <action>With USDT still off, open x-bitkit-claim=usdt-address-v1. Verify the request is unavailable and authorization cannot be submitted; no enable prompt or successful setup is shown. Cancel and verify Settings still shows USDT off.</action>
+    <action>Enable USDT in Settings and reopen the combined request. Verify the optional USDT switch, address and privacy disclosure return. Turn sharing off and verify Bitcoin authorization remains available, then cancel.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-opt-in.xml b/journeys/usdt-opt-in.xml
index a312a5901..001d46def 100644
--- a/journeys/usdt-opt-in.xml
+++ b/journeys/usdt-opt-in.xml
@@ -5,10 +5,10 @@
     <action>Swipe the intro sheet down. Verify Home shows Savings and Spending without a USDT tile. Open Receive and verify there is no USDT tab, then close it.</action>
     <action>Terminate and relaunch the app. Verify the USDT intro returns. Tap No Thanks (id "UsdtIntroDecline"), relaunch again, and verify the intro does not return.</action>
     <action>Open Settings, General, Payments. Verify USDT (Tether) (id "UsdtSettingsToggle") is off. Enable it, return Home, and verify the USDT tile appears. Open Receive and verify the USDT tab appears.</action>
-    <action>Open USDT Send and its network pill. Verify the USDT Network picker (id "UsdtNetworkPicker") uses rounded rows with Tether icons, a teal selection check, the recipient-network explanation and Tether coin illustration. Choose another supported network and verify the pill updates.</action>
+    <action>Open USDT Send and its network pill. Verify the USDT Network picker (id "UsdtNetworkPicker") uses rounded rows with Tether icons, a teal selection check, the recipient-network explanation and Tether coin illustration. Choose another supported network and verify the pill updates while retaining its network icon.</action>
     <action>Return to Settings and turn USDT off while the wallet is empty and all transfers are complete. Verify the USDT tile, receive tab and new Paykit receiving option disappear. Existing payment history remains stored.</action>
-    <action>Open an owned USDT payment link while USDT is off. Verify the Enable USDT prompt (id "UsdtEnablePrompt"). Cancel and verify USDT stays off. Open the link again, enable USDT (id "UsdtEnablePromptContinue"), and verify the recipient and exact amount continue into the payment flow. Cancel without paying.</action>
-    <action>With a funded wallet or an unresolved transfer, try turning USDT off in Settings. Verify the change is blocked with an explanation and the wallet and pending payment remain accessible. Restore the original setting after this check.</action>
-    <action>Restore an owned funded wallet whose USDT preference is absent or off. Verify its USDT wallet remains visible without enabling new Paykit receiving options. Open Receive, enable USDT when asked, and verify it opens the USDT tab. No payment is submitted.</action>
+    <action>Open an owned USDT payment link while USDT is off. Verify the Enable USDT prompt (id "UsdtEnablePrompt"). Decline and verify USDT stays off, the flow closes quietly, and no payment spinner or failure screen remains. Open the link again, enable USDT (id "UsdtEnablePromptContinue"), and verify the recipient and exact amount continue into the payment flow. Cancel without paying.</action>
+    <action>With a funded wallet or an unresolved transfer, open Settings. Verify USDT is visibly on, greyed out and cannot be toggled. Verify the wallet, history and pending payment remain accessible.</action>
+    <action>Restore an owned funded wallet whose USDT preference is absent or off. Verify USDT is enabled, its Settings switch is on and greyed out, and Receive opens the USDT tab without an enable prompt. No payment is submitted.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index bb3030853..b477ca434 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -3,8 +3,9 @@
   <actions>
     <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount screen preserves the recipient and exact input 0.010001 USDT; the review rounds its displayed value to $0.01. Verify no payment occurs without approval.</action>
-    <action>On iOS, copy the USDT receive URI, return to Home and accept the clipboard prompt. Verify the USDT amount screen opens with the copied recipient and amount. Cancel without paying. Repeat with a wrong-chain URI and verify no payment prompt appears.</action>
+    <action>Copy the USDT receive URI, return to Home and accept the clipboard prompt. Verify the USDT amount screen opens with the copied recipient and amount. Cancel without paying. Repeat with a wrong-chain URI and verify no payment prompt appears.</action>
     <action>Cancel the send, then reopen the identical URI. Verify the amount or review screen opens again. Cancel and open a different owned recipient and amount, verifying only the new values appear.</action>
+    <action>Close the send sheet, open Settings from the drawer, then go back. Verify the dismissed link does not reopen its Amount screen. Explicitly reopen the same link and verify a new send flow is available, then cancel without paying.</action>
     <action>While a USDT contact amount screen or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
     <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>
     <action>Cancel the send. Open the same link without uint256. Verify the amount screen opens with no amount and accepts a new amount.</action>
@@ -14,5 +15,7 @@
     <action>On iOS, open a USDT link while Lightning is stopped but the wallet is ready. Verify it routes without starting Lightning. Open two different USDT links while the main scanner sheet is dismissing; verify an older delayed link cannot replace the review that opened first.</action>
     <action>Enter this wallet’s own Arbitrum address in USDT Send, enter an amount and continue. Verify the error explicitly says you cannot send USDT to your own address, and no payment is submitted. Repeat with MAX. On Android, enter this wallet’s own bare Arbitrum address through Home Send → Enter Manually and verify the self-send message appears while Continue stays disabled.</action>
     <action>Enter the entire available USDT balance and continue. Verify the fee-collection error explains that the transaction fee could not be paid in USDT and suggests a smaller amount. Reduce the amount, reach review and close without signing.</action>
+    <action>With an empty wallet and no pending transfers, turn USDT off in Settings. Copy an owned bare USDT address, return to the app, and verify no automatic payment or enable prompt. Repeat with an amount-bearing USDT payment URI. Copy a valid Bitcoin address and a Lightning invoice in turn; verify their normal clipboard prompts still appear and cancel without paying.</action>
+    <action>With USDT off, explicitly open the same USDT URI and verify the designed Enable USDT modal appears. Decline and verify a quiet return with no stuck spinner. Scan its QR, enable USDT, and verify the original recipient and exact amount resume. Cancel without paying.</action>
   </actions>
 </journey>

From 9d8cb118bb278765f12f7751e606718fa2983f9b Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 11:46:17 -0500
Subject: [PATCH 40/62] fix: align usdt review dividers

---
 Bitkit/Views/Wallets/UsdtActivityDetail.swift | 5 ++++-
 Bitkit/Views/Wallets/UsdtSendView.swift       | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index 597873ff5..725c8e130 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -238,13 +238,16 @@ struct UsdtDetailCell: View {
     let value: String
     let icon: String
     var valueColor: Color = .textPrimary
+    var minimumValueHeight: CGFloat = 20
 
     var body: some View {
         SendSectionView(title) {
             HStack(spacing: 4) {
                 Image(icon).resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(.usdtAccent)
                 BodySSBText(value, textColor: valueColor)
-            }.frame(minHeight: 20, alignment: .leading)
+            }
+            .frame(minHeight: 20, alignment: .leading)
+            .frame(minHeight: minimumValueHeight, alignment: .topLeading)
         }
     }
 }
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 5566684f4..4058035a2 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -446,7 +446,7 @@ struct UsdtSendView: View {
                 SendSectionView(t("usdt__pay_from")) {
                     NumberPadActionButton(text: "USDT", color: .usdtAccent, variant: .secondary, disabled: true) {}
                 }
-                UsdtDetailCell(title: t("usdt__network"), value: quote.destination.label, icon: "usdt-network")
+                UsdtDetailCell(title: t("usdt__network"), value: quote.destination.label, icon: "usdt-network", minimumValueHeight: 28)
             }
             HStack(alignment: .top, spacing: 16) {
                 UsdtDetailCell(title: t(quote.destination == .arbitrum ? "wallet__activity_payment" : "usdt__you_send"),

From 2818c75749033d244b927cabadeeb094fbfc01a3 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 11:57:14 -0500
Subject: [PATCH 41/62] fix: align usdt receive keypad spacing

---
 Bitkit/Views/Wallets/UsdtReceiveAmountView.swift | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
index 7cb860734..9ec4796d6 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
@@ -25,13 +25,13 @@ struct UsdtReceiveAmountView: View {
             .frame(minHeight: 146, alignment: .top)
             .fixedSize(horizontal: false, vertical: true)
             Divider()
+            Spacer(minLength: 34)
             NumberPad(type: .decimal, decimalSeparator: Locale.current.decimalSeparator ?? ".", isDisabled: busy,
                       onDeleteLongPress: { amount = "" })
             { key in
                 amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
             }
-            .padding(.top, 34)
-            Spacer(minLength: 24)
+            .padding(.bottom, 36)
             CustomButton(title: t("common__continue"), isDisabled: !canContinue, isLoading: busy, action: onContinue)
                 .accessibilityIdentifier("UsdtDepositCreate")
         }

From 6576f237909b31e9b3d16bf02c4ae2c67c650524 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 12:33:30 -0500
Subject: [PATCH 42/62] fix: preserve usdt subscription payment context

---
 Bitkit/Styles/SheetStyles.swift               | 21 +++---
 Bitkit/Views/Wallets/Send/SendSheet.swift     |  5 +-
 .../PaykitPaymentRequestServiceTests.swift    | 75 +++++++++++++++++++
 .../subscriptions/review-and-subscribe.xml    |  5 ++
 4 files changed, 92 insertions(+), 14 deletions(-)

diff --git a/Bitkit/Styles/SheetStyles.swift b/Bitkit/Styles/SheetStyles.swift
index 30b6dd201..543a10697 100644
--- a/Bitkit/Styles/SheetStyles.swift
+++ b/Bitkit/Styles/SheetStyles.swift
@@ -28,18 +28,15 @@ struct SheetBackgroundModifier: ViewModifier {
     let applyGradient: Bool
 
     func body(content: Content) -> some View {
-        if applyGradient {
-            content
-                .background(
-                    LinearGradient(
-                        gradient: Gradient(colors: [Color.white.opacity(0.08), Color.white.opacity(0.012)]),
-                        startPoint: .top,
-                        endPoint: .bottom
-                    )
+        content
+            .background(
+                LinearGradient(
+                    gradient: Gradient(colors: [Color.white.opacity(0.08), Color.white.opacity(0.012)]),
+                    startPoint: .top,
+                    endPoint: .bottom
                 )
-                .background(base)
-        } else {
-            content.background(base)
-        }
+                .opacity(applyGradient ? 1 : 0)
+            )
+            .background(base)
     }
 }
diff --git a/Bitkit/Views/Wallets/Send/SendSheet.swift b/Bitkit/Views/Wallets/Send/SendSheet.swift
index 424a07737..f2217fc53 100644
--- a/Bitkit/Views/Wallets/Send/SendSheet.swift
+++ b/Bitkit/Views/Wallets/Send/SendSheet.swift
@@ -381,10 +381,11 @@ struct SendSheet: View {
             if PaykitSubscriptionNotificationTargetStore.load()?.matches(request) == true {
                 PaykitSubscriptionNotificationTargetStore.clear()
             }
-            wallet.sendAmountSats = try? request.payment(
+            let payment = try? request.payment(
                 using: app.paykitPaymentMethod,
                 quoteId: app.paykitPaymentTerms?.quoteId
-            ).amount.atomic
+            )
+            wallet.sendAmountSats = payment?.amount.asset == .btc ? payment?.amount.atomic : nil
             incomingPaymentRequest = request
         } else {
             tagManager.clearSelectedTags()
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index b1bfdc3c3..eb697efa0 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -2676,6 +2676,81 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         )
     }
 
+    func testInitialUsdtSubscriptionPaymentPreservesContextInsideSubscriptionSheet() async throws {
+        snapshotAppDefaultsDomain()
+        snapshotAppGroupDefaults("home_screen_display_currency_code_v1", "home_screen_display_currency_symbol_v1")
+        let settings = SettingsViewModel.shared
+        let originalPreference = settings.usdtPreference
+        settings.usdtPreference = .enabled
+        defer { settings.usdtPreference = originalPreference }
+        let now = Date()
+        let start = timestamp(now.addingTimeInterval(-60))
+        let recurrence = PaymentRequestRecurrence(every: 1, unit: "month", startsAt: start, anchor: start, endsAt: nil)
+        let endpoint = PublicPaykitService.Endpoint(
+            methodId: .usdtArbitrum, value: "0x1111111111111111111111111111111111111111",
+            min: nil, max: nil, rawPayload: ""
+        )
+        let record = try paymentRequestRecord(
+            amount: "2", asset: "usd", conversion: .fixed(rates: [.init(asset: "usdt", value: "1")]),
+            recurrence: recurrence, endpoints: [endpoint.methodId.rawValue]
+        )
+        let sdk = PaymentRequestSdkMock(records: [record])
+        let manager = paymentRequestManager(sdk: sdk, clock: PaymentRequestTestClock(now))
+        await manager.refresh()
+        let dueRequest = try await manager.accept(XCTUnwrap(manager.subscriptions.first))
+        let request = try XCTUnwrap(dueRequest)
+        let sheets = SheetViewModel()
+        sheets.activeSheetConfiguration = SheetConfiguration(id: .subscription, data: nil)
+        let app = AppViewModel(sheetViewModel: sheets, navigationViewModel: NavigationViewModel())
+        let context = ContactPaymentContext(
+            publicKey: request.counterparty, incomingPaymentRequest: request,
+            isInitialSubscriptionPayment: true, endpoints: [endpoint]
+        )
+        XCTAssertTrue(app.claimContactPaymentContext(context))
+        app.paykitUsesUsdt = true
+        let wallet = PaymentRequestSendWallet()
+        wallet.nodeLifecycleState = .running
+        let view = SubscriptionSheet(config: SubscriptionSheetItem(route: .payment(.amount)))
+            .environment(manager)
+            .environment(UsdtWalletManager(loadCredentials: { throw CancellationError() }))
+            .environment(HwWalletManager())
+            .environment(TrezorManager())
+            .environmentObject(app)
+            .environmentObject(wallet as WalletViewModel)
+            .environmentObject(sheets)
+            .environmentObject(NetworkMonitor())
+            .environmentObject(settings)
+            .environmentObject(TagManager())
+            .environmentObject(PubkyProfileManager())
+            .environmentObject(ActivityListViewModel())
+            .environmentObject(ContactsManager())
+            .environmentObject(CurrencyViewModel(currencyService: OfflineCurrencyService()))
+            .environmentObject(FeeEstimatesManager())
+        let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 390, height: 844))
+        window.rootViewController = UIHostingController(rootView: view)
+        window.makeKeyAndVisible()
+        window.rootViewController?.view.layoutIfNeeded()
+        defer {
+            window.isHidden = true
+            window.rootViewController = nil
+            ToastWindowManager.shared.hideToast()
+        }
+        try await waitUntil { wallet.selectedFeeRateSatsPerVByte != nil }
+        try await Task.sleep(for: .milliseconds(200))
+
+        XCTAssertEqual(app.contactPaymentContext, context)
+        XCTAssertTrue(app.paykitUsesUsdt)
+        XCTAssertNil(wallet.sendAmountSats)
+        XCTAssertEqual(try request.payment(using: app.paykitPaymentMethod).amount, PaykitAmount(asset: .usdt, atomic: 2_000_000))
+        XCTAssertEqual(manager.subscriptions.first?.lifecycleState, .activeRecurring)
+        XCTAssertTrue(manager.pendingRequests.contains(where: { $0.id == request.id }))
+
+        window.rootViewController = UIHostingController(rootView: Color.clear)
+        try await waitUntil { app.contactPaymentContext == nil }
+        XCTAssertFalse(app.paykitUsesUsdt)
+        XCTAssertNil(wallet.sendAmountSats)
+    }
+
     func testSubscriptionPaymentCanBeReopenedForManualRetry() async throws {
         let now = try XCTUnwrap(ISO8601DateFormatter().date(from: "2027-01-15T08:00:00Z"))
         let recurrence = PaymentRequestRecurrence(
diff --git a/journeys/subscriptions/review-and-subscribe.xml b/journeys/subscriptions/review-and-subscribe.xml
index da098dba6..41a722352 100644
--- a/journeys/subscriptions/review-and-subscribe.xml
+++ b/journeys/subscriptions/review-and-subscribe.xml
@@ -30,5 +30,10 @@
     <action>Verify the sheet dismisses and "Journey Sub" moves from PROPOSALS into the ACTIVE section</action>
     <action>Tap the "Journey Sub" row and verify the detail shows STATUS "Active" and a RENEWS date one month ahead, with no year</action>
     <action>Only when a payment was made: verify the PAYMENTS section lists it titled "Journey Sub" with the payment date as its subtitle. With no payment yet, the section is absent.</action>
+    <action>Have the creator send a second proposal for 2 USD monthly, accepting only USDT, with its first period due on acceptance; open its Review and Subscribe sheet on the payer with USDT enabled and enough USDT for 2 USDT plus the payment fee</action>
+    <action>Verify the requested amount is $2, USDT is the only payment method and the swipe knob is USDT teal; swipe to subscribe</action>
+    <action>Verify the Amount screen keeps $2 locked and USDT as its only payment source; no Bitcoin amount, Savings source or editable amount is offered</action>
+    <action>Tap Continue and verify the USDT review shows 2 USDT, the creator's address and the fee; do not swipe to pay</action>
+    <action>Close the send sheet, reopen this subscription's unpaid first period from Payments, and verify it still offers the locked 2 USDT payment; cancel without sending</action>
   </actions>
 </journey>

From e83bca074430aa161e34abde46195016d3a5912e Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 13:36:31 -0500
Subject: [PATCH 43/62] feat: align payment requests and Earn with USDT designs

---
 .../paper-plane-tilt.imageset/Contents.json   |  16 ++
 .../paper-plane-tilt.svg                      |   5 +
 .../Localization/en.lproj/Localizable.strings |  19 +-
 .../CreatePaymentRequestView.swift            |  56 +++---
 .../PubkyAuthApprovalSheet.swift              | 187 +++++++++---------
 .../CreateSubscriptionView.swift              |  74 ++++---
 journeys/paykit-quoted-usdt.xml               |   6 +-
 .../pubky-auth/share-receiving-details.xml    |  15 +-
 8 files changed, 216 insertions(+), 162 deletions(-)
 create mode 100644 Bitkit/Assets.xcassets/icons/paper-plane-tilt.imageset/Contents.json
 create mode 100644 Bitkit/Assets.xcassets/icons/paper-plane-tilt.imageset/paper-plane-tilt.svg

diff --git a/Bitkit/Assets.xcassets/icons/paper-plane-tilt.imageset/Contents.json b/Bitkit/Assets.xcassets/icons/paper-plane-tilt.imageset/Contents.json
new file mode 100644
index 000000000..6d56d81de
--- /dev/null
+++ b/Bitkit/Assets.xcassets/icons/paper-plane-tilt.imageset/Contents.json
@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "paper-plane-tilt.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}
diff --git a/Bitkit/Assets.xcassets/icons/paper-plane-tilt.imageset/paper-plane-tilt.svg b/Bitkit/Assets.xcassets/icons/paper-plane-tilt.imageset/paper-plane-tilt.svg
new file mode 100644
index 000000000..52cdda25c
--- /dev/null
+++ b/Bitkit/Assets.xcassets/icons/paper-plane-tilt.imageset/paper-plane-tilt.svg
@@ -0,0 +1,5 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path opacity="0.2" d="M13.1406 2.24338L1.49513 5.52801C1.39716 5.55564 1.30996 5.61252 1.24518 5.69104C1.1804 5.76956 1.14112 5.86598 1.13261 5.96742C1.1241 6.06885 1.14675 6.17047 1.19753 6.25869C1.24832 6.34691 1.32482 6.41753 1.41682 6.4611L6.76749 8.99563C6.87185 9.04507 6.95589 9.1291 7.00532 9.23346L9.53985 14.5841C9.58343 14.6761 9.65404 14.7526 9.74226 14.8034C9.83048 14.8542 9.9321 14.8769 10.0335 14.8683C10.135 14.8598 10.2314 14.8206 10.3099 14.7558C10.3884 14.691 10.4453 14.6038 10.4729 14.5058L13.7576 2.86034C13.7817 2.7748 13.7826 2.68437 13.7601 2.59837C13.7377 2.51237 13.6927 2.4339 13.6299 2.37106C13.567 2.30821 13.4886 2.26325 13.4026 2.24081C13.3166 2.21837 13.2262 2.21926 13.1406 2.24338Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M13.0049 1.76216C13.176 1.7139 13.3568 1.71213 13.5288 1.75701C13.7008 1.80189 13.8578 1.89181 13.9834 2.0175C14.1091 2.1432 14.1991 2.30012 14.2439 2.47213C14.2888 2.64413 14.287 2.82499 14.2388 2.99607L10.9542 14.6416C10.8989 14.8375 10.7851 15.0119 10.6281 15.1415C10.4711 15.271 10.2782 15.3496 10.0754 15.3666C9.87248 15.3836 9.66924 15.3383 9.4928 15.2367C9.31637 15.1352 9.17513 14.9822 9.08798 14.7982L6.55345 9.4475L1.20277 6.91297C1.01879 6.82582 0.86578 6.68459 0.764209 6.50815C0.662637 6.33171 0.617337 6.12847 0.634364 5.9256C0.65139 5.72273 0.729932 5.52988 0.859492 5.37284C0.989052 5.21581 1.16346 5.10205 1.3594 5.04678L13.0049 1.76216ZM13.2763 2.72461L1.63086 6.00923L6.98154 8.54377L6.76749 8.99563L6.98154 8.54377C7.19026 8.64263 7.35832 8.8107 7.45719 9.01941L7.00532 9.23346L7.45719 9.01942L9.99172 14.3701L13.2763 2.72461Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M10.1117 5.88863C10.3069 6.0839 10.3069 6.40048 10.1117 6.59574L7.28324 9.42417C7.08798 9.61943 6.7714 9.61943 6.57613 9.42417C6.38087 9.22891 6.38087 8.91232 6.57613 8.71706L9.40456 5.88863C9.59982 5.69337 9.91641 5.69337 10.1117 5.88863Z" fill="white"/>
+</svg>
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 100eef940..d9686e13a 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -732,7 +732,7 @@
 "pubky_auth__paykit_access_description" = "This service will manage your private Paykit data and send Paykit messages for you. Your pubky secret and wallet keys stay private.";
 "pubky_auth__watch_only_intro_relay" = "Your authorization will be delivered to <accent>{relay}</accent>.";
 "pubky_auth__watch_only_intro_nav_title" = "Earn";
-"pubky_auth__watch_only_intro_title" = "<accent>EARN BITCOIN</accent>\nFROM YOUR\nCONTENT";
+"pubky_auth__watch_only_intro_title" = "<accent>EARN MONEY</accent>\nFROM YOUR\nCONTENT";
 "pubky_auth__watch_only_account_xpub_error" = "Bitkit could not create a valid account xpub.";
 "pubky_auth__trust_warning" = "Make sure you trust the service, browser, and device before authorizing with your pubky.";
 "pubky_auth__authorization_relay" = "AUTHORIZATION RELAY";
@@ -1893,7 +1893,7 @@
 "usdt__deposit_amount_out_of_range" = "Amount outside deposit limits.";
 "usdt__deposit_not_found" = "Deposit details changed. Refresh the deposit history and select it again.";
 
-"wallet__payment_request_accepted_methods" = "Accept payment with";
+"wallet__payment_request_accepted_methods" = "Accept payment in";
 "wallet__payment_request_rate_unavailable" = "Payment rates are unavailable or expired. Try again when online.";
 
 "wallet__payment_request_payment_verified" = "Payment verified";
@@ -1902,17 +1902,12 @@
 "wallet__payment_request_underpaid" = "Received · Underpaid";
 "wallet__payment_request_after_expiry" = "Received · After expiry";
 
-"pubky_auth__bitcoin_account" = "Separate watch-only account · xpub";
-"pubky_auth__payment_details" = "PAYMENT DETAILS TO SHARE";
-"pubky_auth__payment_details_intro_title" = "<accent>EARN BITCOIN\nAND USDT</accent>\nFROM YOUR CONTENT";
-"pubky_auth__payment_details_intro_description" = "Share a separate Bitcoin account to receive earnings. You can also share your existing USDT address. Sharing these details does not let the service spend your funds.";
-"pubky_auth__usdt_intro_title" = "<accent>EARN USDT</accent>\nFROM YOUR\nCONTENT";
 "pubky_auth__usdt_intro_description" = "Share your existing USDT address on Arbitrum One to receive earnings directly in Bitkit. The service cannot spend your funds.";
 "pubky_auth__usdt_privacy" = "This is your existing USDT account. The service can see its balance and transaction history, but cannot spend your funds.";
 "pubky_auth__usdt_unavailable" = "Your USDT address is unavailable. Please try again.";
-"pubky_auth__shared_usdt" = "Your USDT receiving address was shared.";
-"pubky_auth__shared_bitcoin" = "Your Bitcoin watch-only account was shared.";
-"pubky_auth__shared_both" = "Your Bitcoin watch-only account and USDT receiving address were shared.";
+"pubky_auth__shared_usdt" = "Also, you shared a USDT address with Paykit.";
+"pubky_auth__shared_bitcoin" = "Also, you shared a watch-only Bitcoin account with Paykit.";
+"pubky_auth__shared_both" = "Also, you shared a watch-only Bitcoin account and USDT address with Paykit.";
 "usdt__deposit_batch" = "Converted batch";
 "usdt__deposit_refund_address" = "Refund address on the source network";
 "usdt__deposit_refund_note" = "Confirm a refund address with the sender. Do not assume an exchange deposit can be returned to its sending address. Refund fees may apply. TRON refunds can require Orchestra operator assistance.";
@@ -1930,7 +1925,7 @@
 "usdt__bridge_reference" = "Bridge reference";
 "usdt__copy_details" = "Copy Details";
 
-"pubky_auth__share_usdt_optional" = "Share USDT address (optional)";
+"pubky_auth__share_usdt_optional" = "Also share my USDT address";
 
 "usdt__receive_network_title" = "USDT Network";
 
@@ -1974,3 +1969,5 @@
 "usdt__camera_permission" = "Allow camera access to scan USDT payment requests and pay more quickly.";
 
 "usdt__disabled" = "USDT is turned off.";
+
+"subscriptions__accepted_payments" = "Accepted payments";
diff --git a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
index 28b8e5102..bbc93050b 100644
--- a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
+++ b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
@@ -426,21 +426,23 @@ struct PaymentRequestDetailsView: View {
 
     var body: some View {
         VStack(spacing: 0) {
-            SheetHeader(title: t("wallet__payment_request"), showBackButton: true)
+            SheetHeader(title: t("wallet__payment_request"), showBackButton: true,
+                        topPadding: 28, bottomPadding: 22, dragIndicatorTopPadding: 8)
 
             ScrollView(showsIndicators: false) {
-                VStack(alignment: .leading, spacing: 24) {
+                VStack(alignment: .leading, spacing: 32) {
                     amount
                     noteInput
                     recipient
-                    acceptedMethods
                     expirationPicker
+                    acceptedMethods
                 }
+                .padding(.bottom, 24)
             }
 
             CustomButton(
                 title: t("wallet__payment_request_send_request"),
-                icon: Image("airplane").resizable().frame(width: 16, height: 16),
+                icon: Image("paper-plane-tilt").resizable().frame(width: 16, height: 16),
                 isDisabled: (restrictedEndpoints ?? enabledEndpoints).isEmpty,
                 isLoading: paymentRequests.isCreatingRequest
             ) {
@@ -450,7 +452,8 @@ struct PaymentRequestDetailsView: View {
             .accessibilityIdentifier("PaymentRequestSend")
         }
         .padding(.horizontal, 16)
-        .sheetBackground()
+        .modifier(SheetBackgroundModifier(base: .gray7, applyGradient: false))
+        .preference(key: SheetBackgroundPreferenceKey.self, value: .gray7)
         .navigationBarHidden(true)
         .interactiveDismissDisabled(paymentRequests.isCreatingRequest)
         .task {
@@ -468,15 +471,20 @@ struct PaymentRequestDetailsView: View {
     }
 
     private var amount: some View {
-        Button { onEditAmount(currentDraft) } label: {
-            HStack(spacing: 8) {
-                if initialDraft.amount.asset == .btc {
-                    MoneyText(sats: Int(clamping: initialDraft.amount.atomic), unitType: .primary, size: .display,
-                              symbol: true, color: .textPrimary, symbolColor: .textSecondary)
-                } else { NumberPadAmountText(value: initialDraft.amount.value, symbol: "$") }
-                Image("pencil").resizable().frame(width: 24, height: 24).foregroundColor(.textPrimary)
+        VStack(alignment: .leading, spacing: 16) {
+            CaptionMText(t("wallet__payment_request_amount"), textColor: .white64)
+            Button { onEditAmount(currentDraft) } label: {
+                HStack(spacing: 16) {
+                    if initialDraft.amount.asset == .btc {
+                        MoneyText(sats: Int(clamping: initialDraft.amount.atomic), unitType: .primary, size: .display,
+                                  symbol: true, color: .textPrimary, symbolColor: .textSecondary, fillsWidth: false)
+                    } else { NumberPadAmountText(value: initialDraft.amount.value, symbol: "$") }
+                    Image("pencil").resizable().frame(width: 24, height: 24).foregroundColor(.textPrimary)
+                }
             }
-        }.buttonStyle(.plain)
+            .buttonStyle(.plain)
+            .accessibilityIdentifier("PaymentRequestEditAmount")
+        }
     }
 
     private var enabledEndpoints: [String] {
@@ -485,8 +493,7 @@ struct PaymentRequestDetailsView: View {
 
     private var acceptedMethodGroups: [[PublicPaykitService.MethodId]] {
         let groups: [[PublicPaykitService.MethodId]] = [
-            PublicPaykitService.MethodId.onchainPreferenceOrder,
-            [.bitcoinLightningBolt11, .bitcoinLightningLnurl],
+            PublicPaykitService.MethodId.onchainPreferenceOrder + [.bitcoinLightningBolt11, .bitcoinLightningLnurl],
             [.usdtArbitrum],
         ]
         return groups.map { $0.filter { enabledEndpoints.contains($0.rawValue) } }.filter { !$0.isEmpty }
@@ -495,22 +502,22 @@ struct PaymentRequestDetailsView: View {
     private var acceptedMethods: some View {
         VStack(alignment: .leading, spacing: 8) {
             CaptionMText(t("wallet__payment_request_accepted_methods"), textColor: .white64)
-            HStack {
+            HStack(spacing: 8) {
                 ForEach(acceptedMethodGroups, id: \.self) { methods in
                     let endpoints = methods.map(\.rawValue)
                     let usdt = methods.contains(.usdtArbitrum)
-                    let lightning = methods.contains(.bitcoinLightningBolt11) || methods.contains(.bitcoinLightningLnurl)
                     let selected = restrictedEndpoints ?? enabledEndpoints
-                    let isSelected = endpoints.allSatisfy(selected.contains)
-                    NumberPadActionButton(text: usdt ? "USDT" : t(lightning ? "lightning__spending" : "lightning__savings").uppercased(),
-                                          color: usdt ? .usdtAccent : lightning ? .purpleAccent : .brandAccent,
-                                          variant: isSelected ? .primary : .secondary)
+                    let isSelected = endpoints.contains(where: selected.contains)
+                    NumberPadActionButton(text: usdt ? "USDT" : "BITCOIN",
+                                          color: isSelected ? (usdt ? .usdtAccent : .brandAccent) : .white32,
+                                          variant: .secondary)
                     {
                         restrictedEndpoints = isSelected
                             ? selected.filter { !endpoints.contains($0) }
                             : selected + endpoints.filter { !selected.contains($0) }
                     }
-                    .accessibilityIdentifier("PaymentRequestAccept-\(usdt ? "usdt" : lightning ? "spending" : "savings")")
+                    .accessibilityAddTraits(isSelected ? .isSelected : [])
+                    .accessibilityIdentifier("PaymentRequestAccept-\(usdt ? "usdt" : "bitcoin")")
                 }
             }
         }
@@ -523,7 +530,10 @@ struct PaymentRequestDetailsView: View {
                 text: $note,
                 placeholder: t("wallet__receive_note_placeholder"),
                 testIdentifier: "PaymentRequestNote",
-                isFocused: $isNoteFocused
+                isFocused: $isNoteFocused,
+                minHeight: 20,
+                maxHeight: 20,
+                backgroundColor: .white10
             )
         }
     }
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index 9721de065..7f0016e30 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -81,7 +81,6 @@ struct PubkyAuthApprovalSheet: View {
     @State private var isShowingAuthCheck = false
     @State private var usdtAddress: String?
     @State private var usdtUnavailable = false
-    @State private var showsUsdtAddress = false
     @State private var shareUsdt = false
 
     private var createsIdentity: Bool {
@@ -203,20 +202,80 @@ struct PubkyAuthApprovalSheet: View {
     // MARK: - Watch-Only Consent
 
     private var watchOnlyConsentContent: some View {
-        SheetIntro(
-            navTitle: t("pubky_auth__watch_only_intro_nav_title"),
-            title: t(introTitleKey),
-            description: watchOnlyConsentDescription,
-            image: "coin-stack-4",
-            continueText: t("pubky_auth__watch_only_intro_approve"),
-            cancelText: t("common__cancel"),
-            accentColor: config.request.bitkitClaim == .usdtAddressV1 ? .usdtAccent : .blueAccent,
-            testID: "PubkyAuthWatchOnlyConsent",
-            cancelTestID: "PubkyAuthWatchOnlyCancel",
-            continueTestID: "PubkyAuthWatchOnlyApprove",
-            onCancel: { sheets.hideSheet() },
-            onContinue: { _ = state.approveWatchOnlyConsent() }
-        )
+        VStack(alignment: .leading, spacing: 0) {
+            SheetHeader(title: t("pubky_auth__watch_only_intro_nav_title"),
+                        topPadding: 28, bottomPadding: 0, dragIndicatorTopPadding: 8)
+
+            GeometryReader { geometry in
+                ScrollView {
+                    VStack(alignment: .leading, spacing: 32) {
+                        Image("coin-stack-4")
+                            .resizable()
+                            .scaledToFit()
+                            .frame(width: 328, height: 328)
+                            .frame(width: 256, height: 256)
+                            .frame(maxWidth: .infinity)
+                            .accessibilityHidden(true)
+
+                        VStack(alignment: .leading, spacing: 8) {
+                            DisplayText(t("pubky_auth__watch_only_intro_title"), accentColor: .blueAccent)
+                            BodyMText(watchOnlyConsentDescription, kerning: 0, lineHeight: 22)
+                                .accessibilityIdentifier("PubkyAuthWatchOnlyConsentDescription")
+                        }
+                    }
+                    .frame(minHeight: geometry.size.height, alignment: .bottom)
+                }
+                .scrollIndicators(.hidden)
+            }
+
+            if config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled {
+                usdtSharingConsent
+                    .fixedSize(horizontal: false, vertical: true)
+                    .padding(.top, 32)
+            }
+
+            HStack(spacing: 16) {
+                CustomButton(title: t("common__cancel"), variant: .secondary) { sheets.hideSheet() }
+                    .accessibilityIdentifier("PubkyAuthWatchOnlyCancel")
+                CustomButton(title: t("pubky_auth__watch_only_intro_approve"), isDisabled: receivingDetailsUnavailable) {
+                    _ = state.approveWatchOnlyConsent()
+                }
+                .accessibilityIdentifier("PubkyAuthWatchOnlyApprove")
+            }
+            .padding(.top, 32)
+        }
+        .padding(.horizontal, 16)
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("PubkyAuthWatchOnlyConsent")
+    }
+
+    private var receivingDetailsUnavailable: Bool {
+        (config.request.bitkitClaim?.requiresUsdtAddress == true || shareUsdt) && usdtAddress == nil
+    }
+
+    private var usdtSharingConsent: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            if config.request.bitkitClaim?.requiresUsdtAddress != true {
+                Toggle(isOn: $shareUsdt) {
+                    BodyMText(t("pubky_auth__share_usdt_optional"), kerning: 0, lineHeight: 22)
+                }
+                .tint(.blueAccent)
+                .accessibilityIdentifier("PubkyAuthShareUsdt")
+            }
+            if shareUsdt || config.request.bitkitClaim?.requiresUsdtAddress == true {
+                BodySText(t("pubky_auth__usdt_privacy"), textColor: .white64)
+                    .accessibilityIdentifier("PubkyAuthUsdtPrivacy")
+                if usdtUnavailable {
+                    BodySText(t("pubky_auth__usdt_unavailable"), textColor: .white64)
+                    Button(t("common__retry")) { Task { await loadUsdtAddress() } }
+                        .tint(.blueAccent)
+                } else if usdtAddress == nil {
+                    ProgressView()
+                }
+            }
+        }
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("PubkyAuthUsdtDetails")
     }
 
     // MARK: - Authorization
@@ -226,7 +285,7 @@ struct PubkyAuthApprovalSheet: View {
             SheetHeader(
                 title: headerTitle,
                 showBackButton: showsBackButton,
-                topPadding: 28, bottomPadding: 22, dragIndicatorTopPadding: 8,
+                topPadding: 28, bottomPadding: state == .success ? 30 : 22, dragIndicatorTopPadding: 8,
                 onBack: onBack
             )
 
@@ -257,8 +316,7 @@ struct PubkyAuthApprovalSheet: View {
                 CustomButton(title: t("pubky_auth__title")) {
                     await onAuthorize()
                 }
-                .disabled((config.request.bitkitClaim?.requiresUsdtAddress == true && (!shareUsdt || usdtAddress == nil))
-                    || (config.request.bitkitClaim?.sharesUsdt == true && shareUsdt && usdtAddress == nil))
+                .disabled(receivingDetailsUnavailable || (config.request.bitkitClaim?.requiresUsdtAddress == true && !shareUsdt))
                 .accessibilityIdentifier("PubkyAuthAuthorize")
             }
         }
@@ -285,14 +343,9 @@ struct PubkyAuthApprovalSheet: View {
                     VStack(alignment: .leading, spacing: 0) {
                         successDescriptionText
                             .padding(.horizontal, 16)
-                            .padding(.bottom, 16)
-                        if config.request.bitkitClaim?.sharesBitcoin == true || (shareUsdt && usdtAddress != nil) {
-                            BodyMText(t(sharingSuccessKey))
-                                .accessibilityIdentifier("PubkyAuthSharedDetails")
-                                .padding(.horizontal, 16)
-                        }
+                            .accessibilityIdentifier("PubkyAuthSharedDetails")
 
-                        Spacer(minLength: 0)
+                        Spacer(minLength: 32)
 
                         Image("check")
                             .resizable()
@@ -336,10 +389,6 @@ struct PubkyAuthApprovalSheet: View {
                             .padding(.bottom, 32)
                     }
 
-                    if hasReceivingDetails {
-                        paymentDetailsSection
-                            .padding(.bottom, 24)
-                    }
                     if !config.request.permissions.isEmpty {
                         permissionsSection
                     }
@@ -355,6 +404,8 @@ struct PubkyAuthApprovalSheet: View {
                         .accessibilityIdentifier("PubkyAuthPaykitAccess")
                     }
 
+                    Spacer(minLength: 32)
+
                     trustWarning
                         .padding(.bottom, 16)
 
@@ -401,14 +452,8 @@ struct PubkyAuthApprovalSheet: View {
         )
     }
 
-    private var introTitleKey: String {
-        guard config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled else { return "pubky_auth__watch_only_intro_title" }
-        return config.request.bitkitClaim?.sharesBitcoin == true ? "pubky_auth__payment_details_intro_title" : "pubky_auth__usdt_intro_title"
-    }
-
     private var introDescriptionKey: String {
-        guard config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled else { return "pubky_auth__watch_only_intro_description" }
-        return config.request.bitkitClaim?.sharesBitcoin == true ? "pubky_auth__payment_details_intro_description" : "pubky_auth__usdt_intro_description"
+        config.request.bitkitClaim?.sharesBitcoin == true ? "pubky_auth__watch_only_intro_description" : "pubky_auth__usdt_intro_description"
     }
 
     private var sharingSuccessKey: String {
@@ -418,55 +463,6 @@ struct PubkyAuthApprovalSheet: View {
         return "pubky_auth__shared_bitcoin"
     }
 
-    private var paymentDetailsSection: some View {
-        VStack(alignment: .leading, spacing: 12) {
-            CaptionMText(t("pubky_auth__payment_details"), textColor: .white64)
-            if config.request.bitkitClaim?.sharesBitcoin == true {
-                VStack(alignment: .leading, spacing: 4) {
-                    BodySSBText("Bitcoin", textColor: .brandAccent)
-                    BodySText(t("pubky_auth__bitcoin_account"), textColor: .white64)
-                }
-                .accessibilityIdentifier("PubkyAuthBitcoinDetails")
-            }
-            if config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled {
-                VStack(alignment: .leading, spacing: 8) {
-                    if config.request.bitkitClaim?.requiresUsdtAddress == true {
-                        BodySSBText("USDT", textColor: .usdtAccent)
-                    } else {
-                        Toggle(isOn: $shareUsdt) {
-                            BodySSBText(t("pubky_auth__share_usdt_optional"), textColor: .usdtAccent)
-                        }
-                        .tint(.usdtAccent)
-                        .disabled(state == .authorizing)
-                        .accessibilityIdentifier("PubkyAuthShareUsdt")
-                    }
-                    if settings.isUsdtEnabled, let usdtAddress {
-                        Button { showsUsdtAddress.toggle() } label: {
-                            BodySText(showsUsdtAddress ? usdtAddress : String(usdtAddress.prefix(8)) + "…" + String(usdtAddress.suffix(6)))
-                                .multilineTextAlignment(.leading)
-                        }
-                        .accessibilityIdentifier("PubkyAuthUsdtAddress")
-                        if showsUsdtAddress {
-                            Button(t("common__copy")) { UIPasteboard.general.string = usdtAddress }
-                                .tint(.usdtAccent)
-                                .accessibilityIdentifier("PubkyAuthCopyUsdtAddress")
-                        }
-                    } else if settings.isUsdtEnabled, usdtUnavailable {
-                        BodySText(t("pubky_auth__usdt_unavailable"), textColor: .white64)
-                        Button(t("common__retry")) { Task { await loadUsdtAddress() } }
-                            .tint(.usdtAccent)
-                    } else if settings.isUsdtEnabled {
-                        ProgressView()
-                    }
-                    BodySText(t("pubky_auth__usdt_privacy"), textColor: .white64)
-                }
-                .accessibilityElement(children: .contain)
-                .accessibilityIdentifier("PubkyAuthUsdtDetails")
-            }
-            CustomDivider(color: .white10)
-        }
-    }
-
     private func loadUsdtAddress() async {
         guard config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled else { return }
         usdtAddress = nil
@@ -503,15 +499,18 @@ struct PubkyAuthApprovalSheet: View {
     }
 
     private var successDescriptionText: some View {
-        BodyMText(
-            requesterText.isEmpty
-                ? t("pubky_auth__success_prefix") + "<accent>" + truncatedPublicKey + "</accent>"
-                + t("pubky_auth__success_middle") + "<accent>" + serviceText + "</accent>"
-                + t("pubky_auth__success_suffix")
-                : pubkyAuthFilledText(
-                    t("pubky_auth__success_named"),
-                    variables: ["pubky": truncatedPublicKey, "clientId": requesterText, "service": serviceText]
-                ),
+        let authorization = requesterText.isEmpty
+            ? t("pubky_auth__success_prefix") + "<accent>" + truncatedPublicKey + "</accent>"
+            + t("pubky_auth__success_middle") + "<accent>" + serviceText + "</accent>"
+            + t("pubky_auth__success_suffix")
+            : pubkyAuthFilledText(
+                t("pubky_auth__success_named"),
+                variables: ["pubky": truncatedPublicKey, "clientId": requesterText, "service": serviceText]
+            )
+        let sharedDetails = config.request.bitkitClaim?.sharesBitcoin == true || (shareUsdt && usdtAddress != nil)
+            ? "\n\n" + t(sharingSuccessKey) : ""
+        return BodyMText(
+            authorization + sharedDetails,
             accentColor: .textPrimary,
             accentFont: Fonts.bold,
             kerning: 0, lineHeight: 22
diff --git a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
index 27d9b0453..ccb919e6e 100644
--- a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
+++ b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
@@ -3,6 +3,8 @@ import SwiftUI
 
 struct CreateSubscriptionView: View {
     @EnvironmentObject private var app: AppViewModel
+    @EnvironmentObject private var currency: CurrencyViewModel
+    @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var wallet: WalletViewModel
 
     @Binding var draft: PaykitSubscriptionDraft
@@ -23,19 +25,21 @@ struct CreateSubscriptionView: View {
 
     var body: some View {
         VStack(spacing: 0) {
-            SheetHeader(title: t("subscriptions__create_subscription"))
+            SheetHeader(title: t("subscriptions__create_subscription"), topPadding: 28, bottomPadding: 22, dragIndicatorTopPadding: 8)
 
             ScrollViewReader { proxy in
                 GeometryReader { geometry in
                     ScrollView(showsIndicators: false) {
                         VStack(alignment: .leading, spacing: 24) {
                             amount
-                            SubscriptionPaymentMethods(title: t("wallet__payment_request_accepted_methods"), endpoints: acceptedEndpoints)
                             frequency
+                            acceptedPayments
                             name
-                            description
-                                .id("SubscriptionDescription")
-                            customIcon
+                            HStack(alignment: .top, spacing: 16) {
+                                description
+                                customIcon
+                            }
+                            .id("SubscriptionDescription")
                         }
                         .padding(.bottom, 24)
                     }
@@ -61,7 +65,8 @@ struct CreateSubscriptionView: View {
             .accessibilityIdentifier("SubscriptionChooseRecipient")
         }
         .padding(.horizontal, 16)
-        .sheetBackground()
+        .modifier(SheetBackgroundModifier(base: .gray7, applyGradient: false))
+        .preference(key: SheetBackgroundPreferenceKey.self, value: .gray7)
         .navigationBarHidden(true)
         .onChange(of: draft.name) { _, value in
             if value.count > 256 {
@@ -81,7 +86,7 @@ struct CreateSubscriptionView: View {
     }
 
     private var amount: some View {
-        VStack(alignment: .leading, spacing: 12) {
+        VStack(alignment: .leading, spacing: 16) {
             CaptionMText(t("wallet__payment_request_amount").localizedUppercase, textColor: .white64)
             Button(action: onEditAmount) {
                 HStack(spacing: 8) {
@@ -115,6 +120,33 @@ struct CreateSubscriptionView: View {
         )
     }
 
+    private var acceptedPayments: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            CaptionMText(t("subscriptions__accepted_payments"), textColor: .white64)
+            HStack(spacing: 8) {
+                ForEach(settings.isUsdtEnabled ? [PaykitAsset.btc, .usd] : [.btc], id: \.self) { asset in
+                    let isSelected = draft.amount.asset == asset
+                    NumberPadActionButton(
+                        text: asset == .btc ? "BITCOIN" : "USDT",
+                        color: isSelected ? (asset == .btc ? .brandAccent : .usdtAccent) : .white32,
+                        variant: .secondary
+                    ) {
+                        guard !isSelected else { return }
+                        do {
+                            draft.amount = draft.amount.atomic == 0
+                                ? PaykitAmount(asset: asset, atomic: 0)
+                                : try draft.amount.converted(to: asset, rate: currency.paykitRate, at: Date())
+                        } catch {
+                            app.toast(type: .error, title: t("common__error"), description: t("wallet__payment_request_rate_unavailable"))
+                        }
+                    }
+                    .accessibilityAddTraits(isSelected ? .isSelected : [])
+                    .accessibilityIdentifier("SubscriptionAccept-\(asset == .btc ? "bitcoin" : "usdt")")
+                }
+            }
+        }
+    }
+
     private var frequency: some View {
         VStack(alignment: .leading, spacing: 8) {
             CaptionMText(t("subscriptions__frequency").localizedUppercase, textColor: .white64)
@@ -151,8 +183,8 @@ struct CreateSubscriptionView: View {
                 placeholder: t("subscriptions__description_placeholder"),
                 testIdentifier: "SubscriptionDescription",
                 isFocused: $isDescriptionFocused,
-                minHeight: 60,
-                maxHeight: 60,
+                minHeight: 80,
+                maxHeight: 80,
                 backgroundColor: .white10
             )
         }
@@ -162,27 +194,23 @@ struct CreateSubscriptionView: View {
         VStack(alignment: .leading, spacing: 8) {
             CaptionMText(t("subscriptions__custom_icon").localizedUppercase, textColor: .white64)
             PhotosPicker(selection: $selectedPhotoItem, matching: .images) {
-                HStack(spacing: 16) {
-                    Group {
-                        if let iconImage {
-                            Image(uiImage: iconImage)
-                                .resizable()
-                                .scaledToFill()
-                        } else {
-                            SubscriptionDefaultIcon(size: 40)
-                        }
+                Group {
+                    if let iconImage {
+                        Image(uiImage: iconImage)
+                            .resizable()
+                            .scaledToFill()
+                    } else {
+                        SubscriptionDefaultIcon(size: 40)
                     }
-                    .frame(width: 40, height: 40)
-                    .clipShape(RoundedRectangle(cornerRadius: 8))
-
-                    CaptionBText(t("subscriptions__custom_icon_description"), textColor: .white64)
-                    Spacer()
                 }
+                .frame(width: 40, height: 40)
+                .clipShape(RoundedRectangle(cornerRadius: 8))
                 .padding(16)
                 .background(Color.white10)
                 .clipShape(RoundedRectangle(cornerRadius: 8))
             }
             .disabled(isLoadingIcon)
+            .accessibilityLabel(t("subscriptions__custom_icon_description"))
             .accessibilityIdentifier("SubscriptionIconPicker")
         }
     }
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index bd84fdf54..36568131d 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -2,13 +2,13 @@
   <description>Two linked Bitkit wallets with Paykit and USDT enabled, sharing enabled by their owners, and a fresh BTC/USD rate. These request-creation and amount-screen checks need no funds and stop before payment review. Funded Arbitrum review, paid history, controlled rates and proof verification are manual tests in Docs/USDT-QA.md; a Bitcoin regtest balance does not fund USDT.</description>
   <actions>
     <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
-    <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify one Savings choice covers Bitcoin address types, Spending appears when Lightning is enabled, and USDT is available.</action>
+    <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify Accept Payment In appears below expiry, with compact outlined Bitcoin and USDT chips. Bitcoin groups all available Savings and Spending methods; no separate rail chips appear here.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
     <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
     <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
-    <action>Create a USD subscription. Verify only USDT is accepted at fixed 1:1 parity. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method. Verify the subscription swipe uses USDT teal, then close before subscribing.</action>
-    <action>Create a BTC subscription and verify that only enabled Savings and Spending methods are accepted, with no USDT choice. Close without proposing.</action>
+    <action>Create a USD subscription. Verify Accepted Payments appears below frequency, with USDT selected and Bitcoin unselected. Verify the description and icon controls are side by side. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method. Verify the subscription swipe uses USDT teal, then close before subscribing.</action>
+    <action>Create a BTC subscription and verify Bitcoin is selected. Tap SubscriptionAccept-usdt; verify the amount converts to USD and only USDT is selected. Tap SubscriptionAccept-bitcoin; verify the amount converts to BTC and only Bitcoin is selected, covering the enabled Savings and Spending methods. Close without proposing.</action>
     <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01, then close without continuing to review.</action>
   </actions>
 </journey>
diff --git a/journeys/pubky-auth/share-receiving-details.xml b/journeys/pubky-auth/share-receiving-details.xml
index 2467ff4ae..3df42864f 100644
--- a/journeys/pubky-auth/share-receiving-details.xml
+++ b/journeys/pubky-auth/share-receiving-details.xml
@@ -2,22 +2,21 @@
   <description>Use an onboarded empty wallet with a Pubky identity and configured USDT. Enable USDT in Settings for the first checks. Use a local test auth request; cancel before Authorize so no receiving details or session are exported.</description>
   <actions>
     <action>Open the existing watch-only setup fixture with x-bitkit-claim=usdt-address-v1</action>
-    <action>Verify the Earn USDT introduction, then tap Approve</action>
-    <action>Verify only USDT Arbitrum details, the existing address and balance/history disclosure are shown</action>
-    <action>Expand the address and copy it; verify it matches the wallet receive address</action>
+    <action>Verify the Earn Money introduction describes sharing the existing USDT address on Arbitrum One, with the balance/history disclosure and no optional sharing switch. Tap Approve</action>
+    <action>Verify the authorization screen shows the requested permissions and trust warning without repeating the receiving-details controls</action>
     <action>Cancel and verify no Bitcoin account was created</action>
-    <action>Repeat with x-bitkit-claim=watch-only-account-v1.usdt-address-v1; verify Bitcoin and USDT appear together, then cancel</action>
+    <action>Repeat with x-bitkit-claim=watch-only-account-v1.usdt-address-v1; verify the Earn Money introduction describes the Bitcoin watch-only account and shows the blue "Also share my USDT address" switch (id "PubkyAuthShareUsdt"). Turn sharing off and verify its privacy disclosure disappears. Tap Approve, then Back; verify the choice remains off. Cancel</action>
     <action>Repeat with x-bitkit-claim=watch-only-account-v1; verify only Bitcoin is requested, then cancel</action>
-    <action>With USDT enabled but its address temporarily unavailable, open a combined Bitcoin and USDT request. Verify sharing is off and Bitcoin authorization remains available; turn USDT sharing on and verify authorization is disabled until Retry loads the address</action>
+    <action>With USDT enabled but its address temporarily unavailable, open a combined Bitcoin and USDT request. Verify sharing is off and Approve remains available; turn USDT sharing on and verify Approve is disabled until Retry loads the address</action>
     <action>Open the setup fixture with x-bitkit-claim=paykit-access-v1.watch-only-account-v1.usdt-address-v1</action>
-    <action>Continue to authorization; verify the named requester, exact requested permission paths and access, Bitcoin account, Paykit Details explanation, and optional USDT sharing toggle are shown</action>
+    <action>Verify the introduction shows the optional USDT sharing switch and selected-address privacy disclosure. Continue to authorization; verify the named requester, exact requested permission paths and access, and Paykit Details explanation are shown without a second sharing switch or address panel</action>
     <action>Verify Before You Continue explains trusting the service, browser, and device. Verify the compact horizontal profile card (id "PubkyAuthProfile") shows the correct identity and name, with Cancel and Authorize reachable without overlap.</action>
-    <action>Turn off PubkyAuthShareUsdt; verify authorization remains enabled, then cancel</action>
+    <action>Go back to the introduction and turn off PubkyAuthShareUsdt. Continue to authorization; verify Authorize remains enabled, then cancel</action>
     <action>Open the auth fixture with only x-bitkit-claim=paykit-access-v1; verify Paykit permissions and Details are shown without an empty Payment Details to Share section, then cancel.</action>
     <action>Turn USDT off in Settings, then open x-bitkit-claim=watch-only-account-v1.usdt-address-v1. Verify the introduction and authorization show Bitcoin only: no USDT sharing switch, address, privacy text or enable prompt. Cancel before Authorize.</action>
     <action>With USDT still off, repeat with x-bitkit-claim=paykit-access-v1.watch-only-account-v1.usdt-address-v1. Verify Bitcoin and Paykit permissions remain available without any USDT content or enable prompt, then cancel.</action>
     <action>With USDT still off, open x-bitkit-claim=paykit-access-v1.usdt-address-v1. Verify Paykit permissions appear without a receiving-details introduction or USDT content. Go back and verify the request closes without showing a Bitcoin introduction.</action>
     <action>With USDT still off, open x-bitkit-claim=usdt-address-v1. Verify the request is unavailable and authorization cannot be submitted; no enable prompt or successful setup is shown. Cancel and verify Settings still shows USDT off.</action>
-    <action>Enable USDT in Settings and reopen the combined request. Verify the optional USDT switch, address and privacy disclosure return. Turn sharing off and verify Bitcoin authorization remains available, then cancel.</action>
+    <action>Enable USDT in Settings and reopen the combined request. Verify the optional USDT switch and selected-address privacy disclosure return on the introduction. Turn sharing off and verify Bitcoin approval remains available, then cancel.</action>
   </actions>
 </journey>

From cc4b35430f2e03d0323d5b7e2945466e9c9ab625 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 13:44:47 -0500
Subject: [PATCH 44/62] fix: keep Earn disclosures visible on compact screens

---
 .../PubkyAuthApprovalSheet.swift              | 46 +++++++++++++------
 1 file changed, 32 insertions(+), 14 deletions(-)

diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index 7f0016e30..d004eea30 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -206,27 +206,28 @@ struct PubkyAuthApprovalSheet: View {
             SheetHeader(title: t("pubky_auth__watch_only_intro_nav_title"),
                         topPadding: 28, bottomPadding: 0, dragIndicatorTopPadding: 8)
 
-            GeometryReader { geometry in
+            ViewThatFits(in: .vertical) {
+                VStack(alignment: .leading, spacing: 32) {
+                    watchOnlyConsentArtwork
+                        .frame(minHeight: 0, idealHeight: 0, maxHeight: 256)
+                        .layoutPriority(-1)
+
+                    watchOnlyConsentIntroduction
+                        .fixedSize(horizontal: false, vertical: true)
+                        .layoutPriority(1)
+                }
+
                 ScrollView {
                     VStack(alignment: .leading, spacing: 32) {
-                        Image("coin-stack-4")
-                            .resizable()
-                            .scaledToFit()
-                            .frame(width: 328, height: 328)
-                            .frame(width: 256, height: 256)
-                            .frame(maxWidth: .infinity)
-                            .accessibilityHidden(true)
+                        watchOnlyConsentArtwork
+                            .frame(height: 256)
 
-                        VStack(alignment: .leading, spacing: 8) {
-                            DisplayText(t("pubky_auth__watch_only_intro_title"), accentColor: .blueAccent)
-                            BodyMText(watchOnlyConsentDescription, kerning: 0, lineHeight: 22)
-                                .accessibilityIdentifier("PubkyAuthWatchOnlyConsentDescription")
-                        }
+                        watchOnlyConsentIntroduction
                     }
-                    .frame(minHeight: geometry.size.height, alignment: .bottom)
                 }
                 .scrollIndicators(.hidden)
             }
+            .frame(maxHeight: .infinity, alignment: .bottom)
 
             if config.request.bitkitClaim?.sharesUsdt == true, settings.isUsdtEnabled {
                 usdtSharingConsent
@@ -249,6 +250,23 @@ struct PubkyAuthApprovalSheet: View {
         .accessibilityIdentifier("PubkyAuthWatchOnlyConsent")
     }
 
+    private var watchOnlyConsentArtwork: some View {
+        Image("coin-stack-4")
+            .resizable()
+            .scaledToFit()
+            .scaleEffect(328.0 / 256.0)
+            .frame(maxWidth: .infinity)
+            .accessibilityHidden(true)
+    }
+
+    private var watchOnlyConsentIntroduction: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            DisplayText(t("pubky_auth__watch_only_intro_title"), accentColor: .blueAccent)
+            BodyMText(watchOnlyConsentDescription, kerning: 0, lineHeight: 22)
+                .accessibilityIdentifier("PubkyAuthWatchOnlyConsentDescription")
+        }
+    }
+
     private var receivingDetailsUnavailable: Bool {
         (config.request.bitkitClaim?.requiresUsdtAddress == true || shareUsdt) && usdtAddress == nil
     }

From f53b894bcdcf446bd5c1f97553ab5ea0f0f60f99 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 14:10:00 -0500
Subject: [PATCH 45/62] fix: align subscription totals and use core rc6

---
 Bitkit.xcodeproj/project.pbxproj              |  2 +-
 .../xcshareddata/swiftpm/Package.resolved     |  4 +--
 .../Subscriptions/SubscriptionsView.swift     | 27 ++++++++++++++++---
 .../PaykitPaymentRequestServiceTests.swift    | 13 +++++++++
 .../subscriptions/review-and-subscribe.xml    |  1 +
 5 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/Bitkit.xcodeproj/project.pbxproj b/Bitkit.xcodeproj/project.pbxproj
index b98cf76c7..0a142fcb7 100644
--- a/Bitkit.xcodeproj/project.pbxproj
+++ b/Bitkit.xcodeproj/project.pbxproj
@@ -1234,7 +1234,7 @@
 			repositoryURL = "https://github.com/synonymdev/bitkit-core";
 			requirement = {
 				kind = exactVersion;
-				version = "0.8.0-rc5";
+				version = "0.8.0-rc6";
 			};
 		};
 		96E493A22C942FD1000E8BC2 /* XCRemoteSwiftPackageReference "swift-secp256k1" */ = {
diff --git a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
index 885da0d31..49f9b98b5 100644
--- a/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
+++ b/Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -6,8 +6,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/synonymdev/bitkit-core",
       "state" : {
-        "revision" : "f5972d655a9f9a3807df03899f79339ddc68ae83",
-        "version" : "0.8.0-rc5"
+        "revision" : "e2c768f5dcae6f81c99a97aa01c0494bb0a05284",
+        "version" : "0.8.0-rc6"
       }
     },
     {
diff --git a/Bitkit/Views/Subscriptions/SubscriptionsView.swift b/Bitkit/Views/Subscriptions/SubscriptionsView.swift
index bdd0c60c8..50327f9e5 100644
--- a/Bitkit/Views/Subscriptions/SubscriptionsView.swift
+++ b/Bitkit/Views/Subscriptions/SubscriptionsView.swift
@@ -32,6 +32,7 @@ struct SubscriptionsView: View {
         }
     }
 
+    @EnvironmentObject private var currency: CurrencyViewModel
     @EnvironmentObject private var navigation: NavigationViewModel
     @EnvironmentObject private var sheets: SheetViewModel
     @Environment(PaykitPaymentRequestManager.self) private var paymentRequests
@@ -180,10 +181,12 @@ struct SubscriptionsView: View {
     private var metrics: some View {
         HStack(spacing: 16) {
             SubscriptionMetric(title: t("subscriptions__monthly_cost"), icon: "calendar") {
-                VStack(alignment: .leading, spacing: 4) {
-                    ForEach(subscriptionMonthlyCosts(subscriptions: paymentRequests.subscriptions, now: now), id: \.asset) { amount in
-                        PaykitAmountText(amount: amount).lineLimit(1).minimumScaleFactor(0.5)
-                    }
+                let costs = subscriptionMonthlyCosts(subscriptions: paymentRequests.subscriptions, now: now)
+                if let sats = subscriptionMonthlyCostSats(amounts: costs, rate: currency.paykitRate) {
+                    MoneyText(sats: sats, size: .bodyMSB, symbol: true, fillsWidth: false)
+                        .lineLimit(1).minimumScaleFactor(0.5)
+                } else {
+                    BodyMSBText("—")
                 }
             }
             .frame(maxWidth: .infinity, alignment: .leading)
@@ -227,6 +230,22 @@ struct SubscriptionsView: View {
     }
 }
 
+func subscriptionMonthlyCostSats(amounts: [PaykitAmount], rate: PaykitExchangeRate?, now: Date = Date()) -> Int? {
+    var total = 0
+    for amount in amounts {
+        let sats: Int? = switch amount.asset {
+        case _ where amount.atomic == 0: 0
+        case .btc: Int(exactly: amount.atomic)
+        case .usd, .usdt: usdtDisplaySats(amount: amount.value, rate: rate, now: now)
+        }
+        guard let sats else { return nil }
+        let addition = total.addingReportingOverflow(sats)
+        guard !addition.overflow else { return nil }
+        total = addition.partialValue
+    }
+    return total
+}
+
 func subscriptionMonthlyCosts(subscriptions: [PaykitSubscription], now: Date) -> [PaykitAmount] {
     let annualPeriods: (PaykitSubscriptionRecurrence.Unit) -> Decimal = { unit in
         switch unit {
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index eb697efa0..2d33abcdd 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -11,6 +11,19 @@ import XCTest
 
 @MainActor
 final class PaykitPaymentRequestServiceTests: XCTestCase {
+    func testMonthlyCostCombinesAssetsUsingTheWalletRate() {
+        let now = Date()
+        let amounts = [
+            PaykitAmount(asset: .btc, atomic: 100_000),
+            PaykitAmount(asset: .usd, atomic: 200),
+            PaykitAmount(asset: .usdt, atomic: 3_000_000),
+        ]
+        let rate = PaykitExchangeRate(price: "100000", timestamp: now)
+        XCTAssertEqual(subscriptionMonthlyCostSats(amounts: amounts, rate: rate, now: now), 105_000)
+        XCTAssertNil(subscriptionMonthlyCostSats(amounts: amounts, rate: nil, now: now))
+        XCTAssertEqual(subscriptionMonthlyCostSats(amounts: Array(amounts.prefix(1)), rate: nil, now: now), 100_000)
+    }
+
     func testFixedBitcoinPricingUsesRailRatesBeforeAssetRatesAndParity() throws {
         let cases: [(String, String, [ConversionRate], [String], UInt64)] = [
             ("usd", "1000", [.init(asset: "btc", value: "0.001")], ["btc-lightning-bolt11"], 100_000_000),
diff --git a/journeys/subscriptions/review-and-subscribe.xml b/journeys/subscriptions/review-and-subscribe.xml
index 41a722352..bdedfcc40 100644
--- a/journeys/subscriptions/review-and-subscribe.xml
+++ b/journeys/subscriptions/review-and-subscribe.xml
@@ -35,5 +35,6 @@
     <action>Verify the Amount screen keeps $2 locked and USDT as its only payment source; no Bitcoin amount, Savings source or editable amount is offered</action>
     <action>Tap Continue and verify the USDT review shows 2 USDT, the creator's address and the fee; do not swipe to pay</action>
     <action>Close the send sheet, reopen this subscription's unpaid first period from Payments, and verify it still offers the locked 2 USDT payment; cancel without sending</action>
+    <action>Return to the Overview tab with both the Bitcoin and USD subscriptions active. Verify Monthly Cost shows one total in the selected display currency, using Bitkit's exchange rate, aligned with Active and Created rather than separate stacked amounts.</action>
   </actions>
 </journey>

From c5513d83e9fbe801b96906c3a6962d52b5056bd7 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Tue, 13 Oct 2026 17:09:05 -0500
Subject: [PATCH 46/62] fix: preserve usdt consent and avoid redundant proof
 backups

---
 Bitkit/AppScene.swift                         |  4 +--
 Bitkit/Managers/UsdtWalletManager.swift       |  4 +++
 Bitkit/Models/UsdtPreference.swift            |  6 +++-
 .../Services/PaykitUsdtPaymentService.swift   | 32 +++++++++++++------
 .../CreatePaymentRequestView.swift            |  3 +-
 .../PubkyAuthApprovalSheet.swift              | 23 +++++++------
 .../PaykitPaymentRequestServiceTests.swift    |  7 +++-
 .../PaykitPaymentStateBackupTests.swift       | 11 +++++--
 BitkitTests/PubkyAuthApprovalSheetTests.swift | 11 +++++++
 BitkitTests/UsdtWalletManagerTests.swift      | 20 ++++++++++--
 Docs/USDT.md                                  |  4 +--
 journeys/README.md                            |  4 +++
 journeys/paykit-quoted-usdt.xml               |  1 +
 .../pubky-auth/share-receiving-details.xml    |  2 ++
 journeys/usdt-opt-in.xml                      |  1 +
 journeys/usdt-payment-links-and-scans.xml     |  2 +-
 journeys/usdt-payment-restoration.xml         |  9 ++++++
 17 files changed, 112 insertions(+), 32 deletions(-)
 create mode 100644 journeys/usdt-payment-restoration.xml

diff --git a/Bitkit/AppScene.swift b/Bitkit/AppScene.swift
index 3af01935a..590a68bb3 100644
--- a/Bitkit/AppScene.swift
+++ b/Bitkit/AppScene.swift
@@ -659,8 +659,8 @@ struct AppScene: View {
 
     private var appEventContent: some View {
         paykitEventContent
-            .onChange(of: wallet.usdtWallet.hasProtectedFunds, initial: true) { _, hasProtectedFunds in
-                settings.protectUsdtFunds(hasProtectedFunds)
+            .onChange(of: wallet.usdtWallet.hasFundsOrPendingTransfers, initial: true) { _, hasFundsOrPendingTransfers in
+                settings.protectUsdtFunds(hasFundsOrPendingTransfers)
             }
             .onChange(of: settings.usdtPreference) { _, _ in
                 PublicPaykitService.setCleanupPending(true)
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index ba84e2fc7..e9e428eb4 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -47,6 +47,10 @@ final class UsdtWalletManager {
         UsdtPreference.protectsFunds(balance: balance, transfers: transfers) || !pendingDepositIds.isEmpty
     }
 
+    var hasFundsOrPendingTransfers: Bool {
+        UsdtPreference.hasFundsOrPendingTransfers(balance: balance, transfers: transfers) || !pendingDepositIds.isEmpty
+    }
+
     func checkCanDisable() async throws {
         try beginOperation()
         defer { finishOperation() }
diff --git a/Bitkit/Models/UsdtPreference.swift b/Bitkit/Models/UsdtPreference.swift
index 4f11a8f36..76790c852 100644
--- a/Bitkit/Models/UsdtPreference.swift
+++ b/Bitkit/Models/UsdtPreference.swift
@@ -13,7 +13,11 @@ enum UsdtPreference: String {
     }
 
     static func protectsFunds(balance: UInt64?, transfers: [UsdtTransfer]) -> Bool {
-        (balance ?? 0) > 0 || (balance == nil && !transfers.isEmpty) || transfers.contains { transfer in
+        (balance == nil && !transfers.isEmpty) || hasFundsOrPendingTransfers(balance: balance, transfers: transfers)
+    }
+
+    static func hasFundsOrPendingTransfers(balance: UInt64?, transfers: [UsdtTransfer]) -> Bool {
+        (balance ?? 0) > 0 || transfers.contains { transfer in
             switch transfer.status {
             case .pending, .bridging, .bridgeNeedsAttention, .bridgeFailed: true
             case .confirmed, .failed, .replaced, .bridgeRefunded: false
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
index 9055cdd7d..a4e636cc3 100644
--- a/Bitkit/Services/PaykitUsdtPaymentService.swift
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -80,6 +80,7 @@ final class PaykitUsdtPaymentService {
     private var restoreGeneration = 0
     private(set) var resumableRequests: Set<PaykitPaymentRequest.ID> = []
     private var unsubmittedAttempts: [Attempt] = []
+    private var boundRequestIds: Set<PaykitPaymentRequest.ID>?
 
     private nonisolated(unsafe) static let stateChanged = PassthroughSubject<Void, Never>()
     nonisolated static var walletBackupDataChangedPublisher: AnyPublisher<Void, Never> {
@@ -93,6 +94,7 @@ final class PaykitUsdtPaymentService {
     }
 
     func restoreBackup(_ backup: PaykitUsdtStateBackup) throws {
+        boundRequestIds = nil
         restoreGeneration &+= 1
         unsubmittedAttempts = []
         resumableRequests = []
@@ -166,6 +168,7 @@ final class PaykitUsdtPaymentService {
     }
 
     private func save(_ state: State) throws {
+        boundRequestIds = nil
         try Keychain.upsert(key: .paykitUsdtPayments, data: JSONEncoder().encode(state))
         publish(state)
         Self.stateChanged.send()
@@ -175,11 +178,15 @@ final class PaykitUsdtPaymentService {
         attempts = state.attempts.filter { $0.wallet == activeWallet && $0.identity == activeIdentity }
         receipts = state.receipts.filter { $0.wallet == activeWallet && $0.identity == activeIdentity }
         unsubmittedAttempts.removeAll { !attempts.contains($0) }
+        boundRequestIds = Set(state.attempts.filter { !unsubmittedAttempts.contains($0) }.compactMap(\.requestId))
     }
 
     func hasBinding(for requestId: PaykitPaymentRequest.ID) -> Bool {
-        guard let state = try? load() else { return true }
-        return state.attempts.contains { $0.requestId == requestId && !unsubmittedAttempts.contains($0) }
+        if boundRequestIds == nil {
+            guard let state = try? load() else { return true }
+            publish(state)
+        }
+        return boundRequestIds?.contains(requestId) ?? true
     }
 
     func paymentProtection(identity: String) throws
@@ -313,6 +320,7 @@ final class PaykitUsdtPaymentService {
 
     func reconcile(wallet: UsdtWalletManager) async {
         guard wallet.isConfigured else {
+            boundRequestIds = nil
             unsubmittedAttempts = []
             resumableRequests = []
             return
@@ -343,6 +351,7 @@ final class PaykitUsdtPaymentService {
         let generation = restoreGeneration
         reconciling = true
         defer { reconciling = false }
+        boundRequestIds = nil
         unsubmittedAttempts = []
         resumableRequests = []
         do {
@@ -401,9 +410,10 @@ final class PaykitUsdtPaymentService {
                 }
             }
             guard restoreGeneration == generation, activeWallet == owner, activeIdentity == identity else { return }
-            let currentAttempts = try load().attempts
-            resumableRequests = Set(resumable.filter { currentAttempts.contains($0) }.compactMap(\.requestId))
-            unsubmittedAttempts = unsubmitted.filter { currentAttempts.contains($0) }
+            let currentState = try load()
+            resumableRequests = Set(resumable.filter { currentState.attempts.contains($0) }.compactMap(\.requestId))
+            unsubmittedAttempts = unsubmitted.filter { currentState.attempts.contains($0) }
+            publish(currentState)
             try Task.checkCancellation()
             for record in try await paymentRequests() where record.localRole == .payee {
                 for submission in record.paymentProofs
@@ -440,12 +450,14 @@ final class PaykitUsdtPaymentService {
                         let receivedAt = Date(timeIntervalSince1970: TimeInterval(payment.timestamp))
                         let terms = try request.payment(using: .usdtArbitrum, at: receivedAt, quoteId: submission.conversionQuoteId)
                         let received = PaykitAmount(asset: .usdt, atomic: payment.amount)
+                        let receipt = Receipt(wallet: owner, identity: identity, requestId: request.id,
+                                              paymentId: payment.paymentId, proofEventId: submission.eventId, verified: true,
+                                              transferId: payment.transferId, amount: received,
+                                              receivedAt: receivedAt, underpaid: received.atomic < terms.amount.atomic,
+                                              afterExpiry: !terms.isValid(at: receivedAt))
+                        guard !current.receipts.contains(receipt) else { continue }
                         current.receipts.removeAll { $0.wallet == owner && $0.identity == identity && $0.paymentId == payment.paymentId }
-                        current.receipts.append(Receipt(wallet: owner, identity: identity, requestId: request.id,
-                                                        paymentId: payment.paymentId, proofEventId: submission.eventId, verified: true,
-                                                        transferId: payment.transferId, amount: received,
-                                                        receivedAt: receivedAt, underpaid: received.atomic < terms.amount.atomic,
-                                                        afterExpiry: !terms.isValid(at: receivedAt)))
+                        current.receipts.append(receipt)
                         try save(current)
                     } catch let error as UsdtError {
                         if case .InvalidPaymentProof = error {
diff --git a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
index bbc93050b..7dcf6a3a9 100644
--- a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
+++ b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
@@ -328,7 +328,7 @@ struct PaymentRequestAmountView: View {
             )
 
             if asset == .usd {
-                NumberPadAmountText(value: dollarAmount.isEmpty ? "0" : dollarAmount, symbol: "$")
+                NumberPadAmountText(value: usdtInputAmount(dollarAmount.isEmpty ? "0" : dollarAmount), symbol: "$")
                     .accessibilityIdentifier("\(testIdentifierPrefix)AmountField")
             } else {
                 NumberPadTextField(viewModel: amountViewModel, showEditButton: false, isFocused: true,
@@ -364,6 +364,7 @@ struct PaymentRequestAmountView: View {
             }
             NumberPad(
                 type: asset == .usd ? .decimal : amountViewModel.getNumberPadType(currency: currency),
+                decimalSeparator: Locale.current.decimalSeparator ?? ".",
                 errorKey: amountViewModel.errorKey
             ) { key in
                 if asset == .usd { dollarAmount = NumberPadInputHandler.handleInput(key: key, current: dollarAmount, maxLength: 16, maxDecimals: 2) }
diff --git a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
index d004eea30..967a2e063 100644
--- a/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
+++ b/Bitkit/Views/Sheets/PubkyAuthApproval/PubkyAuthApprovalSheet.swift
@@ -97,6 +97,15 @@ struct PubkyAuthApprovalSheet: View {
             self != .authorizing
         }
 
+        mutating func updateUsdtAvailability(isEnabled: Bool, claim: PubkyAuthClaim?, shareUsdt: inout Bool) {
+            if !isEnabled {
+                shareUsdt = false
+                if self == .watchOnlyConsent, claim?.sharesBitcoin != true { self = .authorize }
+            } else if self == .authorize, claim?.requiresUsdtAddress == true {
+                self = .watchOnlyConsent
+            }
+        }
+
         @MainActor
         mutating func approveWatchOnlyConsent() -> Bool {
             guard self == .watchOnlyConsent else { return false }
@@ -114,7 +123,9 @@ struct PubkyAuthApprovalSheet: View {
 
     init(config: PubkyAuthApprovalSheetItem) {
         self.config = config
-        _state = State(initialValue: Self.initialState(for: config.request))
+        let isUsdtEnabled = Env.isUsdtEnabled && UsdtPreference.isEnabled()
+        _state = State(initialValue: Self.initialState(for: config.request, isUsdtEnabled: isUsdtEnabled))
+        _shareUsdt = State(initialValue: config.request.bitkitClaim?.sharesUsdt == true && isUsdtEnabled)
     }
 
     static func initialState(
@@ -172,16 +183,10 @@ struct PubkyAuthApprovalSheet: View {
             }
         }
         .task(id: settings.isUsdtEnabled) {
-            shareUsdt = config.request.bitkitClaim?.sharesUsdt == true && settings.isUsdtEnabled
+            state.updateUsdtAvailability(isEnabled: settings.isUsdtEnabled, claim: config.request.bitkitClaim, shareUsdt: &shareUsdt)
+            if !settings.isUsdtEnabled { usdtAddress = nil }
             await loadUsdtAddress()
         }
-        .onChange(of: settings.isUsdtEnabled) { _, enabled in
-            if !enabled {
-                shareUsdt = false
-                usdtAddress = nil
-                if state == .watchOnlyConsent, config.request.bitkitClaim?.sharesBitcoin != true { state = .authorize }
-            }
-        }
         .interactiveDismissDisabled(!state.canDismiss)
         .fullScreenCover(isPresented: $isShowingAuthCheck) {
             AuthCheck(
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index 2d33abcdd..de0deecb3 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -8606,7 +8606,11 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
             let service = PaykitUsdtPaymentService()
             try service.restoreBackup(PaykitUsdtStateBackup(attempts: attempts.map(PaykitUsdtStateBackup.Attempt.init), receipts: []))
             var verified = 0
-            for _ in 0 ... 1 {
+            var backupChanges = 0
+            let observation = PaykitUsdtPaymentService.walletBackupDataChangedPublisher.sink { backupChanges += 1 }
+            defer { observation.cancel() }
+            for iteration in 0 ... 1 {
+                backupChanges = 0
                 await service.reconcile(
                     context: { ("wallet", identity) },
                     storedTransfer: { id in self.usdtTransfer(id, status: .confirmed) },
@@ -8626,6 +8630,7 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
                 XCTAssertTrue(try XCTUnwrap(service.attempts.first { $0.quoteId == "quote-1" }).proofQueued)
                 XCTAssertEqual(service.receipts.count, 1)
                 XCTAssertTrue(try XCTUnwrap(service.receipts.first).satisfied)
+                if iteration == 1 { XCTAssertEqual(backupChanges, 0) }
             }
             XCTAssertEqual(verified, 2)
         }
diff --git a/BitkitTests/PaykitPaymentStateBackupTests.swift b/BitkitTests/PaykitPaymentStateBackupTests.swift
index fa00ae9ee..3ff9b59b7 100644
--- a/BitkitTests/PaykitPaymentStateBackupTests.swift
+++ b/BitkitTests/PaykitPaymentStateBackupTests.swift
@@ -158,6 +158,12 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         await reconcileUsdt(service)
         XCTAssertFalse(service.hasBinding(for: requestId))
 
+        for context in [("other-wallet", identity), ("wallet", "other-identity")] {
+            await service.reconcile(context: { context }, storedTransfer: { _ in nil }, paymentProof: { _, _ in nil },
+                                    submitProof: { _ in false }, paymentRequests: { [] }, verifyPayment: { _, _ in nil })
+            XCTAssertTrue(service.hasBinding(for: requestId))
+        }
+
         let restarted = PaykitUsdtPaymentService()
         XCTAssertTrue(restarted.hasBinding(for: requestId))
         await reconcileUsdt(restarted)
@@ -178,7 +184,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
     }
 
     @MainActor
-    func testChangedUsdtAttemptsAndUnreadablePersistenceInvalidateReleaseEvidence() async throws {
+    func testReconciliationInvalidatesReleaseEvidenceForChangedOrUnreadablePersistence() async throws {
         let service = PaykitUsdtPaymentService()
         let attempt = unsubmittedUsdtAttempt()
         let requestId = try XCTUnwrap(attempt.requestId)
@@ -196,6 +202,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
             await reconcileUsdt(service)
             XCTAssertFalse(service.hasBinding(for: requestId))
             try saveUsdtAttempts([changed])
+            await reconcileUsdt(service) { _ in throw PaykitPaymentStateBackupTestError.restoreFailed }
             XCTAssertTrue(service.hasBinding(for: requestId))
             if changed != replacement {
                 await reconcileUsdt(service)
@@ -205,7 +212,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         try saveUsdtAttempts([attempt])
         await reconcileUsdt(service)
         try Keychain.upsert(key: .paykitUsdtPayments, data: Data("unreadable".utf8))
-        XCTAssertTrue(service.hasBinding(for: requestId))
+        XCTAssertTrue(PaykitUsdtPaymentService().hasBinding(for: requestId))
         await reconcileUsdt(service)
         XCTAssertTrue(service.hasBinding(for: requestId))
     }
diff --git a/BitkitTests/PubkyAuthApprovalSheetTests.swift b/BitkitTests/PubkyAuthApprovalSheetTests.swift
index 299933da4..1249f1145 100644
--- a/BitkitTests/PubkyAuthApprovalSheetTests.swift
+++ b/BitkitTests/PubkyAuthApprovalSheetTests.swift
@@ -131,6 +131,17 @@ final class PubkyAuthApprovalSheetTests: XCTestCase {
             let request = try PubkyAuthRequest.parse(url: url)
             XCTAssertEqual(PubkyAuthApprovalSheet.initialState(for: request, isUsdtEnabled: false), disabledState, claim)
             XCTAssertEqual(PubkyAuthApprovalSheet.initialState(for: request, isUsdtEnabled: true), .watchOnlyConsent, claim)
+            var state = disabledState
+            var shareUsdt = false
+            state.updateUsdtAvailability(isEnabled: true, claim: request.bitkitClaim, shareUsdt: &shareUsdt)
+            XCTAssertFalse(shareUsdt, "Enabling USDT must not opt into sharing its address")
+            XCTAssertEqual(state, request.bitkitClaim?.requiresUsdtAddress == true ? .watchOnlyConsent : disabledState, claim)
+            shareUsdt = true
+            state.updateUsdtAvailability(isEnabled: false, claim: request.bitkitClaim, shareUsdt: &shareUsdt)
+            XCTAssertFalse(shareUsdt)
+            XCTAssertEqual(state, disabledState, claim)
+            state.updateUsdtAvailability(isEnabled: true, claim: request.bitkitClaim, shareUsdt: &shareUsdt)
+            XCTAssertFalse(shareUsdt, "Reloading the address must preserve an opt-out")
         }
     }
 
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 712ebf1bc..5c97f8d90 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -23,13 +23,13 @@ final class UsdtWalletManagerTests: XCTestCase {
         defer { settings.usdtPreference = original }
         for preference: UsdtPreference in [.undecided, .disabled] {
             settings.usdtPreference = preference
-            settings.protectUsdtFunds(UsdtPreference.protectsFunds(balance: 0, transfers: []))
+            settings.protectUsdtFunds(UsdtPreference.hasFundsOrPendingTransfers(balance: 0, transfers: []))
             XCTAssertEqual(settings.usdtPreference, preference)
             for (balance, transfers): (UInt64, [UsdtTransfer]) in [
                 (1, []), (0, [transfer("pending", status: .pending)]), (0, [transfer("bridge", status: .bridging)]),
             ] {
                 settings.usdtPreference = preference
-                settings.protectUsdtFunds(UsdtPreference.protectsFunds(balance: balance, transfers: transfers))
+                settings.protectUsdtFunds(UsdtPreference.hasFundsOrPendingTransfers(balance: balance, transfers: transfers))
                 XCTAssertTrue(settings.isUsdtEnabled)
                 XCTAssertTrue(UsdtPreference.isEnabled())
                 settings.protectUsdtFunds(false)
@@ -38,6 +38,20 @@ final class UsdtWalletManagerTests: XCTestCase {
         }
     }
 
+    func testUnknownBalancePreservesDisabledPreferenceWhileKeepingHistoryVisible() {
+        let settings = SettingsViewModel.shared
+        let original = settings.usdtPreference
+        defer { settings.usdtPreference = original }
+        settings.usdtPreference = .disabled
+        let history = [transfer("completed")]
+        XCTAssertTrue(UsdtPreference.protectsFunds(balance: nil, transfers: history))
+        for balance: UInt64? in [nil, 0] {
+            settings.protectUsdtFunds(UsdtPreference.hasFundsOrPendingTransfers(balance: balance, transfers: history))
+            XCTAssertEqual(settings.usdtPreference, .disabled)
+            XCTAssertFalse(PublicPaykitService.isUsdtPaymentOptionEnabled())
+        }
+    }
+
     func testKnownInboundPaymentsProtectTheWalletUntilEachSettles() {
         let manager = UsdtWalletManager(loadCredentials: { throw CancellationError() })
         let settings = SettingsViewModel.shared
@@ -47,7 +61,7 @@ final class UsdtWalletManagerTests: XCTestCase {
         manager.recordDepositStatus(id: "waiting", status: "awaiting_deposit")
         XCTAssertFalse(manager.hasProtectedFunds)
         manager.recordDepositStatus(id: "first", status: "funded")
-        settings.protectUsdtFunds(manager.hasProtectedFunds)
+        settings.protectUsdtFunds(manager.hasFundsOrPendingTransfers)
         XCTAssertTrue(settings.isUsdtEnabled)
         manager.recordDepositStatus(id: "second", status: "refunding")
         manager.recordDepositStatus(id: "first", status: "completed")
diff --git a/Docs/USDT.md b/Docs/USDT.md
index 40f059a42..db43fa020 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -1,6 +1,6 @@
 # USDT configuration
 
-Normal builds use published bitkit-core `0.8.0-rc5`, including its matching native libraries and generated bindings. MAX requires the USDT gateway to allow Core's pinned balance override during gas estimation; it never applies to signing or submission.
+Normal builds use published bitkit-core `0.8.0-rc6`, including its matching native libraries and generated bindings. MAX requires the USDT gateway to allow Core's pinned balance override during gas estimation; it never applies to signing or submission.
 
 USDT uses Arbitrum One regardless of the Bitcoin network setting. Builds use the credential-free Bitkit gateway by default:
 
@@ -29,7 +29,7 @@ USDT starts off. The introductory sheet offers Enable USDT and No Thanks; dismis
 
 When off, USDT is hidden from new payment choices, Paykit offers and authorization details. Combined Bitcoin and USDT authorization continues with Bitcoin and omits the USDT address; a USDT-only authorization is unavailable. Authorization never asks to enable USDT. Automatic clipboard detection ignores USDT addresses and links while retaining Bitcoin and Lightning detection.
 
-Explicitly opening a USDT link or request, or scanning its QR, offers the USDT enable sheet. Enabling resumes the original flow; declining cancels it quietly. Funds or unresolved transfers keep USDT enabled, with the Settings switch on and greyed out. Disabling requires a fresh empty balance and no unresolved transfers or deposits. Tracking, history and encrypted backups continue, including after restore. Previously shared addresses cannot be revoked.
+Explicitly opening a USDT link or request, or scanning its QR, offers the USDT enable sheet. Enabling resumes the original flow; declining cancels it quietly. Funds or unresolved transfers keep USDT enabled, with the Settings switch on and greyed out. Disabling requires a fresh empty balance and no unresolved transfers or deposits. Tracking, history and encrypted backups continue, including after restore. Previously shared addresses cannot be revoked. If a declined wallet has settled history but its balance is unavailable, history remains visible without re-enabling receiving options.
 
 ## Paykit
 
diff --git a/journeys/README.md b/journeys/README.md
index 0569902a8..dbd33d18b 100644
--- a/journeys/README.md
+++ b/journeys/README.md
@@ -212,6 +212,10 @@ authenticated Contacts list. It has not yet been ported to Android.
 actions. Successful dismissal without a toast or duplicate payment is shared behavior, not an
 iOS-only feature.
 
+`usdt-payment-restoration.xml` has the same file name, journey name and actions on both platforms.
+Android restores an unpaid amount draft after process death, while iOS may return to the wallet.
+A submitted payment must return to the wallet without reopening the paid draft on either platform.
+
 `coin-selection/manual-wallet-switch.xml` is shared with Android, with the same file name, journey
 name and actions. iOS can open the picker on the wallet switch; Android opens it on the next swipe.
 The iOS picker has no accessibility identifiers, so assert its visible "Coin Selection" title.
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index 36568131d..fafcdc839 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -3,6 +3,7 @@
   <actions>
     <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify Accept Payment In appears below expiry, with compact outlined Bitcoin and USDT chips. Bitcoin groups all available Savings and Spending methods; no separate rail chips appear here.</action>
+    <action>On a comma-decimal device locale, enter 3,25 USD while creating a payment request. Verify the keypad and amount use the comma and the request review preserves exactly 3,25 USD.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
     <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
     <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
diff --git a/journeys/pubky-auth/share-receiving-details.xml b/journeys/pubky-auth/share-receiving-details.xml
index 3df42864f..12d4f4e2c 100644
--- a/journeys/pubky-auth/share-receiving-details.xml
+++ b/journeys/pubky-auth/share-receiving-details.xml
@@ -18,5 +18,7 @@
     <action>With USDT still off, open x-bitkit-claim=paykit-access-v1.usdt-address-v1. Verify Paykit permissions appear without a receiving-details introduction or USDT content. Go back and verify the request closes without showing a Bitcoin introduction.</action>
     <action>With USDT still off, open x-bitkit-claim=usdt-address-v1. Verify the request is unavailable and authorization cannot be submitted; no enable prompt or successful setup is shown. Cancel and verify Settings still shows USDT off.</action>
     <action>Enable USDT in Settings and reopen the combined request. Verify the optional USDT switch and selected-address privacy disclosure return on the introduction. Turn sharing off and verify Bitcoin approval remains available, then cancel.</action>
+    <action>With an owned wallet restored before its funded USDT balance has loaded, open a combined Bitcoin and USDT authorization. Let the balance refresh finish while the sheet remains open. Verify the optional USDT sharing choice appears off, its address finishes loading and Bitcoin approval remains available. Turn sharing on, then off, and verify it stays off. Cancel before Authorize.</action>
+    <action>Repeat the delayed funded-balance refresh with a USDT-only authorization. Verify receiving-details consent becomes available once the address loads; continue to the permission review and cancel before Authorize.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-opt-in.xml b/journeys/usdt-opt-in.xml
index 001d46def..d5021db8f 100644
--- a/journeys/usdt-opt-in.xml
+++ b/journeys/usdt-opt-in.xml
@@ -7,6 +7,7 @@
     <action>Open Settings, General, Payments. Verify USDT (Tether) (id "UsdtSettingsToggle") is off. Enable it, return Home, and verify the USDT tile appears. Open Receive and verify the USDT tab appears.</action>
     <action>Open USDT Send and its network pill. Verify the USDT Network picker (id "UsdtNetworkPicker") uses rounded rows with Tether icons, a teal selection check, the recipient-network explanation and Tether coin illustration. Choose another supported network and verify the pill updates while retaining its network icon.</action>
     <action>Return to Settings and turn USDT off while the wallet is empty and all transfers are complete. Verify the USDT tile, receive tab and new Paykit receiving option disappear. Existing payment history remains stored.</action>
+    <action>With completed USDT history and a zero balance, disable USDT and relaunch. While the balance loads, history may keep the wallet visible and the Settings switch protected. Verify no new Paykit USDT receiving option is advertised during loading or after the zero balance arrives, and USDT remains off once loading finishes.</action>
     <action>Open an owned USDT payment link while USDT is off. Verify the Enable USDT prompt (id "UsdtEnablePrompt"). Decline and verify USDT stays off, the flow closes quietly, and no payment spinner or failure screen remains. Open the link again, enable USDT (id "UsdtEnablePromptContinue"), and verify the recipient and exact amount continue into the payment flow. Cancel without paying.</action>
     <action>With a funded wallet or an unresolved transfer, open Settings. Verify USDT is visibly on, greyed out and cannot be toggled. Verify the wallet, history and pending payment remain accessible.</action>
     <action>Restore an owned funded wallet whose USDT preference is absent or off. Verify USDT is enabled, its Settings switch is on and greyed out, and Receive opens the USDT tab without an enable prompt. No payment is submitted.</action>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index b477ca434..ca56e83fb 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -4,7 +4,7 @@
     <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open an ethereum: USDT receive link with chain 42161, the pinned Arbitrum token, an owned recipient and uint256=10001. Verify the USDT amount screen preserves the recipient and exact input 0.010001 USDT; the review rounds its displayed value to $0.01. Verify no payment occurs without approval.</action>
     <action>Copy the USDT receive URI, return to Home and accept the clipboard prompt. Verify the USDT amount screen opens with the copied recipient and amount. Cancel without paying. Repeat with a wrong-chain URI and verify no payment prompt appears.</action>
-    <action>Cancel the send, then reopen the identical URI. Verify the amount or review screen opens again. Cancel and open a different owned recipient and amount, verifying only the new values appear.</action>
+    <action>Cancel the send and remain on the USDT wallet without returning Home, then reopen the identical URI. Verify the amount or review screen opens again. Cancel back to the USDT wallet and open a different owned recipient and amount, verifying only the new values appear.</action>
     <action>Close the send sheet, open Settings from the drawer, then go back. Verify the dismissed link does not reopen its Amount screen. Explicitly reopen the same link and verify a new send flow is available, then cancel without paying.</action>
     <action>While a USDT contact amount screen or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
     <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>
diff --git a/journeys/usdt-payment-restoration.xml b/journeys/usdt-payment-restoration.xml
new file mode 100644
index 000000000..ebcfda007
--- /dev/null
+++ b/journeys/usdt-payment-restoration.xml
@@ -0,0 +1,9 @@
+<journey name="usdt payment restoration">
+  <description>Use the local USDT test environment, an onboarded wallet with test funds and another owned wallet's Arbitrum address. Submit only a small local test payment. Background before terminating the app process so saved screen state can be restored. Android restores an unpaid amount draft; iOS may return to the wallet.</description>
+  <actions>
+    <action>Open an owned USDT payment link with an amount, then background, terminate and reopen the app before submitting. On Android, verify the same unpaid amount and recipient remain; on iOS, either the original draft or the wallet is acceptable. No payment occurs automatically.</action>
+    <action>Open the owned link if necessary, review the amount and fee, and submit the local test payment. While Payment submitted or USDT Sent is showing, background, terminate and reopen the app. Verify the wallet opens with no send sheet or prefilled paid amount. Verify the original transfer remains in history and pending tracking continues.</action>
+    <action>Tap Send from the USDT wallet. Verify recipient entry and the amount are empty. Cancel without paying.</action>
+    <action>Reopen the original payment link explicitly. Verify it opens a new send flow with that link's recipient and amount; cancel. Open a link for a different owned recipient and amount and verify only those new values appear. Cancel without paying.</action>
+  </actions>
+</journey>

From dfd9b5690cb022ac5bd9c9676cf39eef2c16950f Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 04:18:30 -0500
Subject: [PATCH 47/62] fix: keep disabled usdt settings available while
 balance loads

---
 Bitkit/Views/Settings/GeneralSettingsView.swift | 5 +++--
 journeys/usdt-opt-in.xml                        | 2 +-
 journeys/usdt-payment-links-and-scans.xml       | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/Bitkit/Views/Settings/GeneralSettingsView.swift b/Bitkit/Views/Settings/GeneralSettingsView.swift
index 05b826066..7b94731f7 100644
--- a/Bitkit/Views/Settings/GeneralSettingsView.swift
+++ b/Bitkit/Views/Settings/GeneralSettingsView.swift
@@ -149,9 +149,10 @@ struct GeneralSettingsView: View {
                         title: t("usdt__settings_title"),
                         iconName: "usdt-settings",
                         rightIcon: nil,
-                        toggle: Binding(get: { settings.isUsdtEnabled || usdt.hasProtectedFunds },
+                        toggle: Binding(get: { settings.isUsdtEnabled || usdt.hasFundsOrPendingTransfers },
                                         set: { enabled in Task { await updateUsdt(enabled) } }),
-                        disabled: isUpdatingUsdt || isCheckingUsdt || usdt.hasProtectedFunds || usdtDisableBlocked,
+                        disabled: isUpdatingUsdt || isCheckingUsdt || usdt.hasFundsOrPendingTransfers ||
+                            (settings.isUsdtEnabled && (usdt.hasProtectedFunds || usdtDisableBlocked)),
                         testIdentifier: "UsdtSettingsToggle"
                     )
                 }
diff --git a/journeys/usdt-opt-in.xml b/journeys/usdt-opt-in.xml
index d5021db8f..e50ddd2a0 100644
--- a/journeys/usdt-opt-in.xml
+++ b/journeys/usdt-opt-in.xml
@@ -7,7 +7,7 @@
     <action>Open Settings, General, Payments. Verify USDT (Tether) (id "UsdtSettingsToggle") is off. Enable it, return Home, and verify the USDT tile appears. Open Receive and verify the USDT tab appears.</action>
     <action>Open USDT Send and its network pill. Verify the USDT Network picker (id "UsdtNetworkPicker") uses rounded rows with Tether icons, a teal selection check, the recipient-network explanation and Tether coin illustration. Choose another supported network and verify the pill updates while retaining its network icon.</action>
     <action>Return to Settings and turn USDT off while the wallet is empty and all transfers are complete. Verify the USDT tile, receive tab and new Paykit receiving option disappear. Existing payment history remains stored.</action>
-    <action>With completed USDT history and a zero balance, disable USDT and relaunch. While the balance loads, history may keep the wallet visible and the Settings switch protected. Verify no new Paykit USDT receiving option is advertised during loading or after the zero balance arrives, and USDT remains off once loading finishes.</action>
+    <action>With completed USDT history and a zero balance, disable USDT and relaunch. While the balance loads or its refresh fails, history may keep the USDT tile visible, but the Settings switch stays off and can be enabled. Verify Receive and optional address sharing still omit USDT. Enable it and verify the switch stays on and cannot be disabled until the zero balance is confirmed.</action>
     <action>Open an owned USDT payment link while USDT is off. Verify the Enable USDT prompt (id "UsdtEnablePrompt"). Decline and verify USDT stays off, the flow closes quietly, and no payment spinner or failure screen remains. Open the link again, enable USDT (id "UsdtEnablePromptContinue"), and verify the recipient and exact amount continue into the payment flow. Cancel without paying.</action>
     <action>With a funded wallet or an unresolved transfer, open Settings. Verify USDT is visibly on, greyed out and cannot be toggled. Verify the wallet, history and pending payment remain accessible.</action>
     <action>Restore an owned funded wallet whose USDT preference is absent or off. Verify USDT is enabled, its Settings switch is on and greyed out, and Receive opens the USDT tab without an enable prompt. No payment is submitted.</action>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index ca56e83fb..faa9db23d 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -6,7 +6,7 @@
     <action>Copy the USDT receive URI, return to Home and accept the clipboard prompt. Verify the USDT amount screen opens with the copied recipient and amount. Cancel without paying. Repeat with a wrong-chain URI and verify no payment prompt appears.</action>
     <action>Cancel the send and remain on the USDT wallet without returning Home, then reopen the identical URI. Verify the amount or review screen opens again. Cancel back to the USDT wallet and open a different owned recipient and amount, verifying only the new values appear.</action>
     <action>Close the send sheet, open Settings from the drawer, then go back. Verify the dismissed link does not reopen its Amount screen. Explicitly reopen the same link and verify a new send flow is available, then cancel without paying.</action>
-    <action>While a USDT contact amount screen or direct-send review is open, open another USDT link. Verify the active recipient, amount and contact are preserved. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
+    <action>While a USDT contact amount screen, contact review or direct-send review is open, open another USDT link, then scan or accept a clipboard prompt for another owned bare USDT address. Verify the active recipient, amount and contact or request are preserved, with no new send flow or invalid-QR error. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
     <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>
     <action>Cancel the send. Open the same link without uint256. Verify the amount screen opens with no amount and accepts a new amount.</action>
     <action>Cancel the send. From the main scanner, paste or import a QR containing the same amount-bearing URI. Verify it opens the USDT send flow with the same recipient and amount.</action>

From e325f9cb8cbaefce0c04604eeda2902334bb9c99 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 07:10:36 -0500
Subject: [PATCH 48/62] fix: preserve request amounts and suppress active send
 prompts

---
 Bitkit/MainNavView.swift                                 | 2 +-
 .../Views/PaymentRequests/CreatePaymentRequestView.swift | 9 ++++++---
 BitkitTests/UsdtDisplayTests.swift                       | 3 ++-
 journeys/paykit-quoted-usdt.xml                          | 2 +-
 journeys/usdt-payment-links-and-scans.xml                | 2 +-
 journeys/usdt-payment-restoration.xml                    | 1 +
 6 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 38e34cc39..dafc27bb5 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -725,7 +725,7 @@ struct MainNavView: View {
                     uri,
                     ownPublicKey: pubkyProfile.publicKey,
                     contacts: contactsManager.contacts,
-                    isUsdtEnabled: settings.isUsdtEnabled
+                    isUsdtEnabled: settings.isUsdtEnabled && !usdt.isSendPresented && app.contactPaymentContext == nil
                 )
             } else {
                 false
diff --git a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
index 7dcf6a3a9..ff434c722 100644
--- a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
+++ b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
@@ -313,6 +313,7 @@ struct PaymentRequestAmountView: View {
     @State private var asset: PaykitAsset = .btc
     @State private var dollarAmount = ""
     @State private var conversionError = false
+    @State private var didLoadAmount = false
 
     private var amount: PaykitAmount? {
         asset == .btc ? PaykitAmount(asset: .btc, atomic: amountViewModel.amountSats) : try? PaykitAmount(asset: .usd, value: dollarAmount)
@@ -364,7 +365,7 @@ struct PaymentRequestAmountView: View {
             }
             NumberPad(
                 type: asset == .usd ? .decimal : amountViewModel.getNumberPadType(currency: currency),
-                decimalSeparator: Locale.current.decimalSeparator ?? ".",
+                decimalSeparator: asset == .usd ? Locale.current.decimalSeparator ?? "." : ".",
                 errorKey: amountViewModel.errorKey
             ) { key in
                 if asset == .usd { dollarAmount = NumberPadInputHandler.handleInput(key: key, current: dollarAmount, maxLength: 16, maxDecimals: 2) }
@@ -387,6 +388,8 @@ struct PaymentRequestAmountView: View {
         .sheetBackground()
         .navigationBarHidden(true)
         .task {
+            guard !didLoadAmount else { return }
+            didLoadAmount = true
             asset = initialDraft.amount.asset == .btc ? .btc : .usd
             if asset == .btc { amountViewModel.updateFromSats(initialDraft.amount.atomic, currency: currency) }
             else { dollarAmount = initialDraft.amount.value }
@@ -479,7 +482,7 @@ struct PaymentRequestDetailsView: View {
                     if initialDraft.amount.asset == .btc {
                         MoneyText(sats: Int(clamping: initialDraft.amount.atomic), unitType: .primary, size: .display,
                                   symbol: true, color: .textPrimary, symbolColor: .textSecondary, fillsWidth: false)
-                    } else { NumberPadAmountText(value: initialDraft.amount.value, symbol: "$") }
+                    } else { NumberPadAmountText(value: usdtInputAmount(initialDraft.amount.value), symbol: "$") }
                     Image("pencil").resizable().frame(width: 24, height: 24).foregroundColor(.textPrimary)
                 }
             }
@@ -557,7 +560,7 @@ struct PaymentRequestDetailsView: View {
                 }
                 Spacer(minLength: 8)
                 if initialDraft.amount.asset == .btc { MoneyCell(sats: Int(clamping: initialDraft.amount.atomic), prefix: "") }
-                else { BodyMSBText("$" + initialDraft.amount.value) }
+                else { BodyMSBText("$" + usdtInputAmount(initialDraft.amount.value)) }
             }
             .padding(16)
             .background(Color.gray6)
diff --git a/BitkitTests/UsdtDisplayTests.swift b/BitkitTests/UsdtDisplayTests.swift
index a3894f01e..14900327c 100644
--- a/BitkitTests/UsdtDisplayTests.swift
+++ b/BitkitTests/UsdtDisplayTests.swift
@@ -15,10 +15,11 @@ final class UsdtDisplayTests: XCTestCase {
     }
 
     func testAmountInputUsesLocaleSeparatorWithoutRoundingTypedPrecision() {
-        for amount in ["0", "0.", "0.000001", "1.230000", "1234567.890000"] {
+        for amount in ["0", "0.", "3.25", "0.000001", "1.230000", "1234567.890000"] {
             XCTAssertEqual(usdtInputAmount(amount, locale: Locale(identifier: "en_US")), amount)
             XCTAssertEqual(usdtInputAmount(amount, locale: Locale(identifier: "de_DE")), amount.replacingOccurrences(of: ".", with: ","))
             XCTAssertEqual(usdtInputAmount(amount, locale: Locale(identifier: "fr_FR")), amount.replacingOccurrences(of: ".", with: ","))
+            XCTAssertEqual(usdtInputAmount(amount, locale: Locale(identifier: "en_BR")), amount.replacingOccurrences(of: ".", with: ","))
         }
     }
 
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index fafcdc839..03d77d42d 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -3,7 +3,7 @@
   <actions>
     <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify Accept Payment In appears below expiry, with compact outlined Bitcoin and USDT chips. Bitcoin groups all available Savings and Spending methods; no separate rail chips appear here.</action>
-    <action>On a comma-decimal device locale, enter 3,25 USD while creating a payment request. Verify the keypad and amount use the comma and the request review preserves exactly 3,25 USD.</action>
+    <action>On a comma-decimal device locale, enter 3,25 USD while creating a payment request. Verify the keypad, entered amount, request review and recipient row all show exactly 3,25 USD. Go back and verify the amount and denomination are preserved. On iOS with Classic Bitcoin display, repeat with a BTC amount and verify the keypad and amount use a dot and returning from review preserves the amount.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
     <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
     <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
diff --git a/journeys/usdt-payment-links-and-scans.xml b/journeys/usdt-payment-links-and-scans.xml
index faa9db23d..85c2151c5 100644
--- a/journeys/usdt-payment-links-and-scans.xml
+++ b/journeys/usdt-payment-links-and-scans.xml
@@ -6,7 +6,7 @@
     <action>Copy the USDT receive URI, return to Home and accept the clipboard prompt. Verify the USDT amount screen opens with the copied recipient and amount. Cancel without paying. Repeat with a wrong-chain URI and verify no payment prompt appears.</action>
     <action>Cancel the send and remain on the USDT wallet without returning Home, then reopen the identical URI. Verify the amount or review screen opens again. Cancel back to the USDT wallet and open a different owned recipient and amount, verifying only the new values appear.</action>
     <action>Close the send sheet, open Settings from the drawer, then go back. Verify the dismissed link does not reopen its Amount screen. Explicitly reopen the same link and verify a new send flow is available, then cancel without paying.</action>
-    <action>While a USDT contact amount screen, contact review or direct-send review is open, open another USDT link, then scan or accept a clipboard prompt for another owned bare USDT address. Verify the active recipient, amount and contact or request are preserved, with no new send flow or invalid-QR error. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
+    <action>While a USDT contact amount screen, contact review or direct-send review is open, copy another owned bare USDT address and verify no automatic clipboard prompt appears. Repeat with a USDT payment URI. Open another USDT link, then scan another owned USDT address. Verify the active recipient, amount and contact or request are preserved, with no new send flow or invalid-QR error. Where PIN is enabled, repeat while its approval screen is visible, then cancel without paying.</action>
     <action>Open USDT from Home, open a USDT link, then open a second link with another owned recipient and amount. Verify the first amount and recipient remain. Cancel without paying.</action>
     <action>Cancel the send. Open the same link without uint256. Verify the amount screen opens with no amount and accepts a new amount.</action>
     <action>Cancel the send. From the main scanner, paste or import a QR containing the same amount-bearing URI. Verify it opens the USDT send flow with the same recipient and amount.</action>
diff --git a/journeys/usdt-payment-restoration.xml b/journeys/usdt-payment-restoration.xml
index ebcfda007..caf3c93aa 100644
--- a/journeys/usdt-payment-restoration.xml
+++ b/journeys/usdt-payment-restoration.xml
@@ -3,6 +3,7 @@
   <actions>
     <action>Open an owned USDT payment link with an amount, then background, terminate and reopen the app before submitting. On Android, verify the same unpaid amount and recipient remain; on iOS, either the original draft or the wallet is acceptable. No payment occurs automatically.</action>
     <action>Open the owned link if necessary, review the amount and fee, and submit the local test payment. While Payment submitted or USDT Sent is showing, background, terminate and reopen the app. Verify the wallet opens with no send sheet or prefilled paid amount. Verify the original transfer remains in history and pending tracking continues.</action>
+    <action>On Android, repeat with a local test payment and change the device font size while submission or the result is visible. Verify the recreated screen still shows the payment progress or result, including its Details action when available. In a separate local payment, background and terminate during submission, then reopen. Verify the wallet opens without an editable send draft and the original operation continues through pending tracking.</action>
     <action>Tap Send from the USDT wallet. Verify recipient entry and the amount are empty. Cancel without paying.</action>
     <action>Reopen the original payment link explicitly. Verify it opens a new send flow with that link's recipient and amount; cancel. Open a link for a different owned recipient and amount and verify only those new values appear. Cancel without paying.</action>
   </actions>

From a8aa07b4786ec33d923cb401cdbc0f5eda76ef30 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 10:09:18 -0500
Subject: [PATCH 49/62] docs: clarify receive behavior after usdt restore

---
 journeys/usdt-opt-in.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/journeys/usdt-opt-in.xml b/journeys/usdt-opt-in.xml
index e50ddd2a0..007c84a4a 100644
--- a/journeys/usdt-opt-in.xml
+++ b/journeys/usdt-opt-in.xml
@@ -10,6 +10,6 @@
     <action>With completed USDT history and a zero balance, disable USDT and relaunch. While the balance loads or its refresh fails, history may keep the USDT tile visible, but the Settings switch stays off and can be enabled. Verify Receive and optional address sharing still omit USDT. Enable it and verify the switch stays on and cannot be disabled until the zero balance is confirmed.</action>
     <action>Open an owned USDT payment link while USDT is off. Verify the Enable USDT prompt (id "UsdtEnablePrompt"). Decline and verify USDT stays off, the flow closes quietly, and no payment spinner or failure screen remains. Open the link again, enable USDT (id "UsdtEnablePromptContinue"), and verify the recipient and exact amount continue into the payment flow. Cancel without paying.</action>
     <action>With a funded wallet or an unresolved transfer, open Settings. Verify USDT is visibly on, greyed out and cannot be toggled. Verify the wallet, history and pending payment remain accessible.</action>
-    <action>Restore an owned funded wallet whose USDT preference is absent or off. Verify USDT is enabled, its Settings switch is on and greyed out, and Receive opens the USDT tab without an enable prompt. No payment is submitted.</action>
+    <action>Restore an owned funded wallet whose USDT preference is absent or off. Verify USDT is enabled and its Settings switch is on and greyed out. Open Receive from Home and verify it keeps the normal default tab (Auto when available, otherwise Savings). Select the available USDT tab and verify its receiving address appears without an enable prompt. No payment is submitted.</action>
   </actions>
 </journey>

From 05b5fa5af57b45e6331660837b7ec85122daaa71 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 11:32:07 -0500
Subject: [PATCH 50/62] fix: preserve payment review and recovery across assets

---
 Bitkit/AppScene.swift                         |  9 +--
 Bitkit/Components/MoneyStack.swift            |  5 ++
 Bitkit/Components/MoneyText.swift             |  3 +
 Bitkit/Components/SwipeButton.swift           |  9 +--
 Bitkit/Extensions/LnurlPayData+Amount.swift   |  5 ++
 Bitkit/Managers/UsdtWalletManager.swift       | 48 +++++++++----
 Bitkit/Models/PaykitUsdt.swift                |  2 +-
 .../PaykitPaymentRequestService.swift         | 23 +++++--
 .../Services/PaykitUsdtPaymentService.swift   | 24 +++----
 .../PrivatePaykitService+Endpoints.swift      |  4 +-
 Bitkit/Services/PublicPaykitService.swift     |  4 +-
 .../PaykitAmountEntryConversion.swift         | 28 ++++++++
 Bitkit/ViewModels/AppViewModel.swift          | 49 +++++++++----
 Bitkit/Views/Home/HomeWalletView.swift        | 27 +++++---
 .../CreatePaymentRequestView.swift            | 40 ++++++++---
 Bitkit/Views/Sheets/UsdtIntroSheet.swift      |  3 +-
 .../CreateSubscriptionView.swift              | 12 ++--
 .../Wallets/Activity/ActivityLatest.swift     |  3 +-
 .../Views/Wallets/Send/LnurlPayConfirm.swift  |  9 ++-
 .../Views/Wallets/Send/SendAmountView.swift   | 41 ++++++-----
 .../Wallets/Send/SendConfirmationView.swift   | 10 ++-
 Bitkit/Views/Wallets/Send/SendSheet.swift     | 16 ++++-
 Bitkit/Views/Wallets/UsdtActivityDetail.swift |  9 ++-
 .../Views/Wallets/UsdtReceiveAmountView.swift | 10 ++-
 Bitkit/Views/Wallets/UsdtSendView.swift       | 36 +++++++---
 BitkitTests/HomeWalletBalanceTests.swift      | 34 ++++++++++
 BitkitTests/LnurlPayConfirmTests.swift        | 31 +++++++++
 .../PaykitAmountEntryConversionTests.swift    | 68 +++++++++++++++++++
 .../PaykitPaymentRequestServiceTests.swift    | 42 +++++++++++-
 .../PaykitPaymentStateBackupTests.swift       | 36 ++++++++++
 BitkitTests/ShopPaymentRequestTests.swift     | 41 ++++++++++-
 BitkitTests/UsdtWalletManagerTests.swift      | 51 ++++++++++++++
 journeys/README.md                            |  4 ++
 journeys/paykit-quoted-usdt.xml               |  7 +-
 journeys/payment-requests/README.md           |  6 +-
 .../payment-requests/fixed-price-bitcoin.xml  | 10 ++-
 journeys/subscriptions/create-and-propose.xml |  4 +-
 37 files changed, 634 insertions(+), 129 deletions(-)
 create mode 100644 Bitkit/Utilities/PaykitAmountEntryConversion.swift
 create mode 100644 BitkitTests/HomeWalletBalanceTests.swift
 create mode 100644 BitkitTests/PaykitAmountEntryConversionTests.swift

diff --git a/Bitkit/AppScene.swift b/Bitkit/AppScene.swift
index 590a68bb3..f6dc042fd 100644
--- a/Bitkit/AppScene.swift
+++ b/Bitkit/AppScene.swift
@@ -402,10 +402,6 @@ struct AppScene: View {
         PaykitFeatureFlags.enforceBuildAvailability()
         ContactPaymentsService.enableAllPaymentOptions()
 
-        _app = StateObject(wrappedValue: AppViewModel(
-            sheetViewModel: sheetViewModel,
-            navigationViewModel: navigationViewModel
-        ))
         _sheets = StateObject(wrappedValue: sheetViewModel)
         _navigation = StateObject(wrappedValue: navigationViewModel)
         let feeEstimatesManager = FeeEstimatesManager()
@@ -414,6 +410,11 @@ struct AppScene: View {
             sheetViewModel: sheetViewModel,
             feeEstimatesManager: feeEstimatesManager
         )
+        _app = StateObject(wrappedValue: AppViewModel(
+            sheetViewModel: sheetViewModel,
+            navigationViewModel: navigationViewModel,
+            usdtBalance: { walletVm.usdtWallet.balance }
+        ))
         _wallet = StateObject(wrappedValue: walletVm)
         _currency = StateObject(wrappedValue: CurrencyViewModel())
         _blocktank = StateObject(wrappedValue: BlocktankViewModel())
diff --git a/Bitkit/Components/MoneyStack.swift b/Bitkit/Components/MoneyStack.swift
index 3c1610bf5..2a8e68f3f 100644
--- a/Bitkit/Components/MoneyStack.swift
+++ b/Bitkit/Components/MoneyStack.swift
@@ -3,6 +3,7 @@ import SwiftUI
 /// MoneyStack - Stacked display with toggle functionality, optional eye icon and swipe gestures
 struct MoneyStack: View {
     let sats: Int
+    var isUnavailable = false
     var prefix: String?
     var showSymbol: Bool = false
     var showEyeIcon: Bool = false
@@ -24,6 +25,7 @@ struct MoneyStack: View {
             if currency.primaryDisplay == .bitcoin {
                 MoneyText(
                     sats: sats,
+                    isUnavailable: isUnavailable,
                     unitType: .secondary,
                     size: .caption,
                     symbol: true,
@@ -43,6 +45,7 @@ struct MoneyStack: View {
                 HStack {
                     MoneyText(
                         sats: sats,
+                        isUnavailable: isUnavailable,
                         unitType: .primary,
                         size: .display,
                         symbol: showSymbol,
@@ -69,6 +72,7 @@ struct MoneyStack: View {
             } else {
                 MoneyText(
                     sats: sats,
+                    isUnavailable: isUnavailable,
                     unitType: .secondary,
                     size: .caption,
                     symbol: true,
@@ -88,6 +92,7 @@ struct MoneyStack: View {
                 HStack {
                     MoneyText(
                         sats: sats,
+                        isUnavailable: isUnavailable,
                         unitType: .primary,
                         size: .display,
                         symbol: true,
diff --git a/Bitkit/Components/MoneyText.swift b/Bitkit/Components/MoneyText.swift
index b96686a48..27da9baa4 100644
--- a/Bitkit/Components/MoneyText.swift
+++ b/Bitkit/Components/MoneyText.swift
@@ -18,6 +18,7 @@ enum MoneyUnitType {
 
 struct MoneyText: View {
     let sats: Int
+    var isUnavailable = false
     var unitType: MoneyUnitType = .primary
     /// When set, overrides user preference so the value is always shown in this unit.
     var forceUnit: PrimaryDisplay?
@@ -141,6 +142,7 @@ extension MoneyText {
         if hideBalance {
             return displayDots
         }
+        if isUnavailable { return "—" }
 
         if let converted = currency.convert(sats: UInt64(abs(sats))) {
             switch unit {
@@ -168,6 +170,7 @@ extension MoneyText {
     }
 
     private var accessibilityValue: String {
+        if !hideBalance, isUnavailable { return "—" }
         guard !hideBalance, let converted = currency.convert(sats: UInt64(abs(sats))) else {
             return prefixed(displayDots)
         }
diff --git a/Bitkit/Components/SwipeButton.swift b/Bitkit/Components/SwipeButton.swift
index 9f9c0ad9a..cb6ee2826 100644
--- a/Bitkit/Components/SwipeButton.swift
+++ b/Bitkit/Components/SwipeButton.swift
@@ -7,6 +7,7 @@ struct SwipeButton: View {
     var isDisabled = false
     /// Blocks interaction and shows the knob spinner while an operation is running.
     var isLoading = false
+    var isSubmitted = false
     var isComplete = false
     /// Optional binding for swipe progress (0...1), e.g. to drive animations in the parent.
     var swipeProgress: Binding<CGFloat>?
@@ -16,15 +17,15 @@ struct SwipeButton: View {
     @State private var isSubmitting = false
 
     private var isBusy: Bool {
-        isDisabled || isLoading || isSubmitting || isComplete
+        isDisabled || isLoading || isSubmitted || isSubmitting || isComplete
     }
 
     private var showsSpinner: Bool {
-        !isComplete && (isLoading || isSubmitting)
+        !isComplete && (isLoading || isSubmitted || isSubmitting)
     }
 
     private var contentOpacity: Double {
-        isDisabled && !isLoading && !isSubmitting && !isComplete ? 0.5 : 1
+        isDisabled && !isLoading && !isSubmitted && !isSubmitting && !isComplete ? 0.5 : 1
     }
 
     private let buttonHeight: CGFloat = 76
@@ -33,7 +34,7 @@ struct SwipeButton: View {
     var body: some View {
         GeometryReader { geometry in
             let maxOffset = max(1, geometry.size.width - buttonHeight)
-            let clampedOffset = isLoading || isComplete ? maxOffset : max(0, min(offset, maxOffset))
+            let clampedOffset = isSubmitted || isComplete ? maxOffset : max(0, min(offset, maxOffset))
             let trailWidth = max(0, min(clampedOffset + (buttonHeight - innerPadding), geometry.size.width - innerPadding))
             let textProgress = clampedOffset / maxOffset
             let halfWidth = geometry.size.width / 2
diff --git a/Bitkit/Extensions/LnurlPayData+Amount.swift b/Bitkit/Extensions/LnurlPayData+Amount.swift
index 9098d85e0..8e7e41465 100644
--- a/Bitkit/Extensions/LnurlPayData+Amount.swift
+++ b/Bitkit/Extensions/LnurlPayData+Amount.swift
@@ -18,6 +18,11 @@ extension LnurlPayData {
         minSendable == maxSendable || (minSendable > 0 && minSendableSat > maxSendableSat)
     }
 
+    func accepts(amountSats: UInt64) -> Bool {
+        if isFixedAmount { return amountSats == minSendableSat }
+        return amountSats >= max(1, minSendableSat) && amountSats <= maxSendableSat
+    }
+
     /// Returns the amount in millisatoshis for the LNURL-pay callback.
     ///
     /// For fixed-amount requests the original msat value is returned verbatim,
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index e9e428eb4..41680d911 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -35,6 +35,8 @@ final class UsdtWalletManager {
     private var activeOperations = 0
     private var initialization: Task<UsdtWallet, Error>?
     private var wipeTask: Task<Void, Error>?
+    private var nextHistoryRefresh = Date.distantPast
+    private var historyRefreshRequested = false
     private var nextRefresh = Date.distantPast
     private var rateLimitedUntil = Date.distantPast
     private var idleWaiter: CheckedContinuation<Void, Never>?
@@ -100,8 +102,11 @@ final class UsdtWalletManager {
     }
 
     func refresh(includeHistory: Bool = false) async {
-        guard isConfigured, !refreshing, !wiping else { return }
-        guard Date() >= max(nextRefresh, rateLimitedUntil) else { return }
+        guard isConfigured, !wiping else { return }
+        historyRefreshRequested = historyRefreshRequested || includeHistory
+        guard !refreshing, Date() >= rateLimitedUntil else { return }
+        let historyDue = historyRefreshRequested && !isSendPresented && Date() >= nextHistoryRefresh
+        guard historyDue || Date() >= nextRefresh else { return }
         var refreshDelay: TimeInterval = 10
         activeOperations += 1
         refreshing = true
@@ -121,7 +126,9 @@ final class UsdtWalletManager {
                 settlementError = error
             }
             try Task.checkCancellation()
-            if includeHistory, !isSendPresented {
+            if historyRefreshRequested, !isSendPresented, Date() >= nextHistoryRefresh {
+                historyRefreshRequested = false
+                nextHistoryRefresh = Date().addingTimeInterval(10)
                 let complete = try await wallet.syncHistory()
                 historyComplete = historyComplete || complete
                 transfers = try await ServiceQueue.background(.core, wrapErrors: false) { try wallet.history() }
@@ -199,19 +206,30 @@ final class UsdtWalletManager {
         return try PaykitUsdt.endpoint(address: wallet.receiveAddress())
     }
 
+    func paymentEndpointForPublishing() async throws -> PublicPaykitService.Endpoint? {
+        do {
+            return try await paymentEndpoint()
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
+            try Task.checkCancellation()
+            Logger.warn("Unable to prepare USDT payment endpoint: \(Self.message(for: error))", context: "UsdtWalletManager")
+            return nil
+        }
+    }
+
     func send(_ quote: UsdtQuote, submissionDeadline: PaykitPreciseInstant? = nil,
               beforeSubmission: @escaping @MainActor () async throws -> Void = {}) async throws
     {
         try beginOperation()
         defer { finishOperation() }
         let wallet = try await wallet()
+        let credentials = try await loadCredentials()
         do {
             let transfer = try await ServiceQueue.background(.core, wrapErrors: false) {
-                guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
-                let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
                 try await beforeSubmission()
                 return try await wallet.sendWithDeadline(
-                    quoteId: quote.id, mnemonic: mnemonic, passphrase: passphrase,
+                    quoteId: quote.id, mnemonic: credentials.0, passphrase: credentials.1,
                     submissionDeadline: submissionDeadline?.timestamp
                 )
             }
@@ -227,9 +245,8 @@ final class UsdtWalletManager {
         try beginOperation()
         defer { finishOperation() }
         let core = try await wallet()
-        guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
-        return try await core.createPaymentProof(transferId: quoteId, binding: binding, mnemonic: mnemonic,
-                                                 passphrase: Keychain.loadString(key: .bip39Passphrase(index: 0)))
+        let credentials = try await loadCredentials()
+        return try await core.createPaymentProof(transferId: quoteId, binding: binding, mnemonic: credentials.0, passphrase: credentials.1)
     }
 
     func storedTransfer(_ id: String) async throws -> UsdtTransfer? {
@@ -331,12 +348,11 @@ final class UsdtWalletManager {
         try beginOperation()
         defer { finishOperation() }
         guard depositsConfigured, let url = Env.usdtDepositsUrl else { throw UsdtError.NotConfigured }
+        let credentials = try await loadCredentials()
         return try await ServiceQueue.background(.core, wrapErrors: false) {
-            guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
-            let passphrase = try Keychain.loadString(key: .bip39Passphrase(index: 0))
-            let owner = try usdtAddress(mnemonic: mnemonic, passphrase: passphrase)
+            let owner = try usdtAddress(mnemonic: credentials.0, passphrase: credentials.1)
             let client = try UsdtDepositClient(address: owner, serviceUrl: url)
-            return try await operation(client, mnemonic, passphrase)
+            return try await operation(client, credentials.0, credentials.1)
         }
     }
 
@@ -470,8 +486,12 @@ extension UsdtDepositNetwork {
 
 extension String {
     var usdCents: String {
+        formattedUsdCents()
+    }
+
+    func formattedUsdCents(locale: Locale = .current) -> String {
         guard let value = UInt64(self) else { return "—" }
-        return "$\((value / 100).formatted()).\(String(format: "%02d", value % 100))"
+        return "$" + (Decimal(value) / 100).formatted(.number.locale(locale).precision(.fractionLength(2)))
     }
 }
 
diff --git a/Bitkit/Models/PaykitUsdt.swift b/Bitkit/Models/PaykitUsdt.swift
index 55a1542de..e4ece1d8a 100644
--- a/Bitkit/Models/PaykitUsdt.swift
+++ b/Bitkit/Models/PaykitUsdt.swift
@@ -19,7 +19,7 @@ enum PaykitUsdt {
     }
 
     static func endpoint(address: String) throws -> PublicPaykitService.Endpoint {
-        let data = try JSONSerialization.data(withJSONObject: ["value": address, "chain_id": chainId, "token": token])
+        let data = try JSONSerialization.data(withJSONObject: ["value": address, "chain_id": chainId, "token": token], options: [.sortedKeys])
         let payload = String(decoding: data, as: UTF8.self)
         guard let address = self.address(from: payload) else { throw PublicPaykitError.invalidPayload }
         return PublicPaykitService.Endpoint(methodId: .usdtArbitrum, value: address, min: nil, max: nil, rawPayload: payload)
diff --git a/Bitkit/Services/PaykitPaymentRequestService.swift b/Bitkit/Services/PaykitPaymentRequestService.swift
index 3c8c622fc..3c55408e6 100644
--- a/Bitkit/Services/PaykitPaymentRequestService.swift
+++ b/Bitkit/Services/PaykitPaymentRequestService.swift
@@ -161,14 +161,25 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
         } else {
             paymentDeadline = nil
         }
-        guard let asset = PaykitAsset(rawValue: terms.amount.asset) else { return .failure(.unsupportedAsset) }
-        guard let amount = try? PaykitAmount(asset: asset, value: terms.amount.value) else { return .failure(.invalidAmount) }
-        guard asset != .btc || amount.atomic <= UInt64.max / 1000 else { return .failure(.amountOutOfRange) }
-
-        let acceptedPaymentEndpointIdentifiers = PaykitIssuerInterop.supportedEndpointIdentifiers(
+        var acceptedPaymentEndpointIdentifiers = PaykitIssuerInterop.supportedEndpointIdentifiers(
             terms.acceptedPaymentEndpointIdentifiers,
             network: network
         )
+        let amount: PaykitAmount
+        var pricing = PaykitRequestPricing(conversion: terms.conversion, deadline: terms.paymentDeadline, quotes: record.conversionQuotes)
+        if let asset = PaykitAsset(rawValue: terms.amount.asset) {
+            guard let parsed = try? PaykitAmount(asset: asset, value: terms.amount.value) else { return .failure(.invalidAmount) }
+            guard asset != .btc || parsed.atomic <= UInt64.max / 1000 else { return .failure(.amountOutOfRange) }
+            amount = parsed
+        } else {
+            let bitcoinEndpoints = acceptedPaymentEndpointIdentifiers.filter { $0.hasPrefix("btc-") }
+            guard let payment = PaykitBitcoinRequestPricing.bitcoinPayment(terms: terms, endpoints: bitcoinEndpoints) else {
+                return .failure(.unsupportedAsset)
+            }
+            amount = PaykitAmount(asset: .btc, atomic: payment.amountSats)
+            acceptedPaymentEndpointIdentifiers = payment.endpointIdentifiers
+            pricing.conversion = nil
+        }
         if requiresActionableRequest, acceptedPaymentEndpointIdentifiers.isEmpty {
             return .failure(.noSupportedEndpoint)
         }
@@ -190,7 +201,7 @@ struct PaykitPaymentRequest: Identifiable, Hashable {
             proposalStreamItemId: record.proposalStreamItemId,
             amount: amount,
             paymentReference: terms.paymentReference.exportText(),
-            pricing: PaykitRequestPricing(conversion: terms.conversion, deadline: terms.paymentDeadline, quotes: record.conversionQuotes),
+            pricing: pricing,
             note: Self.note(from: terms.metadata),
             createdAt: record.lastEventAt.flatMap(Self.parseDate),
             expiresAt: expiresAt,
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
index a4e636cc3..6025655cc 100644
--- a/Bitkit/Services/PaykitUsdtPaymentService.swift
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -79,7 +79,7 @@ final class PaykitUsdtPaymentService {
     private var preparing = false
     private var restoreGeneration = 0
     private(set) var resumableRequests: Set<PaykitPaymentRequest.ID> = []
-    private var unsubmittedAttempts: [Attempt] = []
+    private var releasedAttempts: [Attempt] = []
     private var boundRequestIds: Set<PaykitPaymentRequest.ID>?
 
     private nonisolated(unsafe) static let stateChanged = PassthroughSubject<Void, Never>()
@@ -96,7 +96,7 @@ final class PaykitUsdtPaymentService {
     func restoreBackup(_ backup: PaykitUsdtStateBackup) throws {
         boundRequestIds = nil
         restoreGeneration &+= 1
-        unsubmittedAttempts = []
+        releasedAttempts = []
         resumableRequests = []
         var state = try load()
         for attempt in try backup.attempts.map({ try $0.restored() }) {
@@ -177,8 +177,8 @@ final class PaykitUsdtPaymentService {
     private func publish(_ state: State) {
         attempts = state.attempts.filter { $0.wallet == activeWallet && $0.identity == activeIdentity }
         receipts = state.receipts.filter { $0.wallet == activeWallet && $0.identity == activeIdentity }
-        unsubmittedAttempts.removeAll { !attempts.contains($0) }
-        boundRequestIds = Set(state.attempts.filter { !unsubmittedAttempts.contains($0) }.compactMap(\.requestId))
+        releasedAttempts.removeAll { !attempts.contains($0) }
+        boundRequestIds = Set(state.attempts.filter { !releasedAttempts.contains($0) }.compactMap(\.requestId))
     }
 
     func hasBinding(for requestId: PaykitPaymentRequest.ID) -> Bool {
@@ -321,7 +321,7 @@ final class PaykitUsdtPaymentService {
     func reconcile(wallet: UsdtWalletManager) async {
         guard wallet.isConfigured else {
             boundRequestIds = nil
-            unsubmittedAttempts = []
+            releasedAttempts = []
             resumableRequests = []
             return
         }
@@ -352,7 +352,7 @@ final class PaykitUsdtPaymentService {
         reconciling = true
         defer { reconciling = false }
         boundRequestIds = nil
-        unsubmittedAttempts = []
+        releasedAttempts = []
         resumableRequests = []
         do {
             try Task.checkCancellation()
@@ -362,16 +362,16 @@ final class PaykitUsdtPaymentService {
             let state = try load()
             publish(state)
             var resumable: [Attempt] = []
-            var unsubmitted: [Attempt] = []
+            var released: [Attempt] = []
             for attempt in state.attempts where attempt.wallet == owner && attempt.identity == identity {
                 guard let requestId = attempt.requestId else { continue }
                 do {
                     try Task.checkCancellation()
                     let transfer = try await storedTransfer(attempt.quoteId)
-                    if (transfer == nil && !attempt.paymentStarted) || transfer?.status == .failed || transfer?
-                        .status == .replaced { resumable.append(attempt) }
-                    if transfer == nil, !attempt.paymentStarted, attempt.proof == nil, !attempt.proofQueued {
-                        unsubmitted.append(attempt)
+                    let unexecuted = (transfer == nil && !attempt.paymentStarted) || transfer?.status == .failed || transfer?.status == .replaced
+                    if unexecuted { resumable.append(attempt) }
+                    if unexecuted, attempt.proof == nil, !attempt.proofQueued {
+                        released.append(attempt)
                     }
                     guard !attempt.proofQueued, let binding = attempt.binding else { continue }
                     guard attempt.proof != nil || transfer?.status == .confirmed else { continue }
@@ -412,7 +412,7 @@ final class PaykitUsdtPaymentService {
             guard restoreGeneration == generation, activeWallet == owner, activeIdentity == identity else { return }
             let currentState = try load()
             resumableRequests = Set(resumable.filter { currentState.attempts.contains($0) }.compactMap(\.requestId))
-            unsubmittedAttempts = unsubmitted.filter { currentState.attempts.contains($0) }
+            releasedAttempts = released.filter { currentState.attempts.contains($0) }
             publish(currentState)
             try Task.checkCancellation()
             for record in try await paymentRequests() where record.localRole == .payee {
diff --git a/Bitkit/Services/PrivatePaykitService+Endpoints.swift b/Bitkit/Services/PrivatePaykitService+Endpoints.swift
index 06d1965b9..b5cef6b7c 100644
--- a/Bitkit/Services/PrivatePaykitService+Endpoints.swift
+++ b/Bitkit/Services/PrivatePaykitService+Endpoints.swift
@@ -94,8 +94,8 @@ extension PrivatePaykitService {
             }
         }
 
-        if PublicPaykitService.isUsdtPaymentOptionEnabled() {
-            try await endpoints.append(wallet.usdtWallet.paymentEndpoint())
+        if PublicPaykitService.isUsdtPaymentOptionEnabled(), let endpoint = try await wallet.usdtWallet.paymentEndpointForPublishing() {
+            endpoints.append(endpoint)
         }
 
         guard !endpoints.isEmpty else {
diff --git a/Bitkit/Services/PublicPaykitService.swift b/Bitkit/Services/PublicPaykitService.swift
index 8f3aac182..2175c849b 100644
--- a/Bitkit/Services/PublicPaykitService.swift
+++ b/Bitkit/Services/PublicPaykitService.swift
@@ -569,8 +569,8 @@ enum PublicPaykitService {
             )
         }
 
-        if isUsdtPaymentOptionEnabled() {
-            try await endpoints.append(wallet.usdtWallet.paymentEndpoint())
+        if isUsdtPaymentOptionEnabled(), let endpoint = try await wallet.usdtWallet.paymentEndpointForPublishing() {
+            endpoints.append(endpoint)
         }
 
         guard !endpoints.isEmpty || !requireEndpoint else {
diff --git a/Bitkit/Utilities/PaykitAmountEntryConversion.swift b/Bitkit/Utilities/PaykitAmountEntryConversion.swift
new file mode 100644
index 000000000..685f5ddbf
--- /dev/null
+++ b/Bitkit/Utilities/PaykitAmountEntryConversion.swift
@@ -0,0 +1,28 @@
+import Foundation
+
+struct PaykitAmountEntryConversion {
+    private var source: PaykitAmount?
+    private var result: PaykitAmount?
+
+    mutating func converted(_ amount: PaykitAmount?, to asset: PaykitAsset, rate: PaykitExchangeRate?, at date: Date) throws -> PaykitAmount {
+        guard let amount, amount.atomic > 0 else {
+            reset()
+            return PaykitAmount(asset: asset, atomic: 0)
+        }
+        let source = amount == result ? source ?? amount : amount
+        let converted = try source.converted(to: asset, rate: rate, at: date)
+        self.source = source
+        result = converted
+        return converted
+    }
+
+    mutating func reset() {
+        source = nil
+        result = nil
+    }
+}
+
+func parsePaykitAmountInput(asset: PaykitAsset, value: String) throws -> PaykitAmount {
+    let normalized = value.hasSuffix(".") ? String(value.dropLast()) : value
+    return try PaykitAmount(asset: asset, value: normalized)
+}
diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index 4dc697432..f818f84ac 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -37,10 +37,16 @@ struct ContactPaymentContext: Equatable {
             incomingPaymentRequest.map { $0.amount.asset != .btc || $0.pricing.conversion != nil } == true
     }
 
-    func prefersUsdt(onchainBalanceSats: UInt64, isUsdtEnabled: Bool = true) -> Bool {
+    func prefersUsdt(
+        onchainBalanceSats: UInt64,
+        canSendLightning: Bool = false,
+        usdtBalance: UInt64 = 0,
+        isUsdtEnabled: Bool = true
+    ) -> Bool {
         guard endpoints.contains(where: { $0.methodId == .usdtArbitrum }) else { return false }
         if !endpoints.contains(where: { $0.methodId != .usdtArbitrum }) { return true }
-        return isUsdtEnabled && (incomingPaymentRequest.map { $0.amount.asset != .btc } == true || onchainBalanceSats == 0)
+        return isUsdtEnabled && (incomingPaymentRequest.map { $0.amount.asset != .btc } == true ||
+            (onchainBalanceSats == 0 && !canSendLightning && usdtBalance > 0))
     }
 
     init(
@@ -136,10 +142,9 @@ class AppViewModel: ObservableObject {
     @Published var paykitPaymentTerms: PaykitRequestPricing.Payment?
 
     var fixedLightningAmountSats: UInt64? {
-        guard !paykitUsesUsdt, selectedWalletToPayFrom == .lightning,
-              let amount = scannedLightningInvoice?.amountSatoshis, amount > 0
-        else { return nil }
-        return amount
+        guard !paykitUsesUsdt, selectedWalletToPayFrom == .lightning else { return nil }
+        if let amount = scannedLightningInvoice?.amountSatoshis, amount > 0 { return amount }
+        return lnurlPayData?.isFixedAmount == true ? lnurlPayData?.minSendableSat : nil
     }
 
     // LNURL
@@ -272,6 +277,7 @@ class AppViewModel: ObservableObject {
     private let sheetViewModel: SheetViewModel
     private let navigationViewModel: NavigationViewModel
     private let scanPaymentOperations: ScanPaymentOperations
+    private let usdtBalance: () -> UInt64?
     private var scannedDataHandlingId: UUID?
     private var manualEntryValidationSequence: UInt64 = 0
 
@@ -285,6 +291,7 @@ class AppViewModel: ObservableObject {
         sheetViewModel: SheetViewModel,
         navigationViewModel: NavigationViewModel,
         scanPaymentOperations: ScanPaymentOperations? = nil,
+        usdtBalance: @escaping () -> UInt64? = { nil },
         migrations: MigrationsService = .shared,
         postMigrationSyncOperations: PostMigrationSyncOperations? = nil
     ) {
@@ -295,6 +302,7 @@ class AppViewModel: ObservableObject {
         self.sheetViewModel = sheetViewModel
         self.navigationViewModel = navigationViewModel
         self.scanPaymentOperations = scanPaymentOperations ?? .live(lightningService: lightningService)
+        self.usdtBalance = usdtBalance
 
         setupManualEntryValidationDebounce()
 
@@ -664,7 +672,7 @@ extension AppViewModel {
             }
         }
 
-        if let context = claimedContactPaymentContext, context.requiresAssetSelection {
+        if let context = claimedContactPaymentContext, context.requiresAssetSelection, scope != .onchainPayments {
             resetSendState(preservingContactPaymentContext: true)
             for endpoint in context.endpoints where endpoint.methodId != .usdtArbitrum {
                 switch try await decode(invoice: endpoint.paymentRequest) {
@@ -675,14 +683,31 @@ extension AppViewModel {
                 }
                 try ensureScannedDataHandlingOwnership(handlingId, claimedContactPaymentContext: context)
             }
-            paykitUsesUsdt = context.prefersUsdt(onchainBalanceSats: lightningService.balances?.spendableOnchainBalanceSats ?? 0,
-                                                 isUsdtEnabled: SettingsViewModel.shared.isUsdtEnabled) ||
-                context.incomingPaymentRequest.map { PaykitUsdtPaymentService.shared.hasBinding(for: $0.id) } == true
-            selectedWalletToPayFrom = scannedLightningInvoice != nil || lnurlPayData != nil ? .lightning : .onchain
+            let state = scanPaymentOperations.state()
+            let lightningMethod: PublicPaykitService.MethodId = lnurlPayData == nil ? .bitcoinLightningBolt11 : .bitcoinLightningLnurl
+            let lightningAmount = (try? context.incomingPaymentRequest?.payment(using: lightningMethod).amount.atomic) ??
+                scannedLightningInvoice?.amountSatoshis ?? lnurlPayData?.minSendableSat ?? 0
+            let hasLightning = scannedLightningInvoice != nil || lnurlPayData != nil
+            let canUseLightning = hasLightning && scanPaymentOperations.canSendLightning(max(1, lightningAmount))
+            paykitUsesUsdt = context.prefersUsdt(
+                onchainBalanceSats: max(state.spendableOnchainBalanceSats, alternativeOnchainBalanceSats),
+                canSendLightning: canUseLightning,
+                usdtBalance: usdtBalance() ?? 0,
+                isUsdtEnabled: SettingsViewModel.shared.isUsdtEnabled
+            ) || context.incomingPaymentRequest.map { PaykitUsdtPaymentService.shared.hasBinding(for: $0.id) } == true
+            selectedWalletToPayFrom = canUseLightning || (hasLightning && scannedOnchainInvoice == nil) ? .lightning : .onchain
             return
         }
 
-        let rawUri = uri
+        let rawUri: String
+        if scope == .onchainPayments, let context = claimedContactPaymentContext, !context.endpoints.isEmpty {
+            guard let endpoint = context.endpoints.first(where: { $0.methodId.onchainNetwork != nil }) else {
+                throw ScanHandlingError.unsupportedRequest
+            }
+            rawUri = endpoint.paymentRequest
+        } else {
+            rawUri = uri
+        }
         let sourceURI = rawUri.removingLightningSchemes()
         let uri = PubkyAuthRequest.normalizedProtocolURL(sourceURI)
         if let claimedContactPaymentContext, PubkyAuthRequest.isProtocolURL(sourceURI) {
diff --git a/Bitkit/Views/Home/HomeWalletView.swift b/Bitkit/Views/Home/HomeWalletView.swift
index 7a97c3242..816058c89 100644
--- a/Bitkit/Views/Home/HomeWalletView.swift
+++ b/Bitkit/Views/Home/HomeWalletView.swift
@@ -16,22 +16,33 @@ struct HomeWalletView: View {
     }
 
     var hasActivity: Bool {
-        return activity.latestActivities?.isEmpty == false || (showsUsdt && !usdt.transfers.isEmpty)
+        return activity.latestActivities?.isEmpty == false || !usdt.transfers.isEmpty
     }
 
     /// Headline total including watch-only hardware-wallet balances (keeps `totalBalanceSats`
     /// semantics unchanged for send/transfer logic; only the headline folds hardware in).
-    private var headlineSats: Int {
-        let hw = Int(clamping: hwWalletManager.totalSats)
-        let usdtSats = (showsUsdt ? usdt.balance : nil)
-            .flatMap { usdtDisplaySats(amount: usdtFormatAmount(amount: $0), rate: currency.paykitRate) } ?? 0
-        return wallet.totalBalanceSats.saturatingAdd(hw).saturatingAdd(usdtSats)
+    private var headlineSats: Int? {
+        Self.aggregateBalance(bitcoinSats: wallet.totalBalanceSats, hardwareSats: hwWalletManager.totalSats,
+                              includesUsdt: showsUsdt, usdtBalance: usdt.balance, rate: currency.paykitRate)
+    }
+
+    static func aggregateBalance(bitcoinSats: Int, hardwareSats: UInt64, includesUsdt: Bool, usdtBalance: UInt64?,
+                                 rate: PaykitExchangeRate?, now: Date = Date()) -> Int?
+    {
+        let bitcoin = bitcoinSats.saturatingAdd(Int(clamping: hardwareSats))
+        guard includesUsdt else { return bitcoin }
+        guard let usdtBalance else { return nil }
+        guard usdtBalance > 0 else { return bitcoin }
+        guard let usdtSats = usdtDisplaySats(amount: usdtFormatAmount(amount: usdtBalance), rate: rate, now: now) else { return nil }
+        return bitcoin.saturatingAdd(usdtSats)
     }
 
     var body: some View {
+        let total = headlineSats
         VStack(spacing: 0) {
             MoneyStack(
-                sats: headlineSats,
+                sats: total ?? 0,
+                isUnavailable: total == nil,
                 showSymbol: true,
                 showEyeIcon: true,
                 enableSwipeGesture: settings.swipeBalanceToHide,
@@ -82,7 +93,7 @@ struct HomeWalletView: View {
             }
 
             if hasActivity {
-                ActivityLatest()
+                ActivityLatest(showsUsdtWallet: showsUsdt)
 
                 Spacer()
 
diff --git a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
index ff434c722..823bb2405 100644
--- a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
+++ b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
@@ -308,15 +308,17 @@ struct PaymentRequestAmountView: View {
     let onContinue: (PaykitPaymentRequestDraft) -> Void
     var onBack: (() -> Void)?
     var testIdentifierPrefix = "PaymentRequest"
+    var allowedAssets: [PaykitAsset] = [.btc, .usd]
 
     @State private var amountViewModel = AmountInputViewModel()
     @State private var asset: PaykitAsset = .btc
     @State private var dollarAmount = ""
     @State private var conversionError = false
     @State private var didLoadAmount = false
+    @State private var entryConversion = PaykitAmountEntryConversion()
 
     private var amount: PaykitAmount? {
-        asset == .btc ? PaykitAmount(asset: .btc, atomic: amountViewModel.amountSats) : try? PaykitAmount(asset: .usd, value: dollarAmount)
+        asset == .btc ? PaykitAmount(asset: .btc, atomic: amountViewModel.amountSats) : try? parsePaykitAmountInput(asset: .usd, value: dollarAmount)
     }
 
     var body: some View {
@@ -340,23 +342,30 @@ struct PaymentRequestAmountView: View {
 
             HStack {
                 Spacer()
-                ForEach([PaykitAsset.btc, .usd], id: \.self) { choice in
+                ForEach(allowedAssets, id: \.self) { choice in
                     NumberPadActionButton(text: choice.rawValue.uppercased(), color: choice == .usd ? .usdtAccent : .brandAccent,
                                           variant: asset == choice ? .primary : .secondary)
                     {
                         guard choice != asset else { return }
                         do {
-                            if let current = amount, current.atomic > 0 {
-                                let converted = try current.converted(to: choice, rate: currency.paykitRate, at: Date())
-                                if choice == .usd { dollarAmount = converted.value }
-                                else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
-                            }
+                            let converted = try entryConversion.converted(amount, to: choice, rate: currency.paykitRate, at: Date())
+                            if choice == .usd { dollarAmount = converted.atomic == 0 ? "" : converted.value }
+                            else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
                             asset = choice
                             conversionError = false
                         } catch { conversionError = true }
                     }
                     .accessibilityIdentifier("\(testIdentifierPrefix)Asset-\(choice.rawValue)")
                 }
+                if asset == .btc {
+                    NumberPadActionButton(
+                        text: currency.primaryDisplay == .bitcoin ? "Bitcoin" : currency.selectedCurrency,
+                        imageName: "arrow-up-down", color: .brandAccent
+                    ) {
+                        withAnimation { amountViewModel.togglePrimaryDisplay(currency: currency) }
+                    }
+                    .accessibilityIdentifier("\(testIdentifierPrefix)AmountUnit")
+                }
             }
             .padding(.bottom, 12)
 
@@ -368,12 +377,13 @@ struct PaymentRequestAmountView: View {
                 decimalSeparator: asset == .usd ? Locale.current.decimalSeparator ?? "." : ".",
                 errorKey: amountViewModel.errorKey
             ) { key in
+                entryConversion.reset()
                 if asset == .usd { dollarAmount = NumberPadInputHandler.handleInput(key: key, current: dollarAmount, maxLength: 16, maxDecimals: 2) }
                 else { amountViewModel.handleNumberPadInput(key, currency: currency) }
             }
 
-            CustomButton(title: t("common__continue"), isDisabled: (amount?.atomic ?? 0) == 0) {
-                guard let amount else { return }
+            CustomButton(title: t("common__continue"), isDisabled: !allowedAssets.contains(asset) || (amount?.atomic ?? 0) == 0) {
+                guard allowedAssets.contains(asset), let amount else { return }
                 onContinue(
                     PaykitPaymentRequestDraft(
                         amount: amount, acceptedPaymentEndpointIdentifiers: initialDraft.acceptedPaymentEndpointIdentifiers,
@@ -391,6 +401,10 @@ struct PaymentRequestAmountView: View {
             guard !didLoadAmount else { return }
             didLoadAmount = true
             asset = initialDraft.amount.asset == .btc ? .btc : .usd
+            guard allowedAssets.contains(asset) else {
+                asset = allowedAssets.first ?? .btc
+                return
+            }
             if asset == .btc { amountViewModel.updateFromSats(initialDraft.amount.atomic, currency: currency) }
             else { dollarAmount = initialDraft.amount.value }
         }
@@ -447,7 +461,7 @@ struct PaymentRequestDetailsView: View {
             CustomButton(
                 title: t("wallet__payment_request_send_request"),
                 icon: Image("paper-plane-tilt").resizable().frame(width: 16, height: 16),
-                isDisabled: (restrictedEndpoints ?? enabledEndpoints).isEmpty,
+                isDisabled: selectedEnabledEndpoints.isEmpty,
                 isLoading: paymentRequests.isCreatingRequest
             ) {
                 await sendRequest()
@@ -495,6 +509,10 @@ struct PaymentRequestDetailsView: View {
         PaykitPaymentRequestService.acceptedPaymentEndpointIdentifiers(canReceiveLightning: wallet.hasUsableChannels)
     }
 
+    private var selectedEnabledEndpoints: [String] {
+        enabledEndpoints.filter { restrictedEndpoints?.contains($0) ?? true }
+    }
+
     private var acceptedMethodGroups: [[PublicPaykitService.MethodId]] {
         let groups: [[PublicPaykitService.MethodId]] = [
             PublicPaykitService.MethodId.onchainPreferenceOrder + [.bitcoinLightningBolt11, .bitcoinLightningLnurl],
@@ -510,7 +528,7 @@ struct PaymentRequestDetailsView: View {
                 ForEach(acceptedMethodGroups, id: \.self) { methods in
                     let endpoints = methods.map(\.rawValue)
                     let usdt = methods.contains(.usdtArbitrum)
-                    let selected = restrictedEndpoints ?? enabledEndpoints
+                    let selected = selectedEnabledEndpoints
                     let isSelected = endpoints.contains(where: selected.contains)
                     NumberPadActionButton(text: usdt ? "USDT" : "BITCOIN",
                                           color: isSelected ? (usdt ? .usdtAccent : .brandAccent) : .white32,
diff --git a/Bitkit/Views/Sheets/UsdtIntroSheet.swift b/Bitkit/Views/Sheets/UsdtIntroSheet.swift
index 05ebed152..92e1935be 100644
--- a/Bitkit/Views/Sheets/UsdtIntroSheet.swift
+++ b/Bitkit/Views/Sheets/UsdtIntroSheet.swift
@@ -6,6 +6,7 @@ struct UsdtIntroSheetItem: SheetItem {
 }
 
 struct UsdtIntroSheet: View {
+    @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var sheets: SheetViewModel
     let config: UsdtIntroSheetItem
@@ -13,7 +14,7 @@ struct UsdtIntroSheet: View {
     var body: some View {
         Sheet(id: .usdtIntro, data: config, backgroundColor: .gray7, applyGradient: false) {
             UsdtIntroContent(onDecline: {
-                settings.usdtPreference = .disabled
+                if !usdt.hasProtectedFunds { settings.usdtPreference = .disabled }
                 sheets.hideSheet()
             }, onEnable: {
                 settings.usdtPreference = .enabled
diff --git a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
index ccb919e6e..00bfd9510 100644
--- a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
+++ b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
@@ -12,6 +12,7 @@ struct CreateSubscriptionView: View {
     let onChooseRecipient: () -> Void
 
     @State private var selectedPhotoItem: PhotosPickerItem?
+    @State private var entryConversion = PaykitAmountEntryConversion()
     @FocusState private var isNameFocused: Bool
     @FocusState private var isDescriptionFocused: Bool
 
@@ -101,7 +102,7 @@ struct CreateSubscriptionView: View {
                     )
                     .lineLimit(1)
                     .minimumScaleFactor(0.5)
-                    } else { NumberPadAmountText(value: draft.amount.value, symbol: "$") }
+                    } else { NumberPadAmountText(value: usdtInputAmount(draft.amount.value), symbol: "$") }
                     Image("pencil")
                         .resizable()
                         .frame(width: 24, height: 24)
@@ -133,9 +134,7 @@ struct CreateSubscriptionView: View {
                     ) {
                         guard !isSelected else { return }
                         do {
-                            draft.amount = draft.amount.atomic == 0
-                                ? PaykitAmount(asset: asset, atomic: 0)
-                                : try draft.amount.converted(to: asset, rate: currency.paykitRate, at: Date())
+                            draft.amount = try entryConversion.converted(draft.amount, to: asset, rate: currency.paykitRate, at: Date())
                         } catch {
                             app.toast(type: .error, title: t("common__error"), description: t("wallet__payment_request_rate_unavailable"))
                         }
@@ -235,6 +234,8 @@ struct CreateSubscriptionView: View {
 }
 
 struct SubscriptionAmountView: View {
+    @EnvironmentObject private var settings: SettingsViewModel
+
     let initialAmount: PaykitAmount
     let onBack: () -> Void
     let onContinue: (PaykitAmount) -> Void
@@ -247,7 +248,8 @@ struct SubscriptionAmountView: View {
             onBack: onBack,
             // Android tags this step PaymentRequest* on the subscription flow too; the journeys
             // share the vocabulary, so keep the odd-reading prefix rather than diverging.
-            testIdentifierPrefix: "PaymentRequest"
+            testIdentifierPrefix: "PaymentRequest",
+            allowedAssets: settings.isUsdtEnabled ? [.btc, .usd] : [.btc]
         )
         .accessibilityElement(children: .contain)
         .accessibilityIdentifier("SubscriptionAmount")
diff --git a/Bitkit/Views/Wallets/Activity/ActivityLatest.swift b/Bitkit/Views/Wallets/Activity/ActivityLatest.swift
index be42901f7..9f6b91e16 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityLatest.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityLatest.swift
@@ -2,6 +2,7 @@ import BitkitCore
 import SwiftUI
 
 struct ActivityLatest: View {
+    let showsUsdtWallet: Bool
     @EnvironmentObject private var activity: ActivityListViewModel
     @EnvironmentObject private var app: AppViewModel
     @EnvironmentObject private var feeEstimatesManager: FeeEstimatesManager
@@ -40,7 +41,7 @@ struct ActivityLatest: View {
     private var maxActivityItemsOnHome: Int {
         let slotCapacity = UIScreen.main.isSmall ? ActivityDisplayConstants.maxHomeActivityItems - 1 : ActivityDisplayConstants.maxHomeActivityItems
         var nonItemSlots = 0
-        nonItemSlots += (hwWalletManager.wallets.count + 1) / 2
+        nonItemSlots += (hwWalletManager.wallets.count + (showsUsdtWallet ? 1 : 0) + 1) / 2
         if shouldShowBanner {
             nonItemSlots += 1
         }
diff --git a/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift b/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
index bb3845e26..84c70df11 100644
--- a/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
+++ b/Bitkit/Views/Wallets/Send/LnurlPayConfirm.swift
@@ -166,7 +166,8 @@ struct LnurlPayConfirm: View {
                     ? t("subscriptions__swipe_to_subscribe_and_pay")
                     : t("wallet__send_swipe"),
                 accentColor: .greenAccent,
-                isLoading: hasStartedAutomaticPayment
+                isLoading: hasStartedAutomaticPayment,
+                isSubmitted: hasStartedAutomaticPayment
             ) {
                 try await submitPayment()
             }
@@ -270,7 +271,11 @@ struct LnurlPayConfirm: View {
             throw NSError(domain: "LNURL", code: -1, userInfo: [NSLocalizedDescriptionKey: "Missing LNURL pay data"])
         }
 
-        let amountMsats = lnurlPayData.callbackAmountMsats(userSats: wallet.sendAmountSats)
+        let reviewedAmount = wallet.sendAmountSats ?? lnurlPayData.minSendableSat
+        guard lnurlPayData.accepts(amountSats: reviewedAmount) else {
+            throw PaykitPaymentRequestError.amountMismatch
+        }
+        let amountMsats = lnurlPayData.callbackAmountMsats(userSats: reviewedAmount)
         let contactPaymentContext = app.contactPaymentContext
         let incomingPaymentRequest = contactPaymentContext?.incomingPaymentRequest
         let paymentActivity = PaykitPaymentActivity.shared.begin()
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index b81928ed9..4419f28d8 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -25,6 +25,7 @@ struct SendAmountView: View {
     @State private var routingFee: UInt64 = 0
     @State private var isContinuing = false
     @State private var usdtAmount = ""
+    @State private var amountConversion = PaykitAmountEntryConversion()
     @State private var conversionError: String?
     @State private var showingFundingSources = false
 
@@ -106,10 +107,12 @@ struct SendAmountView: View {
 
     private var isValidAmount: Bool {
         if app.paykitUsesUsdt {
-            return (try? PaykitAmount(asset: .usdt, value: usdtAmount)).map { $0.atomic > 0 && $0.atomic <= (usdt.balance ?? 0) } ?? false
+            return (try? parsePaykitAmountInput(asset: .usdt, value: usdtAmount)).map { $0.atomic > 0 && $0.atomic <= (usdt.balance ?? 0) } ?? false
         }
         let minAmount = app.selectedWalletToPayFrom == .lightning ? 1 : Env.dustLimit
 
+        if app.selectedWalletToPayFrom == .lightning, let data = app.lnurlPayData,
+           !data.accepts(amountSats: amountSats) { return false }
         return amountSats >= minAmount && amountSats <= availableAmount
     }
 
@@ -167,6 +170,7 @@ struct SendAmountView: View {
                         )
                         .onTapGesture {
                             guard canEditAmount else { return }
+                            amountConversion.reset()
                             amountViewModel.updateFromSats(availableAmount, currency: currency)
 
                             if app.selectedWalletToPayFrom == .lightning {
@@ -220,6 +224,7 @@ struct SendAmountView: View {
                     errorKey: amountViewModel.errorKey,
                     isDisabled: !canEditAmount
                 ) { key in
+                    amountConversion.reset()
                     if app.paykitUsesUsdt { usdtAmount = NumberPadInputHandler.handleInput(
                         key: key,
                         current: usdtAmount,
@@ -320,19 +325,23 @@ struct SendAmountView: View {
                 let terms = try request.payment(using: app.paykitPaymentMethod)
                 guard terms.isValid(at: Date()) else { throw PaykitPaymentRequestError.requestExpired }
                 let expected = terms.amount
-                let entered = app.paykitUsesUsdt ? try PaykitAmount(asset: .usdt, value: usdtAmount) : PaykitAmount(asset: .btc, atomic: amountSats)
+                let entered = app.paykitUsesUsdt ? try parsePaykitAmountInput(asset: .usdt, value: usdtAmount) : PaykitAmount(
+                    asset: .btc,
+                    atomic: amountSats
+                )
                 guard expected == entered else { updateRequestAmount(); return }
                 app.paykitPaymentTerms = terms
             }
             if app.contactPaymentContext != nil {
-                app.paykitReviewedAmount = app.paykitUsesUsdt ? try PaykitAmount(asset: .usdt, value: usdtAmount) : PaykitAmount(
+                app.paykitReviewedAmount = app.paykitUsesUsdt ? try parsePaykitAmountInput(asset: .usdt, value: usdtAmount) : PaykitAmount(
                     asset: .btc,
                     atomic: amountSats
                 )
             }
             if app.paykitUsesUsdt {
                 guard let recipient = app.contactPaymentContext?.endpoints.first(where: { $0.methodId == .usdtArbitrum })?.value else { return }
-                navigationPath.append(.usdt(recipient: recipient, amount: usdtAmount))
+                let amount = try parsePaykitAmountInput(asset: .usdt, value: usdtAmount)
+                navigationPath.append(.usdt(recipient: recipient, amount: amount.value))
                 return
             }
             wallet.sendAmountSats = amountSats
@@ -515,22 +524,20 @@ struct SendAmountView: View {
     private func selectFundingSource(_ source: SendFundingSource) {
         guard source != selectedFundingSource, fundingSources.contains(source) else { return }
         let target: PaykitAsset = source == .usdt ? .usdt : .btc
-        let selectsFixedLightning = source == .spending && (app.scannedLightningInvoice?.amountSatoshis ?? 0) > 0
+        let selectsFixedLightning = source == .spending &&
+            ((app.scannedLightningInvoice?.amountSatoshis ?? 0) > 0 || app.lnurlPayData?.isFixedAmount == true)
         if app.contactPaymentContext?.incomingPaymentRequest != nil || (!selectsFixedLightning && app.paykitUsesUsdt != (source == .usdt)) {
             do {
                 let value = app.contactPaymentContext?.incomingPaymentRequest?.amount ??
-                    (app.paykitUsesUsdt ? (try? PaykitAmount(asset: .usdt, value: usdtAmount)) : PaykitAmount(asset: .btc, atomic: amountSats))
-                if let value, value.atomic > 0 {
-                    let converted = try app.contactPaymentContext?.incomingPaymentRequest?
-                        .payment(using: source == .usdt ? .usdtArbitrum : app.paykitBitcoinMethod(for: source == .spending ? .lightning : .onchain))
-                        .amount ?? value.converted(
-                            to: target,
-                            rate: currency.paykitRate,
-                            at: Date()
-                        )
-                    if target == .usdt { usdtAmount = converted.value }
-                    else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
-                }
+                    (app.paykitUsesUsdt ? (try? parsePaykitAmountInput(asset: .usdt, value: usdtAmount)) : PaykitAmount(
+                        asset: .btc,
+                        atomic: amountSats
+                    ))
+                let converted = try app.contactPaymentContext?.incomingPaymentRequest?
+                    .payment(using: source == .usdt ? .usdtArbitrum : app.paykitBitcoinMethod(for: source == .spending ? .lightning : .onchain))
+                    .amount ?? amountConversion.converted(value, to: target, rate: currency.paykitRate, at: Date())
+                if target == .usdt { usdtAmount = converted.atomic == 0 ? "" : converted.value }
+                else { amountViewModel.updateFromSats(converted.atomic, currency: currency) }
             } catch { conversionError = t("wallet__payment_request_rate_unavailable"); return }
         }
         conversionError = nil
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
index 83b02bded..a7084a4b7 100644
--- a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
+++ b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -22,6 +22,7 @@ struct SendConfirmationView: View {
     let prepareIncomingPaymentRequest: () async throws -> Void
     let routingCacheResetAttempted: Bool
     var preparingRequest: PaykitPaymentRequest?
+    var amountIsRoot = false
 
     @State private var showDetails = false
     @State private var showingBiometricError = false
@@ -358,6 +359,7 @@ struct SendConfirmationView: View {
                     feeRateLoadFailed: wallet.feeRateLoadFailed,
                     isPreparingRequest: preparingRequest != nil
                 ),
+                isSubmitted: hasStartedAutomaticPayment,
                 swipeProgress: $swipeProgress
             ) {
                 try await submitPayment()
@@ -746,7 +748,7 @@ struct SendConfirmationView: View {
     private func selectFundingSource(_ source: SendFundingSource) {
         switch source {
         case .usdt:
-            navigationPath = [.amount]
+            navigationPath = amountIsRoot ? [] : [.amount]
         case .spending:
             hwSend.selectWallet(nil)
             app.selectedWalletToPayFrom = .lightning
@@ -1585,7 +1587,7 @@ struct SendConfirmationView: View {
         guard let terms, terms == app.paykitPaymentTerms, terms.isValid(at: Date()) else {
             app.paykitPaymentTerms = nil
             app.paykitReviewedAmount = nil
-            navigationPath = [.amount]
+            navigationPath = amountIsRoot ? [] : [.amount]
             return true
         }
         return false
@@ -1594,7 +1596,9 @@ struct SendConfirmationView: View {
     private func navigateToAmount() {
         guard canEditAmount else { return }
 
-        if let amountIndex = navigationPath.lastIndex(of: .amount) {
+        if amountIsRoot {
+            navigationPath = []
+        } else if let amountIndex = navigationPath.lastIndex(of: .amount) {
             navigationPath = Array(navigationPath.prefix(amountIndex + 1))
         } else {
             if let confirmIndex = navigationPath.lastIndex(of: .confirm) {
diff --git a/Bitkit/Views/Wallets/Send/SendSheet.swift b/Bitkit/Views/Wallets/Send/SendSheet.swift
index f2217fc53..180e229ae 100644
--- a/Bitkit/Views/Wallets/Send/SendSheet.swift
+++ b/Bitkit/Views/Wallets/Send/SendSheet.swift
@@ -573,7 +573,10 @@ struct SendSheet: View {
             // Original signed bytes only; new-payment balance admission does not apply.
             return .ready
         }
-        if app.contactPaymentContext?.endpoints.isEmpty == false { hasValidatedAfterSync = true; return .ready }
+        if app.paykitUsesUsdt || (app.contactPaymentContext?.requiresAssetSelection == true && currentRoot == .amount && navigationPath.isEmpty) {
+            hasValidatedAfterSync = true
+            return .ready
+        }
         let request = app.contactPaymentContext?.incomingPaymentRequest
         let requestedAmount = try? request?.payment(using: app.paykitPaymentMethod, at: Date()).amount.atomic
         if request != nil && requestedAmount == nil {
@@ -846,7 +849,8 @@ struct SendSheet: View {
                 requestPinCheck: requestPinCheck,
                 prepareIncomingPaymentRequest: prepareIncomingPaymentRequest,
                 routingCacheResetAttempted: routingCacheResetAttempted,
-                preparingRequest: isPreparingRequest ? config.preparation?.request : nil
+                preparingRequest: isPreparingRequest ? config.preparation?.request : nil,
+                amountIsRoot: currentRoot == .amount
             )
         case .hardwareSign:
             let contactContext = app.contactPaymentContext
@@ -1270,6 +1274,14 @@ struct SendSheet: View {
             return
         }
 
+        if !context.requiresAssetSelection {
+            do {
+                wallet.sendAmountSats = try request.payment(using: app.paykitPaymentMethod).amount.atomic
+            } catch {
+                showEmbeddedInitialPaymentFailure(request, error: error, context: context)
+                return
+            }
+        }
         pendingEmbeddedRetryRoute = context.requiresAssetSelection ? .amount : app.lnurlPayData == nil ? .confirm : .lnurlPayConfirm
         hasValidatedAfterSync = false
         guard !shouldShowSyncOverlay else { return }
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index 725c8e130..26803d284 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -4,10 +4,12 @@ import SwiftUI
 struct UsdtActivityRow: View {
     let transfer: UsdtTransfer
     let hideBalance: Bool
+    @AppStorage(PaykitFeatureFlags.uiEnabledKey) private var isPaykitUIEnabled = PaykitFeatureFlags.uiEnabledByDefault
     @EnvironmentObject private var contacts: ContactsManager
 
     private var contactName: String? {
-        guard let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) else { return nil }
+        guard PaykitFeatureFlags.isUIAvailable, isPaykitUIEnabled,
+              let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) else { return nil }
         return contacts.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }?.displayName ?? PubkyPublicKeyFormat.displayTruncated(key)
     }
 
@@ -51,6 +53,7 @@ struct UsdtActivityIcon: View {
 
 struct UsdtActivityDetail: View {
     let transferId: String
+    @AppStorage(PaykitFeatureFlags.uiEnabledKey) private var isPaykitUIEnabled = PaykitFeatureFlags.uiEnabledByDefault
     @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var contacts: ContactsManager
@@ -139,13 +142,13 @@ struct UsdtActivityDetail: View {
             UsdtDetailCell(title: t("wallet__activity_payment"), value: displayedAmount(transfer.amount), icon: "user")
             UsdtDetailCell(title: t("wallet__activity_fee"), value: transfer.fee.map(displayedAmount) ?? "—", icon: "speed-normal")
         }
-        if let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) {
+        if PaykitFeatureFlags.isUIAvailable, isPaykitUIEnabled, let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) {
             SendSectionView(t("wallet__payment_request_contact")) {
                 BodySSBText(contacts.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }?.displayName
                     ?? PubkyPublicKeyFormat.displayTruncated(key))
             }
         }
-        if transfer.destination != .arbitrum, transfer.status != .failed, transfer.status != .replaced {
+        if transfer.destination != .arbitrum, ![.failed, .replaced, .bridgeRefunded].contains(transfer.status) {
             SendSectionView(t(transfer.status == .confirmed ? "usdt__recipient_gets" : "usdt__expected_amount")) {
                 amountText(transfer.receivedAmount)
             }
diff --git a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
index 9ec4796d6..1d0e24f36 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveAmountView.swift
@@ -9,7 +9,7 @@ struct UsdtReceiveAmountView: View {
     let onContinue: () async -> Void
 
     private var canContinue: Bool {
-        !busy && (amount.isEmpty ? allowEmpty : (try? PaykitAmount(asset: .usdt, value: amount)) != nil)
+        !busy && (amount.isEmpty ? allowEmpty : (try? parsePaykitAmountInput(asset: .usdt, value: amount)) != nil)
     }
 
     var body: some View {
@@ -32,8 +32,12 @@ struct UsdtReceiveAmountView: View {
                 amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
             }
             .padding(.bottom, 36)
-            CustomButton(title: t("common__continue"), isDisabled: !canContinue, isLoading: busy, action: onContinue)
-                .accessibilityIdentifier("UsdtDepositCreate")
+            CustomButton(title: t("common__continue"), isDisabled: !canContinue, isLoading: busy) {
+                guard canContinue else { return }
+                if let parsed = try? parsePaykitAmountInput(asset: .usdt, value: amount) { amount = parsed.value }
+                await onContinue()
+            }
+            .accessibilityIdentifier("UsdtDepositCreate")
         }
     }
 }
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 4058035a2..312b9cf8c 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -13,6 +13,7 @@ struct UsdtSendView: View {
     var onClose: (() -> Void)?
     @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject private var contactsManager: ContactsManager
+    @EnvironmentObject private var navigation: NavigationViewModel
     @EnvironmentObject private var currency: CurrencyViewModel
     @EnvironmentObject private var settings: SettingsViewModel
     @Environment(\.dismiss) private var dismiss
@@ -24,6 +25,7 @@ struct UsdtSendView: View {
     @State private var destinations = Env.usdtDestinations
     @State private var quote: UsdtQuote?
     @State private var maximumQuote: UsdtQuote?
+    @State private var isMaximumAmount = false
     @State private var preparingMaximum = false
     @State private var editingRecipient = false
     @State private var editingAmount = false
@@ -57,7 +59,7 @@ struct UsdtSendView: View {
         self.onBack = onBack
         self.onClose = onClose
         _recipient = State(initialValue: initialRecipient)
-        _amount = State(initialValue: initialAmount)
+        _amount = State(initialValue: (try? usdtParseAmount(value: initialAmount)) == 0 ? "" : initialAmount)
         _editingAmount = State(initialValue: !initialRecipient.isEmpty)
     }
 
@@ -107,6 +109,11 @@ struct UsdtSendView: View {
         Group {
             if !settings.isUsdtEnabled, !submitted {
                 UsdtIntroContent(isEnablePrompt: true, onDecline: {
+                    if !embedded, !initialRecipient.isEmpty,
+                       navigation.currentRoute == .usdtPayment(recipient: initialRecipient, amount: initialAmount)
+                    {
+                        navigation.navigateBack()
+                    }
                     if let onClose { onClose() } else { dismiss() }
                 }, onEnable: { settings.usdtPreference = .enabled })
             } else if embedded { content }
@@ -120,7 +127,10 @@ struct UsdtSendView: View {
                 do { destinations = try await usdt.sendDestinations() }
                 catch { Logger.warn("Could not load USDT bridge destinations", context: "UsdtSendView") }
             }
-            guard settings.isUsdtEnabled, !initialRecipient.isEmpty, !initialAmount.isEmpty, quote == nil else { return }
+            guard !Task.isCancelled, settings.isUsdtEnabled, !busy, !submitted, quote == nil, maximumQuote == nil,
+                  editingAmount, !showingNetworks,
+                  !initialRecipient.isEmpty, recipient == initialRecipient, amount == initialAmount, destination == .arbitrum,
+                  (try? parsePaykitAmountInput(asset: .usdt, value: amount)) != nil else { return }
             busy = true
             defer { busy = false }
             do { quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination) }
@@ -213,6 +223,8 @@ struct UsdtSendView: View {
                     showingNetworks = false
                     guard destination != item else { return }
                     destination = item
+                    if isMaximumAmount { amount = "" }
+                    isMaximumAmount = false
                     maximumQuote = nil
                     quote = nil
                     error = nil
@@ -299,11 +311,13 @@ struct UsdtSendView: View {
                 type: .decimal,
                 decimalSeparator: Locale.current.decimalSeparator ?? ".",
                 isDisabled: busy || embedded,
-                onDeleteLongPress: { amount = ""; maximumQuote = nil },
+                onDeleteLongPress: { amount = ""; maximumQuote = nil; isMaximumAmount = false },
                 onPress: enterAmount
             )
             .frame(maxHeight: .infinity)
-            CustomButton(title: t("common__continue"), isDisabled: busy || amount.isEmpty, isLoading: busy && !preparingMaximum) {
+            CustomButton(title: t("common__continue"), isDisabled: busy || (try? parsePaykitAmountInput(asset: .usdt, value: amount)) == nil,
+                         isLoading: busy && !preparingMaximum)
+            {
                 guard !busy, quote == nil else { return }
                 busy = true
                 error = nil
@@ -430,7 +444,7 @@ struct UsdtSendView: View {
             }
             SwipeButton(
                 title: t("wallet__send_swipe"), accentColor: .usdtAccent, isDisabled: busy,
-                isLoading: busy, isComplete: paymentComplete, swipeProgress: $swipeProgress
+                isLoading: busy, isSubmitted: submitted, isComplete: paymentComplete, swipeProgress: $swipeProgress
             ) {
                 await confirmPayment()
                 if !submitted { throw CancellationError() }
@@ -517,9 +531,10 @@ struct UsdtSendView: View {
             else { try UsdtPaymentRequest(recipient: usdtValidateRecipient(value: value, destination: destination), amount: nil, chainId: nil) }
             if request.chainId != nil { destination = .arbitrum }
             recipient = request.recipient
-            if let requestedAmount = request.amount { amount = usdtFormatAmount(amount: requestedAmount) }
+            if let requestedAmount = request.amount { amount = requestedAmount == 0 ? "" : usdtFormatAmount(amount: requestedAmount) }
         } catch { self.error = UsdtWalletManager.message(for: error); return }
         maximumQuote = nil
+        isMaximumAmount = false
         recipientFocused = false
         editingAmount = true
         error = nil
@@ -559,6 +574,7 @@ struct UsdtSendView: View {
         do {
             let prepared = try await usdt.quoteMaximum(recipient: recipient, destination: destination)
             maximumQuote = prepared
+            isMaximumAmount = true
             amount = usdtFormatAmount(amount: prepared.amount)
         } catch is CancellationError {
         } catch { self.error = UsdtWalletManager.message(for: error) }
@@ -566,8 +582,11 @@ struct UsdtSendView: View {
 
     private func enterAmount(_ key: String) {
         guard !busy else { return }
+        let updated = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
+        guard updated != amount else { return }
         maximumQuote = nil
-        amount = NumberPadInputHandler.handleInput(key: key, current: amount, maxLength: 21, maxDecimals: 6)
+        isMaximumAmount = false
+        amount = updated
     }
 
     private func confirmPayment() async {
@@ -610,6 +629,7 @@ struct UsdtSendView: View {
         defer { PaykitPaymentActivity.shared.end(paymentActivity) }
         busy = true
         error = nil
+        maximumQuote = nil
         defer { if !submitted { busy = false } }
         do {
             if let sendPayment { try await sendPayment(quote) }
@@ -620,7 +640,7 @@ struct UsdtSendView: View {
             if usdt.transfers.contains(where: { $0.id == quote.id }) {
                 submitted = true
             } else {
-                self.error = UsdtWalletManager.message(for: error)
+                self.error = (error as? LocalizedError)?.errorDescription ?? UsdtWalletManager.message(for: error)
                 self.quote = nil
             }
             Logger.warn("Failed to send USDT: \(UsdtWalletManager.message(for: error))", context: "UsdtSendView")
diff --git a/BitkitTests/HomeWalletBalanceTests.swift b/BitkitTests/HomeWalletBalanceTests.swift
new file mode 100644
index 000000000..9f306542b
--- /dev/null
+++ b/BitkitTests/HomeWalletBalanceTests.swift
@@ -0,0 +1,34 @@
+@testable import Bitkit
+import Foundation
+import XCTest
+
+@MainActor
+final class HomeWalletBalanceTests: XCTestCase {
+    private let now = Date(timeIntervalSince1970: 1_800_000_000)
+    private var rate: PaykitExchangeRate {
+        PaykitExchangeRate(price: "100000", timestamp: now)
+    }
+
+    func testTotalIsUnavailableUntilVisibleUsdtHasABalanceAndFreshRate() {
+        XCTAssertNil(total(balance: nil, rate: rate))
+        XCTAssertNil(total(balance: 1_000_000_000, rate: nil))
+        XCTAssertNil(total(balance: 1_000_000_000, rate: PaykitExchangeRate(price: "100000", timestamp: now.addingTimeInterval(-601))))
+        XCTAssertEqual(total(balance: 1_000_000_000, rate: rate), 1_150_000)
+    }
+
+    func testKnownZeroAndHiddenUsdtDoNotRequireAnExchangeRate() {
+        XCTAssertEqual(total(balance: 0, rate: nil), 150_000)
+        XCTAssertEqual(HomeWalletView.aggregateBalance(bitcoinSats: 100_000, hardwareSats: 50000, includesUsdt: false,
+                                                       usdtBalance: nil, rate: nil, now: now), 150_000)
+    }
+
+    func testLargeCombinedBalanceSaturatesWithoutOverflow() {
+        XCTAssertEqual(HomeWalletView.aggregateBalance(bitcoinSats: Int.max, hardwareSats: UInt64.max, includesUsdt: true,
+                                                       usdtBalance: 1_000_000, rate: rate, now: now), Int.max)
+    }
+
+    private func total(balance: UInt64?, rate: PaykitExchangeRate?) -> Int? {
+        HomeWalletView.aggregateBalance(bitcoinSats: 100_000, hardwareSats: 50000, includesUsdt: true,
+                                        usdtBalance: balance, rate: rate, now: now)
+    }
+}
diff --git a/BitkitTests/LnurlPayConfirmTests.swift b/BitkitTests/LnurlPayConfirmTests.swift
index 75f06b318..12b689ed9 100644
--- a/BitkitTests/LnurlPayConfirmTests.swift
+++ b/BitkitTests/LnurlPayConfirmTests.swift
@@ -5,6 +5,37 @@ import XCTest
 
 @MainActor
 final class LnurlPayConfirmTests: XCTestCase {
+    func testFixedLnurlLocksReviewedAmountAndPreservesMillisatoshis() {
+        let data = LnurlPayData(
+            uri: "https://example.com/pay", callback: "https://example.com/callback",
+            minSendable: 222_222, maxSendable: 222_538,
+            metadataStr: "[]", commentAllowed: nil, allowsNostr: false, nostrPubkey: nil
+        )
+        let app = AppViewModel()
+        app.lnurlPayData = data
+        app.selectedWalletToPayFrom = .lightning
+        XCTAssertEqual(app.fixedLightningAmountSats, 223)
+        XCTAssertTrue(data.accepts(amountSats: 223))
+        XCTAssertFalse(data.accepts(amountSats: 222))
+        XCTAssertFalse(data.accepts(amountSats: 224))
+        XCTAssertEqual(data.callbackAmountMsats(userSats: 223), 222_222)
+        app.selectedWalletToPayFrom = .onchain
+        XCTAssertNil(app.fixedLightningAmountSats)
+    }
+
+    func testVariableLnurlAcceptsOnlyAmountsWithinItsBounds() {
+        let data = LnurlPayData(
+            uri: "https://example.com/pay", callback: "https://example.com/callback",
+            minSendable: 1_000_001, maxSendable: 5_000_999,
+            metadataStr: "[]", commentAllowed: nil, allowsNostr: false, nostrPubkey: nil
+        )
+        XCTAssertFalse(data.accepts(amountSats: 1000))
+        XCTAssertTrue(data.accepts(amountSats: 1001))
+        XCTAssertTrue(data.accepts(amountSats: 5000))
+        XCTAssertFalse(data.accepts(amountSats: 5001))
+        XCTAssertEqual(data.callbackAmountMsats(userSats: 1001), 1_001_000)
+    }
+
     func testResetWhileMountedDoesNotCrashOrPreparePayment() async {
         snapshotAppDefaultsDomain()
         snapshotAppGroupDefaults("home_screen_display_currency_code_v1", "home_screen_display_currency_symbol_v1")
diff --git a/BitkitTests/PaykitAmountEntryConversionTests.swift b/BitkitTests/PaykitAmountEntryConversionTests.swift
new file mode 100644
index 000000000..db7f4ec4c
--- /dev/null
+++ b/BitkitTests/PaykitAmountEntryConversionTests.swift
@@ -0,0 +1,68 @@
+@testable import Bitkit
+import Foundation
+import XCTest
+
+final class PaykitAmountEntryConversionTests: XCTestCase {
+    private let now = Date(timeIntervalSince1970: 1_800_000_000)
+    private var rate: PaykitExchangeRate {
+        PaykitExchangeRate(price: "65432.10", timestamp: now)
+    }
+
+    func testRepeatedTogglesRoundOnlyOnceFromTheEnteredAmount() throws {
+        for original in try [PaykitAmount(asset: .usd, value: "10"), PaykitAmount(asset: .btc, atomic: 12345),
+                             PaykitAmount(asset: .usdt, value: "10.000001")]
+        {
+            var conversion = PaykitAmountEntryConversion()
+            var amount = original
+            let other: PaykitAsset = original.asset == .btc ? .usd : .btc
+            let expected = try original.converted(to: other, rate: rate, at: now)
+            for _ in 0 ..< 8 {
+                amount = try conversion.converted(amount, to: other, rate: rate, at: now)
+                XCTAssertEqual(amount, expected)
+                amount = try conversion.converted(amount, to: original.asset, rate: rate, at: now)
+                XCTAssertEqual(amount, original)
+            }
+        }
+    }
+
+    func testEditsReplaceTheConversionSource() throws {
+        var conversion = PaykitAmountEntryConversion()
+        let original = try PaykitAmount(asset: .usd, value: "10")
+        let bitcoin = try conversion.converted(original, to: .btc, rate: rate, at: now)
+        let edited = PaykitAmount(asset: .btc, atomic: bitcoin.atomic + 100)
+        let dollars = try conversion.converted(edited, to: .usd, rate: rate, at: now)
+        XCTAssertEqual(try conversion.converted(dollars, to: .btc, rate: rate, at: now), edited)
+
+        conversion.reset()
+        let enteredAgain = try conversion.converted(dollars, to: .btc, rate: rate, at: now)
+        XCTAssertEqual(enteredAgain, try dollars.converted(to: .btc, rate: rate, at: now))
+    }
+
+    func testClearedAndZeroInputsCannotReviveAnEarlierAmount() throws {
+        for cleared: PaykitAmount? in [nil, PaykitAmount(asset: .usd, atomic: 0)] {
+            var conversion = PaykitAmountEntryConversion()
+            _ = try conversion.converted(PaykitAmount(asset: .btc, atomic: 50000), to: .usd, rate: rate, at: now)
+            let bitcoin = try conversion.converted(cleared, to: .btc, rate: nil, at: now)
+            XCTAssertEqual(bitcoin.atomic, 0)
+            XCTAssertEqual(try conversion.converted(bitcoin, to: .usd, rate: nil, at: now).atomic, 0)
+        }
+    }
+
+    func testFailedConversionRetainsTheEnteredAmount() throws {
+        var conversion = PaykitAmountEntryConversion()
+        let original = try PaykitAmount(asset: .usd, value: "10")
+        XCTAssertThrowsError(try conversion.converted(original, to: .btc, rate: nil, at: now))
+        let bitcoin = try conversion.converted(original, to: .btc, rate: rate, at: now)
+        XCTAssertEqual(try conversion.converted(bitcoin, to: .usd, rate: rate, at: now), original)
+    }
+
+    func testInputParserAcceptsATrailingDecimalWithoutRelaxingProtocolParsing() throws {
+        for asset in [PaykitAsset.usd, .usdt] {
+            XCTAssertEqual(try parsePaykitAmountInput(asset: asset, value: "5.").value, "5")
+            XCTAssertThrowsError(try PaykitAmount(asset: asset, value: "5."))
+            for invalid in ["", ".", "5..", "0.", "-5.", "5,", "5e1."] {
+                XCTAssertThrowsError(try parsePaykitAmountInput(asset: asset, value: invalid), invalid)
+            }
+        }
+    }
+}
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index de0deecb3..9bedd380c 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -57,6 +57,44 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         }
     }
 
+    func testExternalFixedDenominationRetainsBitcoinCompatibilityAndDeadline() throws {
+        let deadline = "2037-01-15T08:00:00Z"
+        let endpoints = ["btc-regtest-p2wpkh", "btc-lightning-bolt11", "usdt-arbitrum-address"]
+        for asset in ["eur", "gbp"] {
+            let record = try paymentRequestRecord(
+                amount: "10", asset: asset,
+                conversion: .fixed(rates: [.init(asset: "btc", value: "0.000011"), .init(asset: "usdt", value: "2")]),
+                paymentDeadline: .at(timestamp: deadline), endpoints: endpoints
+            )
+            let request = try PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest).get()
+            XCTAssertEqual(request.amount, PaykitAmount(asset: .btc, atomic: 11000))
+            XCTAssertEqual(request.acceptedPaymentEndpointIdentifiers, Array(endpoints.prefix(2)))
+            XCTAssertEqual(try request.payment(using: .bitcoinLightningBolt11).amount.atomic, 11000)
+            XCTAssertEqual(request.paymentDeadline?.timestamp, deadline)
+            XCTAssertNil(request.pricing.conversion)
+            XCTAssertEqual(record.terms?.amount.asset, asset)
+            XCTAssertEqual(record.terms?.amount.value, "10")
+            XCTAssertEqual(record.terms?.conversion, .fixed(rates: [.init(asset: "btc", value: "0.000011"), .init(asset: "usdt", value: "2")]))
+            var history = record
+            history.state = .proofSubmitted
+            XCTAssertEqual(PaykitPaymentRequest(historyRecord: history, now: Date())?.amount, request.amount)
+        }
+    }
+
+    func testExternalDenominationRequiresAConsistentFixedBitcoinQuote() throws {
+        let conversions: [PaymentConversion?] = [
+            nil, .perPeriod, .fixed(rates: [.init(asset: "usdt", value: "1")]),
+            .fixed(rates: [.init(asset: "btc", value: "0.000011"), .init(asset: "btc-lightning", value: "0.000022")]),
+        ]
+        for conversion in conversions {
+            let record = try paymentRequestRecord(amount: "10", asset: "eur", conversion: conversion,
+                                                  endpoints: ["btc-regtest-p2wpkh", "btc-lightning-bolt11", "usdt-arbitrum-address"])
+            guard case .failure = PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest) else {
+                return XCTFail("An external denomination requires a consistent fixed Bitcoin quote")
+            }
+        }
+    }
+
     func testFixedPricingRejectsRequestedAmountsBeyondCurrencyPrecision() throws {
         for amount in ["9.001", "9." + String(repeating: "0", count: 35) + "1"] {
             let record = try paymentRequestRecord(
@@ -4627,7 +4665,9 @@ final class PaykitPaymentRequestServiceTests: XCTestCase {
         let sheets = SheetViewModel()
         let app = AppViewModel(sheetViewModel: sheets, navigationViewModel: NavigationViewModel())
         let wallet = PaymentRequestSendWallet()
-        let context = ContactPaymentContext(publicKey: request.counterparty, incomingPaymentRequest: request)
+        let context = ContactPaymentContext(publicKey: request.counterparty, incomingPaymentRequest: request, endpoints: [
+            .init(methodId: onchainMethod, value: "bcrt1q6rhpng9evdsfnn833a4f4vej0asu6dk5srld6x", min: nil, max: nil, rawPayload: ""),
+        ])
         XCTAssertTrue(app.claimContactPaymentContext(context))
         app.selectedWalletToPayFrom = .lightning
         app.scannedOnchainInvoice = OnChainInvoice(
diff --git a/BitkitTests/PaykitPaymentStateBackupTests.swift b/BitkitTests/PaykitPaymentStateBackupTests.swift
index 3ff9b59b7..338f4c424 100644
--- a/BitkitTests/PaykitPaymentStateBackupTests.swift
+++ b/BitkitTests/PaykitPaymentStateBackupTests.swift
@@ -183,6 +183,42 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         }
     }
 
+    @MainActor
+    func testTerminalUsdtBindingRequiresCurrentUnexecutedEvidenceWithoutProofs() async throws {
+        var attempt = unsubmittedUsdtAttempt()
+        attempt.paymentStarted = true
+        let requestId = try XCTUnwrap(attempt.requestId)
+        for status: UsdtTransferStatus in [.failed, .replaced] {
+            let service = PaykitUsdtPaymentService()
+            try saveUsdtAttempts([attempt])
+            XCTAssertTrue(service.hasBinding(for: requestId))
+            await reconcileUsdt(service) { id in
+                UsdtTransfer(sender: nil, id: id, txHash: nil, userOperationHash: nil, bridgeGuid: nil, orchestra: nil,
+                             recipient: "recipient", destination: .arbitrum, amount: 50000, receivedAmount: 0,
+                             fee: nil, isIncoming: false, status: status, timestamp: 1)
+            }
+            XCTAssertFalse(service.hasBinding(for: requestId))
+            XCTAssertTrue(PaykitUsdtPaymentService().hasBinding(for: requestId))
+            await reconcileUsdt(service)
+            XCTAssertTrue(service.hasBinding(for: requestId))
+            for hasProof in [false, true] {
+                var protected = attempt
+                protected.proofQueued = !hasProof
+                if hasProof {
+                    protected.proof = PaykitUsdtPaymentService.Proof(UsdtPaymentProof(chainId: "42161", transactionHash: "transaction",
+                                                                                      receiptLogIndex: "0", signature: "signature"))
+                }
+                try saveUsdtAttempts([protected])
+                await reconcileUsdt(service) { id in
+                    UsdtTransfer(sender: nil, id: id, txHash: nil, userOperationHash: nil, bridgeGuid: nil, orchestra: nil,
+                                 recipient: "recipient", destination: .arbitrum, amount: 50000, receivedAmount: 0,
+                                 fee: nil, isIncoming: false, status: status, timestamp: 1)
+                }
+                XCTAssertTrue(service.hasBinding(for: requestId))
+            }
+        }
+    }
+
     @MainActor
     func testReconciliationInvalidatesReleaseEvidenceForChangedOrUnreadablePersistence() async throws {
         let service = PaykitUsdtPaymentService()
diff --git a/BitkitTests/ShopPaymentRequestTests.swift b/BitkitTests/ShopPaymentRequestTests.swift
index b0f7034df..9dc987c20 100644
--- a/BitkitTests/ShopPaymentRequestTests.swift
+++ b/BitkitTests/ShopPaymentRequestTests.swift
@@ -180,12 +180,51 @@ final class ShopPaymentRequestTests: XCTestCase {
         let btcOnly = ContactPaymentContext(publicKey: "contact", endpoints: [bitcoin])
         XCTAssertTrue(usdtOnly.prefersUsdt(onchainBalanceSats: 100_000))
         XCTAssertFalse(both.prefersUsdt(onchainBalanceSats: 100_000))
-        XCTAssertTrue(both.prefersUsdt(onchainBalanceSats: 0))
+        XCTAssertTrue(both.prefersUsdt(onchainBalanceSats: 0, usdtBalance: 1_000_000))
+        XCTAssertFalse(both.prefersUsdt(onchainBalanceSats: 0))
+        XCTAssertFalse(both.prefersUsdt(onchainBalanceSats: 0, canSendLightning: true, usdtBalance: 1_000_000))
         XCTAssertFalse(btcOnly.prefersUsdt(onchainBalanceSats: 0))
         XCTAssertFalse(both.prefersUsdt(onchainBalanceSats: 0, isUsdtEnabled: false))
         XCTAssertTrue(usdtOnly.prefersUsdt(onchainBalanceSats: 0, isUsdtEnabled: false))
     }
 
+    func testHardwareContactScanKeepsTheBitcoinEndpointWhenUsdtIsFirst() async throws {
+        let address = "bcrt1q6rhpng9evdsfnn833a4f4vej0asu6dk5srld6x"
+        let usdt = try PaykitUsdt.endpoint(address: "0x4cdDcC65AF3Aa77803d1A99A030eb17751AC7780")
+        let bitcoin = PublicPaykitService.Endpoint(
+            methodId: .regtestOnchainP2wpkh, value: address, min: nil, max: nil, rawPayload: address
+        )
+        let app = AppViewModel(
+            sheetViewModel: SheetViewModel(), navigationViewModel: NavigationViewModel(),
+            scanPaymentOperations: ScanPaymentOperations(
+                state: { ScanPaymentState(isNodeRunning: true, spendableOnchainBalanceSats: 0,
+                                          totalLightningBalanceSats: 0, hasChannels: false, hasUsableChannels: false) },
+                canSendLightning: { _ in false }
+            ), usdtBalance: { 1_000_000 }
+        )
+        let context = ContactPaymentContext(publicKey: "contact", endpoints: [usdt, bitcoin])
+        XCTAssertTrue(app.claimContactPaymentContext(context))
+        try await app.handleScannedData(usdt.paymentRequest, claimedContactPaymentContext: context,
+                                        scope: .onchainPayments, alternativeOnchainBalanceSats: 100_000)
+        XCTAssertEqual(app.scannedOnchainInvoice?.address, address)
+        XCTAssertFalse(app.paykitUsesUsdt)
+        XCTAssertEqual(app.selectedWalletToPayFrom, .onchain)
+        XCTAssertFalse(app.didRejectScannedPayment)
+    }
+
+    func testHardwareContactScanRejectsUsdtOnlyEndpoints() async throws {
+        let endpoint = try PaykitUsdt.endpoint(address: "0x4cdDcC65AF3Aa77803d1A99A030eb17751AC7780")
+        let app = AppViewModel()
+        let context = ContactPaymentContext(publicKey: "contact", endpoints: [endpoint])
+        XCTAssertTrue(app.claimContactPaymentContext(context))
+        do {
+            try await app.handleScannedData(endpoint.paymentRequest, claimedContactPaymentContext: context, scope: .onchainPayments)
+            XCTFail("Hardware scope must not select a software USDT wallet")
+        } catch ScanHandlingError.unsupportedRequest {}
+        XCTAssertFalse(app.paykitUsesUsdt)
+        XCTAssertNil(app.scannedOnchainInvoice)
+    }
+
     func testUsdtContactPaymentCanBePreparedAndCleared() async throws {
         let app = AppViewModel()
         let endpoint = try PaykitUsdt.endpoint(address: "0x4cdDcC65AF3Aa77803d1A99A030eb17751AC7780")
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 5c97f8d90..a4a8776c7 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -4,6 +4,57 @@ import XCTest
 
 @MainActor
 final class UsdtWalletManagerTests: XCTestCase {
+    func testEndpointPublicationOmitsUnavailableUsdtAndPropagatesCancellation() async throws {
+        try XCTSkipUnless(Env.isUsdtEnabled)
+        let unavailable = UsdtWalletManager(loadCredentials: { throw UsdtError.InvalidCredentials })
+        let endpoint = try await unavailable.paymentEndpointForPublishing()
+        XCTAssertNil(endpoint)
+        let cancelled = UsdtWalletManager(loadCredentials: { throw CancellationError() })
+        do {
+            _ = try await cancelled.paymentEndpointForPublishing()
+            XCTFail("Cancelled endpoint publication must stop")
+        } catch is CancellationError {}
+    }
+
+    func testHistoryRequestDuringRefreshSurvivesTheBalanceThrottle() async throws {
+        try XCTSkipUnless(Env.isUsdtEnabled)
+        let entered = expectation(description: "refresh started")
+        let gate = AsyncStream<Void>.makeStream()
+        defer { gate.continuation.finish() }
+        var attempts = 0
+        let manager = UsdtWalletManager(loadCredentials: {
+            attempts += 1
+            if attempts == 1 {
+                entered.fulfill()
+                for await _ in gate.stream {
+                    break
+                }
+            }
+            throw UsdtError.InvalidCredentials
+        })
+        let refresh = Task { await manager.refresh() }
+        await fulfillment(of: [entered], timeout: 2)
+        await manager.refresh(includeHistory: true)
+        gate.continuation.yield(())
+        await refresh.value
+        await manager.refresh()
+        XCTAssertEqual(attempts, 2)
+    }
+
+    func testUsdCentsUseTheLocalesDecimalAndGroupingSeparators() {
+        XCTAssertEqual("1000000".formattedUsdCents(locale: Locale(identifier: "en_US")), "$10,000.00")
+        XCTAssertEqual("1000000".formattedUsdCents(locale: Locale(identifier: "de_DE")), "$10.000,00")
+        XCTAssertEqual("5".formattedUsdCents(locale: Locale(identifier: "de_DE")), "$0,05")
+        XCTAssertEqual("invalid".formattedUsdCents(locale: Locale(identifier: "en_US")), "—")
+    }
+
+    func testUsdtEndpointPayloadUsesCanonicalKeyOrder() throws {
+        let address = "0x18503bD685aF84E6A7bC289898bAa1C3f5d8527E"
+        let endpoint = try PaykitUsdt.endpoint(address: address)
+        XCTAssertEqual(endpoint.rawPayload, "{\"chain_id\":\"42161\",\"token\":\"\(PaykitUsdt.token)\",\"value\":\"\(address)\"}")
+        XCTAssertEqual(PaykitUsdt.address(from: endpoint.rawPayload), address)
+    }
+
     func testChangingUsdtPreferencePublishesForOpenPaymentAndAuthorizationViews() {
         let settings = SettingsViewModel.shared
         let original = settings.usdtPreference
diff --git a/journeys/README.md b/journeys/README.md
index dbd33d18b..8107a9382 100644
--- a/journeys/README.md
+++ b/journeys/README.md
@@ -76,6 +76,8 @@ what the journeys assert on, and it avoids the image-size limits the Android run
 
 ## Backend preconditions
 
+In a build with USDT configured, resolve the introductory USDT sheet by enabling or declining it before starting an unrelated journey. The choice persists; a fresh undecided wallet can show the sheet after Home appears. USDT journeys state whether they require opt-in.
+
 Most journeys need regtest and a reachable LSP. Start the stack from a sibling `bitkit-docker`
 checkout on `main` (same stack `Docs/AI_DEVICE_TESTS.md` uses):
 
@@ -164,6 +166,8 @@ journey PR, which is what made this file conflict on every merge.
 
 | Capability | Provided by |
 | --- | --- |
+| USDT wallet navigation without funding | an onboarded build with USDT configured; provider errors may remain visible while offline — [USDT QA](../Docs/USDT-QA.md) |
+| Controlled USDT quotes, provider history, funded submission and recovery | an explicitly configured local USDT gateway/RPC/bundler fixture with owned test accounts and funds; absent from the standard journey environment. Report these steps as blocked unless that setup and transfer authorization are supplied — [USDT QA](../Docs/USDT-QA.md) |
 | On-chain funds and blocks on regtest | `../bitkit-android/lsp` deposit and mine, borrowed from the sibling Android checkout until #694 lands an iOS copy — [Backend preconditions](#backend-preconditions) |
 | Lightning channels, CJIT orders and quoted maxima | the LSP the `E2E_BUILD` app targets, plus its node as an external LN peer — [Backend preconditions](#backend-preconditions), [amount-limits](amount-limits/README.md) |
 | A hardware wallet to pair, watch and sign with | the deterministic Trezor emulator from `bitkit-docker`, reached through Trezor Bridge on the host; the simulator has no Bluetooth LE and iOS cannot do WebUSB, so BLE pairing and USB are not covered — [hardware-wallet](hardware-wallet/README.md) |
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index 03d77d42d..a5af16dbd 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -4,12 +4,17 @@
     <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify Accept Payment In appears below expiry, with compact outlined Bitcoin and USDT chips. Bitcoin groups all available Savings and Spending methods; no separate rail chips appear here.</action>
     <action>On a comma-decimal device locale, enter 3,25 USD while creating a payment request. Verify the keypad, entered amount, request review and recipient row all show exactly 3,25 USD. Go back and verify the amount and denomination are preserved. On iOS with Classic Bitcoin display, repeat with a BTC amount and verify the keypad and amount use a dot and returning from review preserves the amount.</action>
+    <action>Return to the request amount editor, select USD and replace the amount with 10. Switch to BTC and back to USD four times without editing.</action>
+    <action>Verify the USD amount is still exactly 10 and each return to BTC shows the same satoshi amount.</action>
+    <action>Clear the USD input, then select BTC. Verify the amount is zero and Continue is disabled.</action>
+    <action>Select USD and enter 5 followed by the decimal separator without a fractional digit. Verify Continue is enabled. Continue and verify the request review shows exactly 5 USD.</action>
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
     <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
     <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
     <action>Create a USD subscription. Verify Accepted Payments appears below frequency, with USDT selected and Bitcoin unselected. Verify the description and icon controls are side by side. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method. Verify the subscription swipe uses USDT teal, then close before subscribing.</action>
-    <action>Create a BTC subscription and verify Bitcoin is selected. Tap SubscriptionAccept-usdt; verify the amount converts to USD and only USDT is selected. Tap SubscriptionAccept-bitcoin; verify the amount converts to BTC and only Bitcoin is selected, covering the enabled Savings and Spending methods. Close without proposing.</action>
+    <action>Create a BTC subscription for 12,345 sats and verify Bitcoin is selected. Tap SubscriptionAccept-usdt; verify the amount converts to USD and only USDT is selected. Tap SubscriptionAccept-bitcoin; verify the amount returns to exactly 12,345 sats and only Bitcoin is selected, covering the enabled Savings and Spending methods.</action>
+    <action>Repeat the subscription USDT and Bitcoin switches four times without editing. Verify every return to Bitcoin shows exactly 12,345 sats. Edit the amount to 10 USD, repeat the switches and verify every return to USDT shows exactly 10 USD. Close without proposing.</action>
     <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01, then close without continuing to review.</action>
   </actions>
 </journey>
diff --git a/journeys/payment-requests/README.md b/journeys/payment-requests/README.md
index 9982f508c..0ebcb2f0e 100644
--- a/journeys/payment-requests/README.md
+++ b/journeys/payment-requests/README.md
@@ -9,8 +9,10 @@ The resolution-failure journey is ported alongside Android's matching `requested
 ## Issuer interoperability
 
 `fixed-price-bitcoin.xml` verifies a USD-denominated request settled in BTC and an explicit
-same-asset rail price. The confirmation amount uses the issuer's fixed rate; the displayed fiat
-estimate uses Bitkit's own market rate. The flow stops before broadcasting. Differing rail prices,
+same-asset rail price. After preparation, the Amount screen shows the fixed, uneditable payment
+amount with Savings selected. Continue opens confirmation with the same amount. The amount uses
+the issuer's fixed rate; the displayed fiat estimate uses Bitkit's own market rate. The flow stops
+before broadcasting. Differing rail prices,
 fractional-satoshi Lightning payments, and dynamic quotes remain unsupported.
 
 ### Setup
diff --git a/journeys/payment-requests/fixed-price-bitcoin.xml b/journeys/payment-requests/fixed-price-bitcoin.xml
index aa6af658b..138c2a1ca 100644
--- a/journeys/payment-requests/fixed-price-bitcoin.xml
+++ b/journeys/payment-requests/fixed-price-bitcoin.xml
@@ -6,12 +6,18 @@
     <action>Launch the E2E Bitkit app with Paykit UI enabled and the fixture issuer saved as a contact and linked as identities</action>
     <action>Have the issuer publish a current regtest P2WPKH address under identifier "btc-regtest-p2wpkh" with JSON payload {"value":"&lt;current address&gt;"}</action>
     <action>Have the issuer send a new one-time request for amount "10", asset "usd", accepted identifier "btc-regtest-p2wpkh", and fixed conversion rate "btc" equal to "0.000021"</action>
-    <action>Verify the Payment Request confirmation screen (id "PaymentRequestConfirm") shows 21,000 sats, not 10 BTC</action>
+    <action>Wait for request preparation to finish and the Amount screen to open with Savings selected</action>
+    <action>Switch the amount display to Bitcoin if needed</action>
+    <action>Verify the requested amount is 21,000 sats, cannot be edited, and does not show 10 BTC</action>
+    <action>Tap Continue and verify the Payment Request confirmation screen (id "PaymentRequestConfirm") shows 21,000 sats</action>
     <action>Wait for fresh validation and wallet preparation to finish; verify the same sheet stays open and its payment swipe control (id "GRAB") stops showing progress</action>
     <action>Verify the fiat estimate equals Bitkit's current local valuation of 21,000 sats, rather than being forced to the issuer's 10 USD denomination</action>
     <action>Dismiss the Payment Request confirmation screen without paying</action>
     <action>Have the issuer send a new one-time request for amount "0.001", asset "btc", accepted identifier "btc-regtest-p2wpkh", and fixed rates "btc" equal to "2" and "btc-regtest" equal to "0.5"</action>
-    <action>Verify the Payment Request confirmation screen (id "PaymentRequestConfirm") shows 50,000 sats, not 100,000 or 200,000 sats</action>
+    <action>Wait for request preparation to finish and the Amount screen to open with Savings selected</action>
+    <action>Switch the amount display to Bitcoin if needed</action>
+    <action>Verify the requested amount is 50,000 sats, cannot be edited, and does not show 100,000 or 200,000 sats</action>
+    <action>Tap Continue and verify the Payment Request confirmation screen (id "PaymentRequestConfirm") still shows 50,000 sats</action>
     <action>Dismiss the Payment Request confirmation screen without paying</action>
   </actions>
 </journey>
diff --git a/journeys/subscriptions/create-and-propose.xml b/journeys/subscriptions/create-and-propose.xml
index 25d89c4a3..c0e647c3d 100644
--- a/journeys/subscriptions/create-and-propose.xml
+++ b/journeys/subscriptions/create-and-propose.xml
@@ -13,11 +13,13 @@
   </description>
   <actions>
     <action>Launch the E2E Bitkit app with Paykit UI enabled and the payer instance saved as a contact linked as identities</action>
+    <action>With no USDT funds or pending transfers, decline the USDT introduction or disable USDT in Settings, General, Payments</action>
     <action>Open the drawer menu and tap Subscriptions</action>
     <action>Verify the Subscriptions screen (id "SubscriptionsScreen") appears with the Overview tab (id "Tab-overview") selected</action>
     <action>Tap Create (id "SubscriptionCreate")</action>
     <action>Verify the create sheet (id "CreateSubscription") appears with Choose Recipient disabled</action>
-    <action>Tap the amount pencil (id "SubscriptionEditAmount"), enter "5000" on the keypad, and tap Continue (id "PaymentRequestAmountContinue")</action>
+    <action>Tap the amount pencil (id "SubscriptionEditAmount") and verify USD is not offered while USDT is disabled</action>
+    <action>Tap the Bitcoin/fiat unit control (id "PaymentRequestAmountUnit") twice and verify both input units remain available for the BTC denomination. Select Bitcoin units, enter "5000" on the keypad, and tap Continue (id "PaymentRequestAmountContinue")</action>
     <action>Verify the amount reads 5,000 sats and the accepted methods show only enabled Savings or Spending options, with no USDT</action>
     <action>Type "Journey Sub" into the subscription name field (id "SubscriptionName")</action>
     <action>Enter 600 ASCII letters in the description field (id "SubscriptionDescription")</action>

From 997852b5fec5b855135da2c2f51df157057e4351 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 12:25:48 -0500
Subject: [PATCH 51/62] fix: format usd request amounts for the device locale

---
 Bitkit/Components/PaykitAmountText.swift              | 10 +++++++++-
 Bitkit/Styles/SheetStyles.swift                       |  4 ++--
 .../PaymentRequests/CreatePaymentRequestView.swift    |  4 ++--
 .../Views/Subscriptions/CreateSubscriptionView.swift  |  2 +-
 BitkitTests/PaykitAmountTests.swift                   | 11 +++++++++++
 journeys/paykit-quoted-usdt.xml                       | 10 +++++-----
 6 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/Bitkit/Components/PaykitAmountText.swift b/Bitkit/Components/PaykitAmountText.swift
index d50e43ab7..9cea146b9 100644
--- a/Bitkit/Components/PaykitAmountText.swift
+++ b/Bitkit/Components/PaykitAmountText.swift
@@ -7,7 +7,11 @@ struct PaykitAmountText: View {
     var color: Color = .textPrimary
 
     private var displayValue: String {
-        amount.asset == .usdt ? usdtOverviewAmount(amount.atomic) : amount.value
+        switch amount.asset {
+        case .usd: usdDisplayAmount(amount.atomic)
+        case .usdt: usdtOverviewAmount(amount.atomic)
+        case .btc: amount.value
+        }
     }
 
     var body: some View {
@@ -21,3 +25,7 @@ struct PaykitAmountText: View {
         }
     }
 }
+
+func usdDisplayAmount(_ cents: UInt64, locale: Locale = .current) -> String {
+    (Decimal(cents) / 100).formatted(.number.precision(.fractionLength(2)).locale(locale))
+}
diff --git a/Bitkit/Styles/SheetStyles.swift b/Bitkit/Styles/SheetStyles.swift
index 543a10697..26277f169 100644
--- a/Bitkit/Styles/SheetStyles.swift
+++ b/Bitkit/Styles/SheetStyles.swift
@@ -29,14 +29,14 @@ struct SheetBackgroundModifier: ViewModifier {
 
     func body(content: Content) -> some View {
         content
-            .background(
+            .background {
                 LinearGradient(
                     gradient: Gradient(colors: [Color.white.opacity(0.08), Color.white.opacity(0.012)]),
                     startPoint: .top,
                     endPoint: .bottom
                 )
                 .opacity(applyGradient ? 1 : 0)
-            )
+            }
             .background(base)
     }
 }
diff --git a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
index 823bb2405..b3c7aab71 100644
--- a/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
+++ b/Bitkit/Views/PaymentRequests/CreatePaymentRequestView.swift
@@ -496,7 +496,7 @@ struct PaymentRequestDetailsView: View {
                     if initialDraft.amount.asset == .btc {
                         MoneyText(sats: Int(clamping: initialDraft.amount.atomic), unitType: .primary, size: .display,
                                   symbol: true, color: .textPrimary, symbolColor: .textSecondary, fillsWidth: false)
-                    } else { NumberPadAmountText(value: usdtInputAmount(initialDraft.amount.value), symbol: "$") }
+                    } else { PaykitAmountText(amount: initialDraft.amount, size: .display) }
                     Image("pencil").resizable().frame(width: 24, height: 24).foregroundColor(.textPrimary)
                 }
             }
@@ -578,7 +578,7 @@ struct PaymentRequestDetailsView: View {
                 }
                 Spacer(minLength: 8)
                 if initialDraft.amount.asset == .btc { MoneyCell(sats: Int(clamping: initialDraft.amount.atomic), prefix: "") }
-                else { BodyMSBText("$" + usdtInputAmount(initialDraft.amount.value)) }
+                else { PaykitAmountText(amount: initialDraft.amount) }
             }
             .padding(16)
             .background(Color.gray6)
diff --git a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
index 00bfd9510..86339a6d1 100644
--- a/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
+++ b/Bitkit/Views/Subscriptions/CreateSubscriptionView.swift
@@ -102,7 +102,7 @@ struct CreateSubscriptionView: View {
                     )
                     .lineLimit(1)
                     .minimumScaleFactor(0.5)
-                    } else { NumberPadAmountText(value: usdtInputAmount(draft.amount.value), symbol: "$") }
+                    } else { PaykitAmountText(amount: draft.amount, size: .display) }
                     Image("pencil")
                         .resizable()
                         .frame(width: 24, height: 24)
diff --git a/BitkitTests/PaykitAmountTests.swift b/BitkitTests/PaykitAmountTests.swift
index 59df345c1..ded1a7b50 100644
--- a/BitkitTests/PaykitAmountTests.swift
+++ b/BitkitTests/PaykitAmountTests.swift
@@ -8,6 +8,17 @@ final class PaykitAmountTests: XCTestCase {
         PaykitExchangeRate(price: "100000", timestamp: now)
     }
 
+    func testUsdDisplayPreservesCentsAndUsesLocaleGrouping() {
+        for (cents, us, de): (UInt64, String, String) in [
+            (0, "0.00", "0,00"), (1, "0.01", "0,01"), (100, "1.00", "1,00"),
+            (15050, "150.50", "150,50"), (123_456, "1,234.56", "1.234,56"),
+            (.max, "184,467,440,737,095,516.15", "184.467.440.737.095.516,15"),
+        ] {
+            XCTAssertEqual(usdDisplayAmount(cents, locale: Locale(identifier: "en_US")), us, "cents: \(cents)")
+            XCTAssertEqual(usdDisplayAmount(cents, locale: Locale(identifier: "de_DE")), de, "cents: \(cents)")
+        }
+    }
+
     func testConversionPreservesValueAndRoundsPaymentUnitsUpward() throws {
         let cases: [(PaykitAsset, String, PaykitAsset, String)] = [
             (.usd, "5", .usdt, "5"),
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index a5af16dbd..0aaa2ac3a 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -3,16 +3,16 @@
   <actions>
     <action>Enable USDT in the introductory sheet or Settings, General, Payments before starting this flow.</action>
     <action>Open a linked contact and create a USD payment request. Verify BTC and USD are the denomination choices and enabled receiving methods start selected. Verify Accept Payment In appears below expiry, with compact outlined Bitcoin and USDT chips. Bitcoin groups all available Savings and Spending methods; no separate rail chips appear here.</action>
-    <action>On a comma-decimal device locale, enter 3,25 USD while creating a payment request. Verify the keypad, entered amount, request review and recipient row all show exactly 3,25 USD. Go back and verify the amount and denomination are preserved. On iOS with Classic Bitcoin display, repeat with a BTC amount and verify the keypad and amount use a dot and returning from review preserves the amount.</action>
+    <action>On a comma-decimal device locale, enter 150,50 USD while creating a payment request. Verify the keypad, entered amount, request review and recipient row all show exactly 150,50 USD. Go back and verify the amount and denomination are preserved. On iOS with Classic Bitcoin display, repeat with a BTC amount and verify the keypad and amount use a dot and returning from review preserves the amount.</action>
     <action>Return to the request amount editor, select USD and replace the amount with 10. Switch to BTC and back to USD four times without editing.</action>
     <action>Verify the USD amount is still exactly 10 and each return to BTC shows the same satoshi amount.</action>
     <action>Clear the USD input, then select BTC. Verify the amount is zero and Continue is disabled.</action>
-    <action>Select USD and enter 5 followed by the decimal separator without a fractional digit. Verify Continue is enabled. Continue and verify the request review shows exactly 5 USD.</action>
-    <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 1 USD, select an expiry and send the request.</action>
-    <action>On the payer, open the request. Verify Amount shows exactly $1 with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
+    <action>Select USD and enter 5 followed by the decimal separator without a fractional digit. Verify Continue is enabled. Continue and verify the request review shows 5,00 USD on a comma-decimal locale or 5.00 USD on a dot-decimal locale.</action>
+    <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 150,50 USD on the comma-decimal locale, select an expiry and send the request. Verify the sent screen, outgoing request card and request details all show 150,50 USD. Reopen the amount editor on a new request and verify typed trailing zeros are preserved.</action>
+    <action>On the payer using the same comma-decimal locale, verify the incoming request card and details show 150,50 USD. Open the request and verify Amount represents exactly 150.50 USDT with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
     <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
-    <action>Create a USD subscription. Verify Accepted Payments appears below frequency, with USDT selected and Bitcoin unselected. Verify the description and icon controls are side by side. Propose it to the linked contact. On the payer, review its dollar amount, recurrence and USDT payment method. Verify the subscription swipe uses USDT teal, then close before subscribing.</action>
+    <action>Create a USD subscription for 150,50 on a comma-decimal locale. Verify the amount review shows 150,50 USD and editing preserves that amount. Verify Accepted Payments appears below frequency, with USDT selected and Bitcoin unselected. Verify the description and icon controls are side by side. Propose it to the linked contact. On the payer, verify the subscription card and details show 150,50 USD, then review its recurrence and USDT payment method. Verify the subscription swipe uses USDT teal, then close before subscribing.</action>
     <action>Create a BTC subscription for 12,345 sats and verify Bitcoin is selected. Tap SubscriptionAccept-usdt; verify the amount converts to USD and only USDT is selected. Tap SubscriptionAccept-bitcoin; verify the amount returns to exactly 12,345 sats and only Bitcoin is selected, covering the enabled Savings and Spending methods.</action>
     <action>Repeat the subscription USDT and Bitcoin switches four times without editing. Verify every return to Bitcoin shows exactly 12,345 sats. Edit the amount to 10 USD, repeat the switches and verify every return to USDT shows exactly 10 USD. Close without proposing.</action>
     <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01, then close without continuing to review.</action>

From a35f2a34edd670f306aa275993a2345e12d53fff Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 13:04:21 -0500
Subject: [PATCH 52/62] Match USDT bridge activity and refund designs

---
 Bitkit/Components/SendSectionView.swift       |  14 +-
 Bitkit/MainNavView.swift                      |   1 +
 .../Localization/en.lproj/Localizable.strings |  18 +-
 Bitkit/Styles/TextStyle.swift                 |  27 +-
 Bitkit/ViewModels/NavigationViewModel.swift   |   3 +-
 Bitkit/Views/Wallets/UsdtActivityDetail.swift | 134 ++++---
 .../Wallets/UsdtDepositHistoryView.swift      | 330 +++++++++++++-----
 Bitkit/Views/Wallets/UsdtReceiveView.swift    |  18 +-
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |   5 +-
 BitkitTests/UsdtPaymentLinkTests.swift        |   4 +
 BitkitTests/UsdtWalletManagerTests.swift      |  34 ++
 journeys/usdt-bridge-details.xml              |  16 +
 journeys/usdt-bridge-support.xml              |   4 +-
 13 files changed, 448 insertions(+), 160 deletions(-)
 create mode 100644 journeys/usdt-bridge-details.xml

diff --git a/Bitkit/Components/SendSectionView.swift b/Bitkit/Components/SendSectionView.swift
index 00ca7484f..6b41a8f2f 100644
--- a/Bitkit/Components/SendSectionView.swift
+++ b/Bitkit/Components/SendSectionView.swift
@@ -3,18 +3,28 @@ import SwiftUI
 /// A section with a caption label, content, and a divider below. Used for form-style rows (e.g. "Send from", "Send to").
 struct SendSectionView<Content: View>: View {
     private let title: String
+    private let labelLineHeight: CGFloat?
+    private let labelKerning: CGFloat
     private let dividerSpacing: CGFloat
     @ViewBuilder private let content: () -> Content
 
-    init(_ title: String, dividerSpacing: CGFloat = 16, @ViewBuilder content: @escaping () -> Content) {
+    init(
+        _ title: String,
+        dividerSpacing: CGFloat = 16,
+        labelKerning: CGFloat = 0.8,
+        labelLineHeight: CGFloat? = nil,
+        @ViewBuilder content: @escaping () -> Content
+    ) {
         self.title = title
+        self.labelKerning = labelKerning
+        self.labelLineHeight = labelLineHeight
         self.dividerSpacing = dividerSpacing
         self.content = content
     }
 
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
-            CaptionMText(title)
+            CaptionMText(title, kerning: labelKerning, lineHeight: labelLineHeight)
                 .padding(.bottom, 8)
 
             content()
diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index dafc27bb5..55c92a380 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -471,6 +471,7 @@ struct MainNavView: View {
                 case .usdtWallet: UsdtWalletScreen()
                 case let .usdtPayment(recipient, amount): UsdtWalletScreen(initialRecipient: recipient, initialAmount: amount)
                 case let .usdtActivity(transferId): UsdtActivityDetail(transferId: transferId)
+                case .usdtDepositHistory: UsdtDepositHistoryView()
                 case .scanner: ScannerScreen()
 
                 // Transfer
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index d9686e13a..548bd6b94 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1867,7 +1867,7 @@
 "usdt__deposit_estimate" = "Estimated received (USDT)";
 "usdt__deposit_estimate_note" = "Indicative price only. Costs are deducted from the USDT received and may change before conversion. The sender pays their network gas separately.";
 "usdt__deposit_fee_note" = "Fees are deducted from the USDT you receive. The sender pays their network fees separately.";
-"usdt__deposit_history" = "Cross-network Deposits";
+"usdt__deposit_history" = "Cross-Network Deposits";
 "usdt__deposit_limits" = "Deposit limits";
 "usdt__deposit_limits_note" = "Live liquidity and network costs can further restrict these limits. Amounts outside the limits may be held.";
 "usdt__deposit_more" = "Load more";
@@ -1877,7 +1877,7 @@
 "usdt__deposit_refresh" = "Refresh";
 "usdt__deposit_refund" = "Request Refund";
 "usdt__deposit_refunded" = "Refunded";
-"usdt__deposit_status_note" = "Provider status is shown here. Your spendable balance updates only when USDT arrives on Arbitrum.";
+"usdt__deposit_status_note" = "Your spendable balance updates when USDT arrives on Arbitrum.";
 "usdt__deposit_unavailable" = "Cross-network receiving is currently unavailable. Direct Arbitrum receive still works.";
 "usdt__deposit_wrong_asset" = "Unsupported deposit asset — contact support";
 
@@ -1909,8 +1909,6 @@
 "pubky_auth__shared_bitcoin" = "Also, you shared a watch-only Bitcoin account with Paykit.";
 "pubky_auth__shared_both" = "Also, you shared a watch-only Bitcoin account and USDT address with Paykit.";
 "usdt__deposit_batch" = "Converted batch";
-"usdt__deposit_refund_address" = "Refund address on the source network";
-"usdt__deposit_refund_note" = "Confirm a refund address with the sender. Do not assume an exchange deposit can be returned to its sending address. Refund fees may apply. TRON refunds can require Orchestra operator assistance.";
 "usdt__deposit_refund_requested" = "Refund requested. This is not a confirmed refund; check the deposit status.";
 "usdt__deposit_refunding" = "Refund in progress";
 
@@ -1971,3 +1969,15 @@
 "usdt__disabled" = "USDT is turned off.";
 
 "subscriptions__accepted_payments" = "Accepted payments";
+
+"usdt__receiving_title" = "Receiving USDT";
+"usdt__delivering_title" = "Delivering USDT";
+"usdt__delivering" = "Delivering";
+"usdt__receiving_network" = "Receiving network";
+"usdt__provider_status" = "Provider status";
+"usdt__deposit_refund_heading" = "Request a refund";
+"usdt__deposit_refund_instructions" = "Enter a USDT address on {network} to receive the refund. If someone else sent the funds, confirm the address with them.\n\nFor deposits sent from an exchange, don’t copy the transaction’s sending address. Ask the sender for a suitable receiving address.";
+"usdt__deposit_confirm_refund" = "Confirm Refund";
+"usdt__deposit_refund_confirmation" = "Request refund for {amount} USDT deposit?\n\nNetwork:\n{network}\n\nRefund address:\n{address}\n\nConfirm this address can receive USDT on {shortNetwork}. Refund fees may apply.";
+"usdt__deposit_tron_refund_note" = "TRON refunds can require Orchestra operator assistance.";
+"usdt__deposit_refund_address_network" = "USDT address on {network}";
diff --git a/Bitkit/Styles/TextStyle.swift b/Bitkit/Styles/TextStyle.swift
index 0536d4e06..5f08a3eba 100644
--- a/Bitkit/Styles/TextStyle.swift
+++ b/Bitkit/Styles/TextStyle.swift
@@ -341,6 +341,8 @@ struct BodySSBText: View {
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
 
+    var lineHeight: CGFloat?
+
     private let fontSize: CGFloat = 15
 
     init(
@@ -348,8 +350,10 @@ struct BodySSBText: View {
         textColor: Color = .textPrimary,
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
-        accentAction: (() -> Void)? = nil
+        accentAction: (() -> Void)? = nil,
+        lineHeight: CGFloat? = nil
     ) {
+        self.lineHeight = lineHeight
         self.text = text
         self.textColor = textColor
         self.accentColor = accentColor
@@ -366,6 +370,11 @@ struct BodySSBText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
+        .transformEnvironment(\._lineHeightMultiple) { value in
+            if let lineHeight, let font = UIFont(name: Fonts.semiBold, size: fontSize) {
+                value = lineHeight / font.lineHeight
+            }
+        }
         .kerning(0.4)
         // .lineSpacing(0)
     }
@@ -451,6 +460,9 @@ struct CaptionMText: View {
     var accentColor: Color = .brandAccent
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
+    var kerning: CGFloat
+
+    var lineHeight: CGFloat?
 
     private let fontSize: CGFloat = 13
 
@@ -459,12 +471,16 @@ struct CaptionMText: View {
         textColor: Color = .textSecondary,
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
-        accentAction: (() -> Void)? = nil
+        accentAction: (() -> Void)? = nil,
+        kerning: CGFloat = 0.8,
+        lineHeight: CGFloat? = nil
     ) {
+        self.lineHeight = lineHeight
         self.text = text
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
+        self.kerning = kerning
     }
 
     var body: some View {
@@ -476,7 +492,12 @@ struct CaptionMText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
-        .kerning(0.8)
+        .transformEnvironment(\._lineHeightMultiple) { value in
+            if let lineHeight, let font = UIFont(name: Fonts.medium, size: fontSize) {
+                value = lineHeight / font.lineHeight
+            }
+        }
+        .kerning(kerning)
         .textCase(.uppercase)
     }
 }
diff --git a/Bitkit/ViewModels/NavigationViewModel.swift b/Bitkit/ViewModels/NavigationViewModel.swift
index a8e15e6ed..90abe769e 100644
--- a/Bitkit/ViewModels/NavigationViewModel.swift
+++ b/Bitkit/ViewModels/NavigationViewModel.swift
@@ -13,6 +13,7 @@ enum Route: Hashable {
     case usdtWallet
     case usdtPayment(recipient: String, amount: String)
     case usdtActivity(transferId: String)
+    case usdtDepositHistory
     case activityList
     case activityDetail(Activity)
     case activityExplorer(Activity)
@@ -151,7 +152,7 @@ extension Route {
 
     var isUsdtWalletRoute: Bool {
         switch self {
-        case .usdtWallet, .usdtPayment: true
+        case .usdtWallet, .usdtPayment, .usdtDepositHistory: true
         default: false
         }
     }
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index 26803d284..6e47a96d5 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -55,6 +55,7 @@ struct UsdtActivityDetail: View {
     let transferId: String
     @AppStorage(PaykitFeatureFlags.uiEnabledKey) private var isPaykitUIEnabled = PaykitFeatureFlags.uiEnabledByDefault
     @Environment(UsdtWalletManager.self) private var usdt
+    @EnvironmentObject private var navigation: NavigationViewModel
     @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var contacts: ContactsManager
     @Environment(\.openURL) private var openURL
@@ -65,23 +66,14 @@ struct UsdtActivityDetail: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
-            NavigationBar(title: t(transfer?.isIncoming == true ? "usdt__payment_received" : "usdt__sent_title"), onBack: { dismiss() })
+            NavigationBar(title: transfer?.detailTitle ?? t("usdt__sent_title"), onBack: { dismiss() })
                 .padding(.bottom, 16)
             if let transfer {
                 ScrollView(showsIndicators: false) {
                     VStack(alignment: .leading, spacing: 16) {
-                        VStack(alignment: .leading, spacing: 16) {
-                            CaptionMText(settings.hideBalance ? "• • • • •" : "$ " + usdtOverviewAmount(transfer.activityAmount))
-                            HStack(spacing: 16) {
-                                DisplayText(
-                                    "<accent>\(transfer.isIncoming ? "+" : "−")</accent> "
-                                        + (settings.hideBalance ? "• • • • •" : usdtOverviewAmount(transfer.activityAmount)),
-                                    accentColor: .textSecondary, accentFont: Fonts.extraBold
-                                ).lineLimit(1).minimumScaleFactor(0.5)
-                                UsdtActivityIcon(transfer: transfer, size: 48)
-                            }
-                            .frame(height: 36)
-                        }.padding(.bottom, 16)
+                        UsdtActivityAmountHeader(amount: transfer.activityAmount, isIncoming: transfer.isIncoming,
+                                                 hideBalance: settings.hideBalance)
+                            .padding(.bottom, 16)
                         if showDetails {
                             technicalDetails(transfer)
                         } else {
@@ -100,11 +92,22 @@ struct UsdtActivityDetail: View {
                                 }
                             }
                         }
-                        if transfer.destination != .arbitrum { UsdtSupportActions(details: transfer.supportDetails) }
+                        if showDetails, transfer.isIncoming, usdt.depositsConfigured, let txHash = transfer.txHash {
+                            CustomButton(title: t("wallet__activity_explorer"), variant: .secondary, shouldExpand: true) {
+                                if let url = URL(string: "https://arbiscan.io/tx/" + txHash) { openURL(url) }
+                            }
+                            .accessibilityIdentifier("UsdtActivityExplorer")
+                        }
+                        if transfer.destination != .arbitrum,
+                           showDetails || transfer.needsBridgeSupport { UsdtSupportActions(details: transfer.supportDetails) }
                     }
                 }
                 .frame(maxHeight: .infinity, alignment: .top)
-                if showDetails, let txHash = transfer.txHash {
+                if showDetails, transfer.isIncoming, usdt.depositsConfigured {
+                    CustomButton(title: t("usdt__deposit_history"), shouldExpand: true) { navigation.navigate(.usdtDepositHistory) }
+                        .padding(.top, 24)
+                        .accessibilityIdentifier("UsdtDepositHistory")
+                } else if showDetails, let txHash = transfer.txHash {
                     CustomButton(title: t("wallet__activity_explorer"), shouldExpand: true) {
                         if let url = URL(string: "https://arbiscan.io/tx/" + txHash) { openURL(url) }
                     }
@@ -129,9 +132,10 @@ struct UsdtActivityDetail: View {
     private func summary(_ transfer: UsdtTransfer) -> some View {
         HStack(alignment: .top, spacing: 16) {
             UsdtDetailCell(title: t("wallet__activity_status"), value: transfer.status.label,
-                           icon: transfer.status == .confirmed ? "check-circle" : transfer.statusIcon, valueColor: transfer.statusColor)
+                           icon: transfer.status == .confirmed ? "check-circle" : transfer.statusIcon,
+                           valueColor: transfer.statusColor, iconColor: transfer.statusColor)
                 .accessibilityIdentifier("UsdtActivityStatus")
-            UsdtDetailCell(title: t("usdt__network"), value: UsdtDestination.arbitrum.label, icon: "usdt-network")
+            UsdtDetailCell(title: t("usdt__receiving_network"), value: transfer.destination.label, icon: "usdt-network")
         }
         let time = DateFormatterHelpers.formatActivityDetail(transfer.timestamp)
         HStack(alignment: .top, spacing: 16) {
@@ -143,14 +147,9 @@ struct UsdtActivityDetail: View {
             UsdtDetailCell(title: t("wallet__activity_fee"), value: transfer.fee.map(displayedAmount) ?? "—", icon: "speed-normal")
         }
         if PaykitFeatureFlags.isUIAvailable, isPaykitUIEnabled, let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) {
-            SendSectionView(t("wallet__payment_request_contact")) {
+            SendSectionView(t("wallet__payment_request_contact"), labelKerning: 1, labelLineHeight: 18) {
                 BodySSBText(contacts.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }?.displayName
-                    ?? PubkyPublicKeyFormat.displayTruncated(key))
-            }
-        }
-        if transfer.destination != .arbitrum, ![.failed, .replaced, .bridgeRefunded].contains(transfer.status) {
-            SendSectionView(t(transfer.status == .confirmed ? "usdt__recipient_gets" : "usdt__expected_amount")) {
-                amountText(transfer.receivedAmount)
+                    ?? PubkyPublicKeyFormat.displayTruncated(key), lineHeight: 20)
             }
         }
     }
@@ -158,12 +157,18 @@ struct UsdtActivityDetail: View {
     @ViewBuilder
     private func technicalDetails(_ transfer: UsdtTransfer) -> some View {
         if let txHash = transfer.txHash {
-            SendSectionView(t("wallet__activity_tx_id")) { BodySSBText(txHash).textSelection(.enabled) }
+            SendSectionView(t("wallet__activity_tx_id"), labelKerning: 1, labelLineHeight: 18) {
+                BodySSBText(txHash, lineHeight: 20).textSelection(.enabled)
+            }
         }
         if let sender = transfer.sender ?? (!transfer.isIncoming && !usdt.address.isEmpty ? usdt.address : nil) {
-            SendSectionView(t("usdt__from_address")) { BodySSBText(sender).textSelection(.enabled) }
+            SendSectionView(t("usdt__from_address"), labelKerning: 1, labelLineHeight: 18) {
+                BodySSBText(sender, lineHeight: 20).textSelection(.enabled)
+            }
+        }
+        SendSectionView(t("usdt__to_address"), labelKerning: 1, labelLineHeight: 18) {
+            BodySSBText(transfer.recipient, lineHeight: 20).textSelection(.enabled)
         }
-        SendSectionView(t("usdt__to_address")) { BodySSBText(transfer.recipient).textSelection(.enabled) }
         HStack(alignment: .top, spacing: 16) {
             if !transfer.isIncoming {
                 UsdtDetailCell(title: t("usdt__sender_network"), value: UsdtDestination.arbitrum.label, icon: "usdt-network")
@@ -171,14 +176,28 @@ struct UsdtActivityDetail: View {
             UsdtDetailCell(title: t("usdt__destination"), value: transfer.destination.label, icon: "usdt-network")
         }
         if let bridge = transfer.orchestra {
-            SendSectionView(t("usdt__bridge_provider")) { BodySSBText("Orchestra") }
-            SendSectionView(t("usdt__bridge_reference")) { BodySSBText(bridge.quoteId).textSelection(.enabled) }
+            UsdtDetailCell(title: t("usdt__bridge_provider"), value: "Orchestra", icon: "arrow-up-down")
+            UsdtDetailCell(title: t("usdt__bridge_reference"), value: bridge.quoteId, icon: "note")
+                .textSelection(.enabled)
             if let hash = bridge.destinationTx {
-                SendSectionView(t("usdt__destination_tx")) { BodySSBText(hash).textSelection(.enabled) }
+                SendSectionView(t("usdt__destination_tx"), labelKerning: 1, labelLineHeight: 18) {
+                    BodySSBText(hash, lineHeight: 20).textSelection(.enabled)
+                }
             }
             if let amount = bridge.refundAmount, let hash = bridge.refundTx {
-                SendSectionView(t("usdt__deposit_refunded")) { amountText(amount) }
-                SendSectionView(t("usdt__refund_tx")) { BodySSBText(hash).textSelection(.enabled) }
+                SendSectionView(t("usdt__deposit_refunded"), labelKerning: 1, labelLineHeight: 18) { amountText(amount) }
+                SendSectionView(t("usdt__refund_tx"), labelKerning: 1, labelLineHeight: 18) {
+                    BodySSBText(hash, lineHeight: 20).textSelection(.enabled)
+                }
+            }
+        }
+        if transfer.destination != .arbitrum, ![.failed, .replaced, .bridgeRefunded].contains(transfer.status) {
+            SendSectionView(
+                t(transfer.status == .confirmed ? "usdt__recipient_gets" : "usdt__expected_amount"),
+                labelKerning: 1,
+                labelLineHeight: 18
+            ) {
+                amountText(transfer.receivedAmount)
             }
         }
     }
@@ -192,11 +211,20 @@ struct UsdtActivityDetail: View {
     }
 
     private func amountText(_ amount: UInt64) -> some View {
-        BodySSBText((settings.hideBalance ? " • • • • •" : usdtOverviewAmount(amount)) + " USDT")
+        BodySSBText((settings.hideBalance ? " • • • • •" : usdtOverviewAmount(amount)) + " USDT", lineHeight: 20)
     }
 }
 
 extension UsdtTransfer {
+    var detailTitle: String {
+        if isIncoming { return t(status == .pending ? "usdt__receiving_title" : "usdt__payment_received") }
+        return t(status == .bridging ? "usdt__delivering_title" : "usdt__sent_title")
+    }
+
+    var needsBridgeSupport: Bool {
+        destination != .arbitrum && [.bridgeNeedsAttention, .bridgeFailed, .bridgeRefunded, .failed, .replaced].contains(status)
+    }
+
     var activityAmount: UInt64 {
         if isIncoming { return amount }
         if status == .failed || status == .replaced { return fee ?? 0 }
@@ -207,7 +235,7 @@ extension UsdtTransfer {
     var title: String {
         switch status {
         case .failed, .replaced: status.label
-        case .bridging: t("wallet__activity_transferring")
+        case .bridging: status.label
         case .pending, .bridgeNeedsAttention, .bridgeFailed, .bridgeRefunded: status.label
         default: t(isIncoming ? "usdt__received" : "usdt__sent")
         }
@@ -220,8 +248,7 @@ extension UsdtTransfer {
     var statusIcon: String {
         switch status {
         case .failed, .replaced, .bridgeFailed: "x-circle"
-        case .pending, .bridgeNeedsAttention: "hourglass-simple"
-        case .bridging: "arrow-up-down"
+        case .pending, .bridging, .bridgeNeedsAttention: "hourglass-simple"
         case .confirmed: isIncoming ? "arrow-down" : "arrow-up"
         case .bridgeRefunded: "arrow-down"
         }
@@ -230,7 +257,7 @@ extension UsdtTransfer {
     var statusColor: Color {
         switch status {
         case .failed, .replaced: .redAccent
-        case .bridgeNeedsAttention, .bridgeFailed: .yellowAccent
+        case .pending, .bridging, .bridgeNeedsAttention, .bridgeFailed: .yellowAccent
         default: .usdtAccent
         }
     }
@@ -241,16 +268,43 @@ struct UsdtDetailCell: View {
     let value: String
     let icon: String
     var valueColor: Color = .textPrimary
+    var iconColor: Color = .usdtAccent
     var minimumValueHeight: CGFloat = 20
 
     var body: some View {
-        SendSectionView(title) {
+        SendSectionView(title, labelKerning: 1, labelLineHeight: 18) {
             HStack(spacing: 4) {
-                Image(icon).resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(.usdtAccent)
-                BodySSBText(value, textColor: valueColor)
+                Image(icon).resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(iconColor)
+                BodySSBText(value, textColor: valueColor, lineHeight: 20)
             }
             .frame(minHeight: 20, alignment: .leading)
             .frame(minHeight: minimumValueHeight, alignment: .topLeading)
         }
     }
 }
+
+struct UsdtActivityAmountHeader: View {
+    let amount: UInt64?
+    let isIncoming: Bool
+    let hideBalance: Bool
+
+    private var displayedAmount: String {
+        hideBalance ? "• • • • •" : amount.map { usdtOverviewAmount($0) } ?? "—"
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            CaptionMText(hideBalance ? displayedAmount : "$ " + displayedAmount, kerning: 1, lineHeight: 18)
+            HStack(spacing: 16) {
+                HStack(spacing: 6) {
+                    DisplayText("<accent>\(isIncoming ? "+" : "−")</accent>",
+                                accentColor: .textSecondary, accentFont: Fonts.extraBold, fillsWidth: false)
+                    DisplayText(displayedAmount).lineLimit(1).minimumScaleFactor(0.5)
+                }
+                CircularIcon(icon: isIncoming ? "arrow-down" : "arrow-up", iconColor: .usdtAccent,
+                             backgroundColor: .usdtAccent.opacity(0.16), size: 48)
+            }
+            .frame(height: 36)
+        }
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index 0c5e2eecc..a1beab28f 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -2,7 +2,7 @@ import BitkitCore
 import SwiftUI
 
 struct UsdtDepositHistoryView: View {
-    let onBlockingChange: (Bool) -> Void
+    @Environment(\.dismiss) private var dismiss
     @Environment(\.scenePhase) private var scenePhase
     @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject private var settings: SettingsViewModel
@@ -10,6 +10,7 @@ struct UsdtDepositHistoryView: View {
     @State private var nextOffset: UInt32?
     @State private var selected: UsdtDepositDetail?
     @State private var refundAddress = ""
+    @State private var showDetails = true
     @State private var approved: RefundApproval?
     @State private var pageOffsets: [String: UInt32] = [:]
     @State private var confirmRefund = false
@@ -23,75 +24,67 @@ struct UsdtDepositHistoryView: View {
     }
 
     var body: some View {
-        NavigationStack {
-            VStack(alignment: .leading, spacing: 16) {
-                ScrollView {
-                    VStack(alignment: .leading, spacing: 16) {
-                        if let selected { detail(selected) }
-                        else {
-                            if deposits.isEmpty { BodySText(t("usdt__deposit_empty"), textColor: .textSecondary) }
-                            ForEach(deposits, id: \.id) { deposit in
-                                Button {
-                                    Task { await loadDetail(deposit.id) }
-                                } label: {
-                                    ActivityRowContainer {
-                                        ActivityRowContent(title: deposit.network.uppercased(), subtitle: t("wallet__send_details")) {
-                                            CircularIcon(
-                                                icon: "arrow-down",
-                                                iconColor: .usdtAccent,
-                                                backgroundColor: .usdtAccent.opacity(0.16),
-                                                size: 40
-                                            )
-                                        } amount: { BodySSBText(deposit.asset == "USDT" ? amount(deposit.amount) : deposit.asset) }
-                                    }
-                                }.buttonStyle(.plain).disabled(busy)
-                            }
-                            if let nextOffset {
-                                CustomButton(title: t("usdt__deposit_more"), variant: .secondary, isDisabled: busy) { await loadPage(nextOffset) }
-                            }
-                        }
-                        if let error { BodySText(error, textColor: .brandAccent) }
-                        if let message { BodySText(message, textColor: .textSecondary) }
-                    }
+        VStack(alignment: .leading, spacing: 0) {
+            NavigationBar(title: selected == nil ? t("usdt__deposit_history") : t("usdt__receiving_title"), onBack: {
+                if selected == nil { dismiss() }
+                else { clearSelection() }
+            })
+            .disabled(busy || recoveryActive)
+            .padding(.bottom, 16)
+            ScrollView(showsIndicators: false) {
+                VStack(alignment: .leading, spacing: 16) {
+                    if let selected { detail(selected) }
+                    else { depositList }
+                    if let error { BodySText(error, textColor: .brandAccent).accessibilityIdentifier("UsdtDepositError") }
+                    if let message { BodySText(message, textColor: .textSecondary) }
                 }
-                .scrollDismissesKeyboard(.immediately)
-                CustomButton(title: t(selected == nil ? "usdt__deposit_refresh" : "usdt__deposit_history"),
-                             variant: .secondary, isDisabled: busy, isLoading: busy)
-                {
-                    selected = nil
-                    message = nil
-                    refundAddress = ""
-                    approved = nil
+                .padding(.bottom, 16)
+            }
+            .scrollDismissesKeyboard(.immediately)
+            .refreshable {
+                guard !recoveryActive else { return }
+                if let selected { await loadDetail(selected.deposit.id) }
+                else { await loadPage(0) }
+            }
+            if selected != nil {
+                CustomButton(title: t("usdt__deposit_history"), isDisabled: busy || recoveryActive) {
+                    clearSelection()
                     await loadPage(0)
                 }
+                .padding(.top, 16)
+                .accessibilityIdentifier("UsdtDepositHistory")
+            } else if error != nil || deposits.isEmpty {
+                CustomButton(title: t("usdt__deposit_refresh"), isDisabled: busy, isLoading: busy) { await loadPage(0) }
             }
-            .navigationBarHidden(true)
-            .navigationDestination(isPresented: $pin) {
-                SendPinScreen(onCancel: {
-                    pin = false
-                    approved = nil
-                }, onPinVerified: {
-                    pin = false
-                    Task { await refund() }
-                })
-            }
-            .alert(t("usdt__deposit_refund"), isPresented: $confirmRefund) {
-                Button(t("common__cancel"), role: .cancel) {}
-                Button(t("usdt__deposit_refund")) {
-                    if let deposit = selected?.deposit {
-                        approved = RefundApproval(deposit: deposit, offset: pageOffsets[deposit.id] ?? 0, address: refundAddress)
-                        Task { await authorizeRefund() }
-                    }
+        }
+        .padding(.horizontal, 16)
+        .bottomSafeAreaPadding()
+        .background(Color.black)
+        .navigationBarHidden(true)
+        .navigationDestination(isPresented: $pin) {
+            SendPinScreen(onCancel: {
+                pin = false
+                approved = nil
+            }, onPinVerified: {
+                pin = false
+                Task { await refund() }
+            })
+        }
+        .alert(t("usdt__deposit_confirm_refund"), isPresented: $confirmRefund) {
+            Button(t("common__cancel"), role: .cancel) {}
+                .accessibilityIdentifier("UsdtRefundCancel")
+            Button(t("usdt__deposit_refund")) {
+                if let detail = selected, detail.canRequestRefund {
+                    let deposit = detail.deposit
+                    approved = RefundApproval(deposit: deposit, offset: pageOffsets[deposit.id] ?? 0, address: refundAddress)
+                    Task { await authorizeRefund() }
                 }
-            } message: {
-                let network: String = selected?.deposit.network.uppercased() ?? ""
-                let depositId: String = selected?.deposit.id ?? ""
-                let refundAmount: String = amount(selected?.deposit.amount)
-                let note: String = t("usdt__deposit_refund_note")
-                Text("\(network)\n\(depositId)\n\(refundAmount)\n\(refundAddress)\n\n\(note)")
             }
+            .accessibilityIdentifier("UsdtRefundConfirm")
+        } message: {
+            Text(selected?.refundConfirmation(address: refundAddress, hideBalance: settings.hideBalance) ?? "")
         }
-        .task { await loadPage(0) }
+        .task { if !recoveryActive { await loadPage(0) } }
         .task(id: "\(scenePhase == .active)-\(selected?.deposit.id ?? "")-\(recoveryActive)") {
             guard scenePhase == .active, !recoveryActive, let id = selected?.deposit.id else { return }
             while !Task.isCancelled {
@@ -105,50 +98,120 @@ struct UsdtDepositHistoryView: View {
             }
         }
         .interactiveDismissDisabled(busy || pin)
-        .onChange(of: busy || pin) { _, blocked in onBlockingChange(blocked) }
-        .onDisappear { onBlockingChange(false) }
+    }
+
+    private var depositList: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            SendSectionView(t("usdt__provider_status"), labelKerning: 1, labelLineHeight: 18) {
+                BodySSBText(t("usdt__deposit_status_note"), lineHeight: 20)
+            }
+            if deposits.isEmpty, !busy { BodySText(t("usdt__deposit_empty"), textColor: .textSecondary) }
+            ForEach(deposits, id: \.id) { deposit in
+                Button { Task { await loadDetail(deposit.id) } } label: {
+                    UsdtDepositRow(deposit: deposit, hideBalance: settings.hideBalance)
+                }
+                .buttonStyle(.plain).disabled(busy)
+                .accessibilityIdentifier("UsdtDepositRow-\(deposit.id)")
+            }
+            if let nextOffset {
+                CustomButton(title: t("usdt__deposit_more"), variant: .secondary, isDisabled: busy) { await loadPage(nextOffset) }
+            }
+        }
     }
 
     private func detail(_ detail: UsdtDepositDetail) -> some View {
         VStack(alignment: .leading, spacing: 16) {
             if detail.deposit.asset == "USDT" {
-                UsdtAmountHeader(
-                    amount: detail.deposit.amount.map { usdtFormatAmount(amount: $0) } ?? "—",
-                    displayAmount: detail.deposit.amount.map { usdtOverviewAmount($0) }, hideBalance: settings.hideBalance
-                )
+                UsdtActivityAmountHeader(amount: detail.deposit.amount, isIncoming: true, hideBalance: settings.hideBalance)
+                    .padding(.bottom, 16)
             } else {
-                BodySSBText(detail.deposit.asset + " · " + detail.deposit.network.uppercased())
+                BodySSBText(detail.deposit.asset + " · " + detail.deposit.networkLabel, lineHeight: 20)
             }
-            SendSectionView(t("wallet__activity_status")) { BodySSBText(detail.statusText) }
-            BodySText(t("usdt__deposit_status_note"), textColor: .textSecondary)
-            SendSectionView(t("usdt__deposit_reference")) { BodySText(detail.deposit.id).textSelection(.enabled) }
-            SendSectionView(t("wallet__activity_tx_id")) { BodySText(detail.deposit.sourceTx).textSelection(.enabled) }
-            if let code = detail.statusCode { BodySText(code, textColor: .textSecondary).textSelection(.enabled) }
-            if let order = detail.order, order.status != "refunded", let received = order.amountOut {
-                SendSectionView(t("usdt__deposit_batch")) { BodySSBText(amount(received)) }
-                if let sent = order.amountIn, sent >= received {
-                    SendSectionView(t("usdt__deposit_cost")) { BodySSBText(amount(sent - received)) }
+            if showDetails {
+                SendSectionView(t("wallet__activity_tx_id"), labelKerning: 1, labelLineHeight: 18) {
+                    BodySSBText(detail.deposit.sourceTx, lineHeight: 20).textSelection(.enabled)
                 }
+                SendSectionView(t("usdt__deposit_reference"), labelKerning: 1, labelLineHeight: 18) {
+                    BodySSBText(detail.deposit.id, lineHeight: 20).textSelection(.enabled)
+                }
+                if !detail.canRequestRefund {
+                    UsdtDetailCell(title: t("wallet__activity_status"), value: detail.statusText, icon: detail.statusIcon,
+                                   valueColor: detail.statusColor, iconColor: detail.statusColor)
+                }
+                if detail.canRequestRefund {
+                    SendSectionView(t("usdt__deposit_refund_heading"), labelKerning: 1, labelLineHeight: 18) {
+                        BodySSBText(t("usdt__deposit_refund_instructions", variables: ["network": detail.deposit.refundNetworkLabel]), lineHeight: 20)
+                    }
+                    TextField(t("usdt__deposit_refund_address_network", variables: ["network": detail.deposit.refundNetworkLabel]),
+                              text: $refundAddress, axis: .vertical, testIdentifier: "UsdtRefundAddress")
+                        .textInputAutocapitalization(.never).autocorrectionDisabled().disabled(busy)
+                }
+                HStack(spacing: 16) {
+                    if detail.canRequestRefund {
+                        CustomButton(title: t("usdt__deposit_refund"), size: .small,
+                                     icon: Image("coins").resizable().frame(width: 16, height: 16).foregroundColor(.usdtAccent),
+                                     isDisabled: busy || refundAddress.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+                                     isLoading: busy, shouldExpand: true) { confirmRefund = true }
+                            .accessibilityIdentifier("UsdtDepositRefund")
+                    }
+                    detailsButton
+                }
+                if detail.canRequestRefund, UsdtDepositNetwork.named(detail.deposit.network) == .tron {
+                    BodySText(t("usdt__deposit_tron_refund_note"), textColor: .textSecondary)
+                }
+                if let code = detail.statusCode { BodySText(code, textColor: .textSecondary).textSelection(.enabled) }
+                if let tx = detail.order?.destinationTx {
+                    SendSectionView(t("usdt__destination_tx"), labelKerning: 1, labelLineHeight: 18) {
+                        BodySSBText(tx, lineHeight: 20).textSelection(.enabled)
+                    }
+                }
+                if let tx = detail.order?.refundTx ?? detail.deposit.refundTx {
+                    SendSectionView(t("usdt__refund_tx"), labelKerning: 1, labelLineHeight: 18) {
+                        BodySSBText(tx, lineHeight: 20).textSelection(.enabled)
+                    }
+                }
+                if detail.deposit.asset != "USDT" || UsdtDepositNetwork.named(detail.deposit.network) == nil {
+                    BodySText(t("usdt__deposit_wrong_asset"), textColor: .textSecondary)
+                }
+                UsdtSupportActions(details: detail.supportDetails).disabled(busy || recoveryActive)
+            } else {
+                HStack(alignment: .top, spacing: 16) {
+                    UsdtDetailCell(title: t("wallet__activity_status"), value: detail.statusText, icon: detail.statusIcon,
+                                   valueColor: detail.statusColor, iconColor: detail.statusColor)
+                    UsdtDetailCell(title: t("usdt__receiving_network"), value: UsdtDestination.arbitrum.label, icon: "usdt-network")
+                }
+                UsdtDetailCell(title: t("usdt__sender_network"), value: detail.deposit.networkLabel, icon: "usdt-network")
+                if let order = detail.order, order.status != "refunded", let received = order.amountOut {
+                    SendSectionView(t("usdt__deposit_batch"), labelKerning: 1, labelLineHeight: 18) { BodySSBText(amount(received), lineHeight: 20) }
+                    if let sent = order.amountIn, sent >= received {
+                        SendSectionView(t("usdt__deposit_cost"), labelKerning: 1, labelLineHeight: 18) { BodySSBText(
+                            amount(sent - received),
+                            lineHeight: 20
+                        ) }
+                    }
+                }
+                detailsButton
+                UsdtSupportActions(details: detail.supportDetails).disabled(busy || recoveryActive)
             }
-            if let tx = detail.order?
-                .destinationTx { SendSectionView(t("wallet__activity_tx_id") + " · Arbitrum One") { BodySText(tx).textSelection(.enabled) } }
-            if let tx = detail.order?.refundTx ?? detail.deposit.refundTx {
-                SendSectionView(t("usdt__refund_tx")) { BodySText(tx).textSelection(.enabled) }
-            }
-            if detail.deposit.asset != "USDT" || UsdtDepositNetwork.named(detail.deposit.network) == nil {
-                BodySText(t("usdt__deposit_wrong_asset"), textColor: .textSecondary)
-            } else if !["completed", "refunded", "refunding", "refund_requested"].contains(detail.order?.status ?? detail.deposit.status) {
-                BodySText(t("usdt__deposit_refund_note"), textColor: .textSecondary)
-                TextField(t("usdt__deposit_refund_address"), text: $refundAddress, axis: .vertical, testIdentifier: "UsdtRefundAddress")
-                    .textInputAutocapitalization(.never).autocorrectionDisabled().disabled(busy)
-                CustomButton(title: t("usdt__deposit_refund"), variant: .secondary,
-                             isDisabled: busy || refundAddress.isEmpty, isLoading: busy) { if !busy { confirmRefund = true } }
-                    .accessibilityIdentifier("UsdtDepositRefund")
-            }
-            UsdtSupportActions(details: detail.supportDetails).disabled(busy || recoveryActive)
         }
     }
 
+    private var detailsButton: some View {
+        CustomButton(title: t(showDetails ? "common__hide_details" : "wallet__send_details"), size: .small,
+                     icon: Image(showDetails ? "eye-slash" : "git-branch").resizable().frame(width: 16, height: 16)
+                         .foregroundColor(.usdtAccent), isDisabled: busy || recoveryActive, shouldExpand: true) { showDetails.toggle() }
+            .accessibilityIdentifier("UsdtDepositDetails")
+    }
+
+    private func clearSelection() {
+        selected = nil
+        message = nil
+        error = nil
+        refundAddress = ""
+        approved = nil
+        showDetails = true
+    }
+
     private func amount(_ value: UInt64?) -> String {
         (settings.hideBalance ? " • • • • •" : value.map { usdtOverviewAmount($0) } ?? "—") + " USDT"
     }
@@ -184,14 +247,24 @@ struct UsdtDepositHistoryView: View {
                 refundAddress = ""
                 approved = nil
                 message = nil
+                showDetails = true
             }
             if ["completed", "refunded"].contains(detail.order?.status ?? detail.deposit.status) {
                 message = nil
             }
-            selected = detail
+            updateSelection(detail)
         } catch is CancellationError {} catch { self.error = UsdtWalletManager.message(for: error) }
     }
 
+    private func updateSelection(_ detail: UsdtDepositDetail) {
+        selected = detail
+        if let index = deposits.firstIndex(where: { $0.id == detail.deposit.id }) {
+            deposits[index].status = detail.order?.status ?? detail.deposit.status
+            deposits[index].code = detail.statusCode
+            deposits[index].refundTx = detail.order?.refundTx ?? detail.deposit.refundTx
+        }
+    }
+
     private func authorizeRefund() async {
         guard !busy else { return }
         defer { if !pin { approved = nil } }
@@ -226,7 +299,7 @@ struct UsdtDepositHistoryView: View {
             acknowledged.deposit.code = nil
             acknowledged.order?.status = "refund_requested"
             acknowledged.order?.code = nil
-            self.selected = acknowledged
+            updateSelection(acknowledged)
             message = t("usdt__deposit_refund_requested")
         } catch { self.error = UsdtWalletManager.message(for: error) }
     }
@@ -239,6 +312,28 @@ private struct RefundApproval {
 }
 
 extension UsdtDepositDetail {
+    var canRequestRefund: Bool {
+        deposit.asset == "USDT" && UsdtDepositNetwork.named(deposit.network) != nil &&
+            !["completed", "refunded", "refunding", "refund_requested"].contains(order?.status ?? deposit.status)
+    }
+
+    var statusIcon: String {
+        ["completed", "refunded"].contains(order?.status ?? deposit.status) ? "check-circle" : "hourglass-simple"
+    }
+
+    var statusColor: Color {
+        ["completed", "refunded"].contains(order?.status ?? deposit.status) ? .usdtAccent : .yellowAccent
+    }
+
+    func refundConfirmation(address: String, hideBalance: Bool) -> String {
+        t("usdt__deposit_refund_confirmation", variables: [
+            "amount": hideBalance ? "• • • • •" : deposit.amount.map { usdtFormatAmount(amount: $0) } ?? "—",
+            "network": UsdtDepositNetwork.named(deposit.network) == .bsc ? "BNB Smart Chain (BSC)" : deposit.networkLabel,
+            "shortNetwork": deposit.refundNetworkLabel,
+            "address": address,
+        ])
+    }
+
     var statusCode: String? {
         if let order { return order.code }
         return deposit.code
@@ -260,3 +355,44 @@ private func depositStatusText(_ status: String, code: String?) -> String {
     default: t("usdt__deposit_needs_attention")
     }
 }
+
+extension UsdtDeposit {
+    var networkLabel: String {
+        UsdtDepositNetwork.named(network)?.label ?? network
+    }
+
+    var refundNetworkLabel: String {
+        UsdtDepositNetwork.named(network) == .bsc ? "BSC" : networkLabel
+    }
+
+    var statusText: String {
+        depositStatusText(status, code: code)
+    }
+}
+
+struct UsdtDepositRow: View {
+    let deposit: UsdtDeposit
+    let hideBalance: Bool
+
+    private var amount: String {
+        hideBalance ? "• • • • •" : deposit.amount.map { usdtOverviewAmount($0) } ?? "—"
+    }
+
+    var body: some View {
+        let completed = ["completed", "refunded"].contains(deposit.status)
+        let color: Color = completed ? .usdtAccent : .yellowAccent
+        ActivityRowContainer {
+            ActivityRowContent(title: deposit.networkLabel, subtitle: deposit.statusText) {
+                CircularIcon(icon: completed ? "check-circle" : "hourglass-simple", iconColor: color,
+                             backgroundColor: color.opacity(0.16), size: 40)
+            } amount: {
+                VStack(alignment: .trailing, spacing: 2) {
+                    BodyMSBText(deposit.asset == "USDT" ? amount + " USDT" : deposit.asset).lineLimit(1).minimumScaleFactor(0.7)
+                    if deposit.asset == "USDT" {
+                        CaptionBText(hideBalance ? amount : "$ " + amount, textColor: .textSecondary)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index 6efad8f9f..58801609a 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -6,19 +6,19 @@ struct UsdtReceiveView: View {
     let onSelectTab: (ReceiveQr.ReceiveTab) -> Void
     var contactAction: AnyView?
     @Environment(UsdtWalletManager.self) private var usdt
+    @EnvironmentObject private var navigation: NavigationViewModel
     @EnvironmentObject private var sheets: SheetViewModel
     @Environment(\.scenePhase) private var scenePhase
     @State private var networks: [UsdtDepositNetwork] = []
     @State private var network: UsdtDepositNetwork?
     @State private var page = Page.address
-    @State private var historyBlocking = false
     @State private var amount = ""
     @State private var draftAmount = ""
     @State private var deposit: UsdtDepositAddress?
     @State private var busy = false
     @State private var error: String?
 
-    private enum Page { case address, networks, amount, fees, history }
+    private enum Page { case address, networks, amount, fees }
 
     private var networkName: String {
         network?.label ?? "Arbitrum One"
@@ -30,7 +30,6 @@ struct UsdtReceiveView: View {
         case .networks: t("usdt__receive_network_title")
         case .amount: t("wallet__receive_amount")
         case .fees: t("usdt__receive_fees_title")
-        case .history: t("usdt__deposit_history")
         }
     }
 
@@ -49,7 +48,7 @@ struct UsdtReceiveView: View {
                             else if page == .amount, network != nil, deposit == nil { page = .networks }
                             else { if deposit == nil { network = nil }; page = .address }
                         })
-                        .disabled(busy || historyBlocking)
+                        .disabled(busy)
             switch page {
             case .address:
                 SegmentedControl(selectedTab: Binding(get: { .usdt }, set: onSelectTab), tabItems: tabs)
@@ -68,15 +67,13 @@ struct UsdtReceiveView: View {
                 amountEntry
             case .fees:
                 if let deposit { feeEstimate(deposit) }
-            case .history:
-                UsdtDepositHistoryView(onBlockingChange: { historyBlocking = $0 })
             }
         }
         .padding(.horizontal, 16)
         .background(Color.gray7)
         .preference(key: SheetBackgroundPreferenceKey.self, value: .gray7)
         .onReceive(usdt.receivedTxPublisher) { transfer in
-            guard !historyBlocking, sheets.activeSheetConfiguration?.id == .receive else { return }
+            guard sheets.activeSheetConfiguration?.id == .receive else { return }
             sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: transfer.amount, usdtTransferId: transfer.id))
         }
         .task(id: scenePhase) {
@@ -99,8 +96,11 @@ struct UsdtReceiveView: View {
                 ForEach(networks, id: \.self) { networkRow($0) }
             }
             if usdt.depositsConfigured {
-                CustomButton(title: t("usdt__deposit_history"), variant: .tertiary) { page = .history }
-                    .accessibilityIdentifier("UsdtDepositHistory")
+                CustomButton(title: t("usdt__deposit_history"), variant: .tertiary) {
+                    sheets.hideSheet()
+                    navigation.navigate(.usdtDepositHistory)
+                }
+                .accessibilityIdentifier("UsdtDepositHistory")
             }
             if let error { BodySText(error, textColor: .textSecondary) }
         }
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index 13c76476e..b2abee773 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -4,6 +4,7 @@ import SwiftUI
 struct UsdtWalletScreen: View {
     @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject private var settings: SettingsViewModel
+    @EnvironmentObject private var navigation: NavigationViewModel
     @EnvironmentObject private var sheets: SheetViewModel
     @State private var showSend = false
     @State private var selectedTransferId: String?
@@ -72,7 +73,7 @@ struct UsdtWalletScreen: View {
         .padding(.horizontal, 16)
         .navigationBarHidden(true)
         .onReceive(usdt.receivedTxPublisher) { tx in
-            guard !showSend, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
+            guard navigation.currentRoute != .usdtDepositHistory, !showSend, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
             sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount, usdtTransferId: tx.id))
         }
         .sheet(isPresented: $showSend) {
@@ -168,7 +169,7 @@ extension UsdtTransferStatus {
         case .pending: t("usdt__pending")
         case .confirmed: t("usdt__confirmed")
         case .failed: t("usdt__failed")
-        case .bridging: t("wallet__activity_transferring")
+        case .bridging: t("usdt__delivering")
         case .bridgeNeedsAttention, .bridgeFailed: t("usdt__bridge_attention")
         case .replaced: t("usdt__replaced")
         case .bridgeRefunded: t("usdt__deposit_refunded")
diff --git a/BitkitTests/UsdtPaymentLinkTests.swift b/BitkitTests/UsdtPaymentLinkTests.swift
index 2af019373..37c4fe51d 100644
--- a/BitkitTests/UsdtPaymentLinkTests.swift
+++ b/BitkitTests/UsdtPaymentLinkTests.swift
@@ -8,6 +8,10 @@ final class UsdtPaymentLinkTests: XCTestCase {
         "ethereum:\(PaykitUsdt.token)@42161/transfer?address=\(recipient)"
     }
 
+    func testDepositHistoryDefersIncomingCelebrationDuringRefundReview() {
+        XCTAssertTrue(Route.usdtDepositHistory.isUsdtWalletRoute)
+    }
+
     func testPaymentLinkPreservesOptionalAtomicAmount() throws {
         XCTAssertEqual(try resolveUsdtPaymentRoute(input: uri, isEnabled: true), .usdtPayment(recipient: recipient, amount: ""))
         XCTAssertEqual(try resolveUsdtPaymentRoute(input: " \(uri)&uint256=10001\n", isEnabled: true),
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index a4a8776c7..edc89bdba 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -280,6 +280,40 @@ final class UsdtWalletManagerTests: XCTestCase {
         }
     }
 
+    func testDepositRefundEligibilityUsesCurrentOrderAndSupportedAsset() {
+        let deposit = UsdtDeposit(id: "deposit", network: "bsc", asset: "USDT", amount: 50_000_001,
+                                  sourceTx: "source-tx", status: "held", code: nil, refundTx: nil)
+        var detail = UsdtDepositDetail(deposit: deposit, order: nil)
+        XCTAssertTrue(detail.canRequestRefund)
+        for status in ["completed", "refunded", "refunding", "refund_requested"] {
+            detail.order = UsdtDepositOrder(status: status, amountIn: nil, amountOut: nil, destinationTx: nil, refundTx: nil, code: nil)
+            XCTAssertFalse(detail.canRequestRefund, status)
+        }
+        detail.order = nil
+        detail.deposit.asset = "ETH"
+        XCTAssertFalse(detail.canRequestRefund)
+        detail.deposit.asset = "USDT"
+        detail.deposit.network = "unsupported"
+        XCTAssertFalse(detail.canRequestRefund)
+    }
+
+    func testRefundConfirmationShowsExactAmountNetworkAndFullAddress() {
+        let address = "0x1111222233334444555566667777888899990000"
+        let deposit = UsdtDeposit(id: "deposit", network: "bsc", asset: "USDT", amount: 50_000_001,
+                                  sourceTx: "source-tx", status: "held", code: nil, refundTx: nil)
+        let detail = UsdtDepositDetail(deposit: deposit, order: nil)
+        let confirmation = detail.refundConfirmation(address: address, hideBalance: false)
+        for value in ["50.000001", "BNB Smart Chain (BSC)", address, "Refund fees may apply."] {
+            XCTAssertTrue(confirmation.contains(value), value)
+        }
+        let hidden = detail.refundConfirmation(address: address, hideBalance: true)
+        XCTAssertFalse(hidden.contains("50.000001"))
+        XCTAssertTrue(hidden.contains("• • • • •"))
+        XCTAssertTrue(hidden.contains(address))
+        XCTAssertEqual(deposit.networkLabel, "BNB Smart Chain")
+        XCTAssertEqual(deposit.refundNetworkLabel, "BSC")
+    }
+
     private func transfer(_ id: String, incoming: Bool = true, status: UsdtTransferStatus = .confirmed, amount: UInt64 = 1_000_000) -> UsdtTransfer {
         UsdtTransfer(
             sender: nil,
diff --git a/journeys/usdt-bridge-details.xml b/journeys/usdt-bridge-details.xml
new file mode 100644
index 000000000..7da55ab68
--- /dev/null
+++ b/journeys/usdt-bridge-details.xml
@@ -0,0 +1,16 @@
+<journey name="usdt bridge details">
+  <description>Use an isolated provider fixture with a pending Arbitrum receipt, an outgoing Orchestra transfer that is delivering, and supported and unsupported provider deposits. No funded wallet, payment submission, support submission or real refund is required. Native Android and iOS confirmation dialogs differ in platform styling.</description>
+  <actions>
+    <action>Open the pending incoming USDT activity. Verify the Receiving USDT title, incoming amount, teal down arrow, yellow Pending status, receiving network, date, time, payment and available fee.</action>
+    <action>Tap Details (id "UsdtActivityDetails"). Verify the real wallet transaction and available addresses are shown without inventing a provider deposit reference or refund eligibility.</action>
+    <action>Open Cross-Network Deposits (id "UsdtDepositHistory"). Verify the Provider Status note says the spendable balance updates when USDT arrives on Arbitrum, and each row shows its source network, provider status and available amount.</action>
+    <action>Open a supported deposit that needs attention (id "UsdtDepositRow-{depositId}"). Verify its own source transaction and deposit reference are shown. Verify the refund instructions and address placeholder name that deposit's source network.</action>
+    <action>Enter an owned test refund address (id "UsdtRefundAddress") and tap Request Refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the exact deposit amount, network, full refund address and refund fee note. Cancel without submitting.</action>
+    <action>Tap Hide details (id "UsdtDepositDetails"), then Details again. Verify the provider status remains separate from wallet activity and the entered refund address is retained.</action>
+    <action>Open completed, refunded and refund-in-progress deposit fixtures. Verify Request Refund is unavailable and the current provider status and available refund transaction are shown. An unsupported asset or network must show support guidance instead of a refund form.</action>
+    <action>Open the outgoing delivering USDT activity. Verify the Delivering USDT title, outgoing amount, teal up arrow, yellow Delivering status and actual receiving network.</action>
+    <action>Tap Details (id "UsdtActivityDetails"). Verify the source transaction, sender and recipient addresses, sender and recipient networks, Orchestra provider and bridge reference. Verify Open Block Explorer (id "UsdtActivityExplorer") and Hide details remain reachable.</action>
+    <action>For a delayed, failed, refunding, refunded or support-needed bridge fixture, verify Contact Support (id "UsdtContactSupport") and Copy Details (id "UsdtCopyDetails") remain reachable from its details without submitting either action.</action>
+    <action>Open USDT Receive, then Network. Verify Cross-Network Deposits (id "UsdtDepositHistory") remains reachable before any Arbitrum receipt exists.</action>
+  </actions>
+</journey>
diff --git a/journeys/usdt-bridge-support.xml b/journeys/usdt-bridge-support.xml
index 0a159188a..7d090b692 100644
--- a/journeys/usdt-bridge-support.xml
+++ b/journeys/usdt-bridge-support.xml
@@ -6,11 +6,11 @@
     <action>Tap Details (id "UsdtActivityDetails"), then verify the source transaction is displayed. For an Orchestra transfer, verify the bridge reference is also displayed.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard contains the bridge, networks, status and available transaction references.</action>
     <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with those details prefilled and remains unsent. Return without submitting.</action>
-    <action>Open USDT Receive, then Network, scroll to Cross-network Deposits (id "UsdtDepositHistory") and open it. Verify rows show Details rather than a transfer status, then open a deposit.</action>
+    <action>Open USDT Receive, then Network, scroll to Cross-Network Deposits (id "UsdtDepositHistory") and open it. Verify rows show the source network and provider status, then open a deposit.</action>
     <action>For a deposit whose conversion order is funded, confirming, swapping, bridging or delivering without an error, verify Pending is shown. Refresh after completion and verify Confirmed. An active order with an explicit error, or an unknown status, must show Needs attention.</action>
     <action>For a refunded deposit, verify the detail shows Refunded, even when an earlier error code is retained. Verify the transaction is labeled Refund transaction in the detail. Verify no pending-refund notice remains after refreshing the completed refund.</action>
     <action>For a refund in progress, verify Refunding is shown for the provider's pending acknowledgment. A refund requiring operator intervention must still show Needs attention.</action>
     <action>Tap Copy Details (id "UsdtCopyDetails"). Verify the clipboard includes the deposit reference, source network and source transaction, plus the current status and any destination or refund transaction.</action>
-    <action>Tap Contact Support (id "UsdtContactSupport"). Verify the receive sheet closes and the report form opens with the deposit details prefilled. Return without submitting or requesting a refund.</action>
+    <action>Tap Contact Support (id "UsdtContactSupport"). Verify the report form opens with the deposit details prefilled. Return without submitting or requesting a refund.</action>
   </actions>
 </journey>

From 810858ae67bb408c3d040bf1b9202129ecfa0fbe Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 13:24:42 -0500
Subject: [PATCH 53/62] Align USDT bridge typography and spacing with designs

---
 Bitkit/Components/Button/Button.swift         | 22 +++++-
 .../Components/Button/PrimaryButtonView.swift |  6 +-
 .../Button/SecondaryButtonView.swift          |  6 +-
 .../Button/TertiaryButtonView.swift           |  4 +-
 Bitkit/Components/NavigationBar.swift         |  8 +-
 Bitkit/Components/TextField.swift             | 11 ++-
 Bitkit/Styles/TextStyle.swift                 | 52 ++++++++++--
 .../Views/Wallets/Activity/ActivityRow.swift  | 10 ++-
 Bitkit/Views/Wallets/UsdtActivityDetail.swift | 55 +++++++------
 .../Wallets/UsdtDepositHistoryView.swift      | 79 ++++++++++++-------
 10 files changed, 179 insertions(+), 74 deletions(-)

diff --git a/Bitkit/Components/Button/Button.swift b/Bitkit/Components/Button/Button.swift
index 447a40528..9d90795dc 100644
--- a/Bitkit/Components/Button/Button.swift
+++ b/Bitkit/Components/Button/Button.swift
@@ -60,6 +60,8 @@ struct CustomButton: View {
     }
 
     let title: String
+    let titleKerning: CGFloat
+    let titleLineHeight: CGFloat?
     let variant: Variant
     let size: Size
     let icon: AnyView?
@@ -85,9 +87,13 @@ struct CustomButton: View {
         isDisabled: Bool = false,
         isLoading: Bool = false,
         shouldExpand: Bool = false,
-        background: (any View)? = nil
+        background: (any View)? = nil,
+        titleKerning: CGFloat = 0.4,
+        titleLineHeight: CGFloat? = nil
     ) {
         self.title = title
+        self.titleKerning = titleKerning
+        self.titleLineHeight = titleLineHeight
         self.variant = variant
         self.size = size
         self.icon = icon.map { AnyView($0) }
@@ -109,9 +115,13 @@ struct CustomButton: View {
         isLoading: Bool = false,
         shouldExpand: Bool = false,
         background: (any View)? = nil,
+        titleKerning: CGFloat = 0.4,
+        titleLineHeight: CGFloat? = nil,
         action: @escaping () async -> Void
     ) {
         self.title = title
+        self.titleKerning = titleKerning
+        self.titleLineHeight = titleLineHeight
         self.variant = variant
         self.size = size
         self.icon = icon.map { AnyView($0) }
@@ -133,9 +143,13 @@ struct CustomButton: View {
         isLoading: Bool = false,
         shouldExpand: Bool = false,
         background: (any View)? = nil,
+        titleKerning: CGFloat = 0.4,
+        titleLineHeight: CGFloat? = nil,
         destination: some View
     ) {
         self.title = title
+        self.titleKerning = titleKerning
+        self.titleLineHeight = titleLineHeight
         self.variant = variant
         self.size = size
         self.icon = icon.map { AnyView($0) }
@@ -152,6 +166,8 @@ struct CustomButton: View {
         case .primary:
             AnyView(PrimaryButtonView(
                 title: title,
+                titleKerning: titleKerning,
+                titleLineHeight: titleLineHeight,
                 size: size,
                 icon: icon,
                 isDisabled: effectiveIsDisabled,
@@ -163,6 +179,8 @@ struct CustomButton: View {
         case .secondary:
             AnyView(SecondaryButtonView(
                 title: title,
+                titleKerning: titleKerning,
+                titleLineHeight: titleLineHeight,
                 size: size,
                 icon: icon,
                 isDisabled: effectiveIsDisabled,
@@ -173,6 +191,8 @@ struct CustomButton: View {
         case .tertiary:
             AnyView(TertiaryButtonView(
                 title: title,
+                titleKerning: titleKerning,
+                titleLineHeight: titleLineHeight,
                 icon: icon,
                 isPressed: isPressed
             ))
diff --git a/Bitkit/Components/Button/PrimaryButtonView.swift b/Bitkit/Components/Button/PrimaryButtonView.swift
index 00dc27cdb..88094ba63 100644
--- a/Bitkit/Components/Button/PrimaryButtonView.swift
+++ b/Bitkit/Components/Button/PrimaryButtonView.swift
@@ -2,6 +2,8 @@ import SwiftUI
 
 struct PrimaryButtonView: View {
     let title: String
+    var titleKerning: CGFloat = 0.4
+    var titleLineHeight: CGFloat?
     let size: CustomButton.Size
     let icon: AnyView?
     let isDisabled: Bool
@@ -22,9 +24,9 @@ struct PrimaryButtonView: View {
                     .frame(width: 20, height: 20)
             } else {
                 if size == .small {
-                    CaptionBText(title, textColor: .textPrimary)
+                    CaptionBText(title, textColor: .textPrimary, kerning: titleKerning, lineHeight: titleLineHeight)
                 } else {
-                    BodySSBText(title, textColor: .textPrimary)
+                    BodySSBText(title, textColor: .textPrimary, kerning: titleKerning, lineHeight: titleLineHeight)
                 }
             }
         }
diff --git a/Bitkit/Components/Button/SecondaryButtonView.swift b/Bitkit/Components/Button/SecondaryButtonView.swift
index 7f6c8f433..16647e900 100644
--- a/Bitkit/Components/Button/SecondaryButtonView.swift
+++ b/Bitkit/Components/Button/SecondaryButtonView.swift
@@ -2,6 +2,8 @@ import SwiftUI
 
 struct SecondaryButtonView: View {
     let title: String
+    var titleKerning: CGFloat = 0.4
+    var titleLineHeight: CGFloat?
     let size: CustomButton.Size
     let icon: AnyView?
     let isDisabled: Bool
@@ -20,9 +22,9 @@ struct SecondaryButtonView: View {
                     .progressViewStyle(CircularProgressViewStyle(tint: textColor))
                     .frame(width: 20, height: 20)
             } else if size == .small {
-                CaptionBText(title, textColor: textColor)
+                CaptionBText(title, textColor: textColor, kerning: titleKerning, lineHeight: titleLineHeight)
             } else {
-                BodySSBText(title, textColor: textColor)
+                BodySSBText(title, textColor: textColor, kerning: titleKerning, lineHeight: titleLineHeight)
             }
         }
         .frame(maxWidth: (size == .large || shouldExpand) ? .infinity : nil)
diff --git a/Bitkit/Components/Button/TertiaryButtonView.swift b/Bitkit/Components/Button/TertiaryButtonView.swift
index 50f76a3b7..e6539d251 100644
--- a/Bitkit/Components/Button/TertiaryButtonView.swift
+++ b/Bitkit/Components/Button/TertiaryButtonView.swift
@@ -2,6 +2,8 @@ import SwiftUI
 
 struct TertiaryButtonView: View {
     let title: String
+    var titleKerning: CGFloat = 0.4
+    var titleLineHeight: CGFloat?
     let icon: AnyView?
     let isPressed: Bool
 
@@ -11,7 +13,7 @@ struct TertiaryButtonView: View {
                 icon
             }
 
-            BodySSBText(title, textColor: textColor)
+            BodySSBText(title, textColor: textColor, kerning: titleKerning, lineHeight: titleLineHeight)
         }
         .frame(maxWidth: .infinity)
         .frame(height: CustomButton.Size.large.height)
diff --git a/Bitkit/Components/NavigationBar.swift b/Bitkit/Components/NavigationBar.swift
index 36fb13dbb..817911b23 100644
--- a/Bitkit/Components/NavigationBar.swift
+++ b/Bitkit/Components/NavigationBar.swift
@@ -9,6 +9,8 @@ struct NavigationBar: View {
     let showMenuButton: Bool
     let action: AnyView?
     let icon: String?
+    let titleKerning: CGFloat
+    let titleLineHeight: CGFloat?
     let onBack: (() -> Void)?
 
     init(
@@ -17,9 +19,13 @@ struct NavigationBar: View {
         showMenuButton: Bool = true,
         action: AnyView? = nil,
         icon: String? = nil,
+        titleKerning: CGFloat = 0.4,
+        titleLineHeight: CGFloat? = nil,
         onBack: (() -> Void)? = nil
     ) {
         self.title = title
+        self.titleKerning = titleKerning
+        self.titleLineHeight = titleLineHeight
         self.showBackButton = showBackButton
         self.showMenuButton = showMenuButton
         self.action = action
@@ -63,7 +69,7 @@ struct NavigationBar: View {
                         .padding(.trailing, 16)
                 }
 
-                TitleText(title)
+                TitleText(title, kerning: titleKerning, lineHeight: titleLineHeight)
             }
             .frame(maxWidth: .infinity, alignment: .center)
 
diff --git a/Bitkit/Components/TextField.swift b/Bitkit/Components/TextField.swift
index 20c1dc49f..9b806a73f 100644
--- a/Bitkit/Components/TextField.swift
+++ b/Bitkit/Components/TextField.swift
@@ -3,6 +3,8 @@ import SwiftUI
 struct TextField: View {
     let placeholder: String
     let backgroundColor: Color
+    let placeholderColor: Color
+    let minContentHeight: CGFloat?
     let font: Font
     let axis: Axis
     let testIdentifier: String?
@@ -18,9 +20,13 @@ struct TextField: View {
         axis: Axis = .horizontal,
         testIdentifier: String? = nil,
         submitLabel: SubmitLabel = .return,
-        contentPadding: CGFloat = 16
+        contentPadding: CGFloat = 16,
+        placeholderColor: Color = .secondary,
+        minContentHeight: CGFloat? = nil
     ) {
         self.placeholder = placeholder
+        self.placeholderColor = placeholderColor
+        self.minContentHeight = minContentHeight
         self.backgroundColor = backgroundColor
         self.font = font
         self.axis = axis
@@ -34,7 +40,7 @@ struct TextField: View {
         ZStack(alignment: .leading) {
             if text.isEmpty {
                 Text(placeholder)
-                    .foregroundColor(.secondary)
+                    .foregroundColor(placeholderColor)
                     .font(font)
             }
 
@@ -44,6 +50,7 @@ struct TextField: View {
                 .submitLabel(submitLabel)
                 .accessibilityIdentifierIfPresent(testIdentifier)
         }
+        .frame(minHeight: minContentHeight)
         .padding(contentPadding)
         .background(backgroundColor)
         .cornerRadius(8)
diff --git a/Bitkit/Styles/TextStyle.swift b/Bitkit/Styles/TextStyle.swift
index 5f08a3eba..9a8706e36 100644
--- a/Bitkit/Styles/TextStyle.swift
+++ b/Bitkit/Styles/TextStyle.swift
@@ -14,6 +14,7 @@ struct DisplayText: View {
     var accentAction: (() -> Void)?
     var fillsWidth: Bool
     var kerning: CGFloat
+    var lineHeight: CGFloat?
 
     private let fontSize: CGFloat = 44
 
@@ -24,7 +25,8 @@ struct DisplayText: View {
         accentFont: ((CGFloat) -> Font)? = nil,
         accentAction: (() -> Void)? = nil,
         fillsWidth: Bool = true,
-        kerning: CGFloat = -1
+        kerning: CGFloat = -1,
+        lineHeight: CGFloat? = nil
     ) {
         self.text = text
         self.textColor = textColor
@@ -33,6 +35,7 @@ struct DisplayText: View {
         self.accentAction = accentAction
         self.fillsWidth = fillsWidth
         self.kerning = kerning
+        self.lineHeight = lineHeight
     }
 
     var body: some View {
@@ -45,7 +48,9 @@ struct DisplayText: View {
             accentAction: accentAction
         )
         .kerning(kerning)
-        .environment(\._lineHeightMultiple, 0.83)
+        .environment(\._lineHeightMultiple, lineHeight.map {
+            $0 / (UIFont(name: Fonts.black, size: fontSize)?.lineHeight ?? fontSize)
+        } ?? 0.83)
         .textCase(.uppercase)
         .padding(.bottom, -9)
         .frame(maxWidth: fillsWidth ? .infinity : nil, alignment: .leading)
@@ -98,6 +103,9 @@ struct TitleText: View {
     var accentColor: Color = .brandAccent
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
+    var kerning: CGFloat
+
+    var lineHeight: CGFloat?
 
     private let fontSize: CGFloat = 22
 
@@ -106,9 +114,13 @@ struct TitleText: View {
         textColor: Color = .textPrimary,
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
-        accentAction: (() -> Void)? = nil
+        accentAction: (() -> Void)? = nil,
+        kerning: CGFloat = 0.4,
+        lineHeight: CGFloat? = nil
     ) {
         self.text = text
+        self.lineHeight = lineHeight
+        self.kerning = kerning
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
@@ -124,7 +136,12 @@ struct TitleText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
-        .kerning(0.4)
+        .transformEnvironment(\._lineHeightMultiple) { value in
+            if let lineHeight, let font = UIFont(name: Fonts.bold, size: fontSize) {
+                value = lineHeight / font.lineHeight
+            }
+        }
+        .kerning(kerning)
     }
 }
 
@@ -221,6 +238,8 @@ struct BodyMSBText: View {
     var accentAction: (() -> Void)?
     var kerning: CGFloat
 
+    var lineHeight: CGFloat?
+
     private let fontSize: CGFloat = 17
 
     init(
@@ -229,9 +248,11 @@ struct BodyMSBText: View {
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
         accentAction: (() -> Void)? = nil,
-        kerning: CGFloat = 0.4
+        kerning: CGFloat = 0.4,
+        lineHeight: CGFloat? = nil
     ) {
         self.text = text
+        self.lineHeight = lineHeight
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
@@ -248,6 +269,11 @@ struct BodyMSBText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
+        .transformEnvironment(\._lineHeightMultiple) { value in
+            if let lineHeight, let font = UIFont(name: Fonts.semiBold, size: fontSize) {
+                value = lineHeight / font.lineHeight
+            }
+        }
         .kerning(kerning)
     }
 }
@@ -340,6 +366,7 @@ struct BodySSBText: View {
     var accentColor: Color = .brandAccent
     var accentFont: ((CGFloat) -> Font)?
     var accentAction: (() -> Void)?
+    var kerning: CGFloat
 
     var lineHeight: CGFloat?
 
@@ -351,10 +378,12 @@ struct BodySSBText: View {
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
         accentAction: (() -> Void)? = nil,
+        kerning: CGFloat = 0.4,
         lineHeight: CGFloat? = nil
     ) {
         self.lineHeight = lineHeight
         self.text = text
+        self.kerning = kerning
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
@@ -375,7 +404,7 @@ struct BodySSBText: View {
                 value = lineHeight / font.lineHeight
             }
         }
-        .kerning(0.4)
+        .kerning(kerning)
         // .lineSpacing(0)
     }
 }
@@ -423,6 +452,8 @@ struct CaptionBText: View {
     var accentAction: (() -> Void)?
     var kerning: CGFloat
 
+    var lineHeight: CGFloat?
+
     private let fontSize: CGFloat = 13
 
     init(
@@ -431,9 +462,11 @@ struct CaptionBText: View {
         accentColor: Color = .brandAccent,
         accentFont: ((CGFloat) -> Font)? = nil,
         accentAction: (() -> Void)? = nil,
-        kerning: CGFloat = 0.4
+        kerning: CGFloat = 0.4,
+        lineHeight: CGFloat? = nil
     ) {
         self.text = text
+        self.lineHeight = lineHeight
         self.textColor = textColor
         self.accentColor = accentColor
         self.accentFont = accentFont
@@ -450,6 +483,11 @@ struct CaptionBText: View {
             accentFont: accentFont?(fontSize),
             accentAction: accentAction
         )
+        .transformEnvironment(\._lineHeightMultiple) { value in
+            if let lineHeight, let font = UIFont(name: Fonts.semiBold, size: fontSize) {
+                value = lineHeight / font.lineHeight
+            }
+        }
         .kerning(kerning)
     }
 }
diff --git a/Bitkit/Views/Wallets/Activity/ActivityRow.swift b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
index 84a80f3b3..4b9cc32a7 100644
--- a/Bitkit/Views/Wallets/Activity/ActivityRow.swift
+++ b/Bitkit/Views/Wallets/Activity/ActivityRow.swift
@@ -84,15 +84,19 @@ struct ActivityRowContainer<Content: View>: View {
 struct ActivityRowContent<Icon: View, Amount: View>: View {
     let title: String
     let subtitle: String
+    var textKerning: CGFloat = 0.4
+    var titleLineHeight: CGFloat?
+    var subtitleLineHeight: CGFloat?
+    var textSpacing: CGFloat = 2
     @ViewBuilder var icon: () -> Icon
     @ViewBuilder var amount: () -> Amount
 
     var body: some View {
         HStack(spacing: 16) {
             icon()
-            VStack(alignment: .leading, spacing: 2) {
-                BodyMSBText(title).lineLimit(1)
-                CaptionBText(subtitle).lineLimit(1)
+            VStack(alignment: .leading, spacing: textSpacing) {
+                BodyMSBText(title, kerning: textKerning, lineHeight: titleLineHeight).lineLimit(1)
+                CaptionBText(subtitle, kerning: textKerning, lineHeight: subtitleLineHeight).lineLimit(1)
             }
             .fixedSize(horizontal: false, vertical: true)
             Spacer(minLength: 0)
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index 6e47a96d5..0f16af337 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -66,7 +66,7 @@ struct UsdtActivityDetail: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
-            NavigationBar(title: transfer?.detailTitle ?? t("usdt__sent_title"), onBack: { dismiss() })
+            NavigationBar(title: transfer?.detailTitle ?? t("usdt__sent_title"), titleKerning: 0, titleLineHeight: 26, onBack: { dismiss() })
                 .padding(.bottom, 16)
             if let transfer {
                 ScrollView(showsIndicators: false) {
@@ -82,7 +82,7 @@ struct UsdtActivityDetail: View {
                         CustomButton(
                             title: t(showDetails ? "common__hide_details" : "wallet__send_details"), size: .small,
                             icon: Image(showDetails ? "eye-slash" : "git-branch").resizable().frame(width: 16, height: 16)
-                                .foregroundColor(.usdtAccent), shouldExpand: true
+                                .foregroundColor(.usdtAccent), shouldExpand: true, titleKerning: 0, titleLineHeight: 13
                         ) { showDetails.toggle() }
                             .accessibilityIdentifier("UsdtActivityDetails")
                         if showDetails, let txHash = transfer.txHash {
@@ -104,11 +104,13 @@ struct UsdtActivityDetail: View {
                 }
                 .frame(maxHeight: .infinity, alignment: .top)
                 if showDetails, transfer.isIncoming, usdt.depositsConfigured {
-                    CustomButton(title: t("usdt__deposit_history"), shouldExpand: true) { navigation.navigate(.usdtDepositHistory) }
-                        .padding(.top, 24)
-                        .accessibilityIdentifier("UsdtDepositHistory")
+                    CustomButton(title: t("usdt__deposit_history"), shouldExpand: true, titleKerning: -0.4, titleLineHeight: 20) {
+                        navigation.navigate(.usdtDepositHistory)
+                    }
+                    .padding(.top, 24)
+                    .accessibilityIdentifier("UsdtDepositHistory")
                 } else if showDetails, let txHash = transfer.txHash {
-                    CustomButton(title: t("wallet__activity_explorer"), shouldExpand: true) {
+                    CustomButton(title: t("wallet__activity_explorer"), shouldExpand: true, titleKerning: -0.4, titleLineHeight: 20) {
                         if let url = URL(string: "https://arbiscan.io/tx/" + txHash) { openURL(url) }
                     }
                     .padding(.top, 24)
@@ -133,13 +135,13 @@ struct UsdtActivityDetail: View {
         HStack(alignment: .top, spacing: 16) {
             UsdtDetailCell(title: t("wallet__activity_status"), value: transfer.status.label,
                            icon: transfer.status == .confirmed ? "check-circle" : transfer.statusIcon,
-                           valueColor: transfer.statusColor, iconColor: transfer.statusColor)
+                           valueColor: transfer.statusColor, iconColor: transfer.statusColor, valueKerning: 0)
                 .accessibilityIdentifier("UsdtActivityStatus")
             UsdtDetailCell(title: t("usdt__receiving_network"), value: transfer.destination.label, icon: "usdt-network")
         }
         let time = DateFormatterHelpers.formatActivityDetail(transfer.timestamp)
         HStack(alignment: .top, spacing: 16) {
-            UsdtDetailCell(title: t("wallet__activity_date"), value: time.date, icon: "calendar")
+            UsdtDetailCell(title: t("wallet__activity_date"), value: time.date, icon: "calendar", valueKerning: 0)
             UsdtDetailCell(title: t("wallet__activity_time"), value: time.time, icon: "clock")
         }
         HStack(alignment: .top, spacing: 16) {
@@ -147,7 +149,7 @@ struct UsdtActivityDetail: View {
             UsdtDetailCell(title: t("wallet__activity_fee"), value: transfer.fee.map(displayedAmount) ?? "—", icon: "speed-normal")
         }
         if PaykitFeatureFlags.isUIAvailable, isPaykitUIEnabled, let key = PaykitUsdtPaymentService.shared.contact(for: transfer.id) {
-            SendSectionView(t("wallet__payment_request_contact"), labelKerning: 1, labelLineHeight: 18) {
+            SendSectionView(t("wallet__payment_request_contact"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
                 BodySSBText(contacts.contacts.first { PubkyPublicKeyFormat.matches($0.publicKey, key) }?.displayName
                     ?? PubkyPublicKeyFormat.displayTruncated(key), lineHeight: 20)
             }
@@ -157,17 +159,17 @@ struct UsdtActivityDetail: View {
     @ViewBuilder
     private func technicalDetails(_ transfer: UsdtTransfer) -> some View {
         if let txHash = transfer.txHash {
-            SendSectionView(t("wallet__activity_tx_id"), labelKerning: 1, labelLineHeight: 18) {
-                BodySSBText(txHash, lineHeight: 20).textSelection(.enabled)
+            SendSectionView(t("wallet__activity_tx_id"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                BodySSBText(txHash, kerning: 0, lineHeight: 20).textSelection(.enabled)
             }
         }
         if let sender = transfer.sender ?? (!transfer.isIncoming && !usdt.address.isEmpty ? usdt.address : nil) {
-            SendSectionView(t("usdt__from_address"), labelKerning: 1, labelLineHeight: 18) {
-                BodySSBText(sender, lineHeight: 20).textSelection(.enabled)
+            SendSectionView(t("usdt__from_address"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                BodySSBText(sender, kerning: 0, lineHeight: 20).textSelection(.enabled)
             }
         }
-        SendSectionView(t("usdt__to_address"), labelKerning: 1, labelLineHeight: 18) {
-            BodySSBText(transfer.recipient, lineHeight: 20).textSelection(.enabled)
+        SendSectionView(t("usdt__to_address"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+            BodySSBText(transfer.recipient, kerning: 0, lineHeight: 20).textSelection(.enabled)
         }
         HStack(alignment: .top, spacing: 16) {
             if !transfer.isIncoming {
@@ -180,21 +182,21 @@ struct UsdtActivityDetail: View {
             UsdtDetailCell(title: t("usdt__bridge_reference"), value: bridge.quoteId, icon: "note")
                 .textSelection(.enabled)
             if let hash = bridge.destinationTx {
-                SendSectionView(t("usdt__destination_tx"), labelKerning: 1, labelLineHeight: 18) {
-                    BodySSBText(hash, lineHeight: 20).textSelection(.enabled)
+                SendSectionView(t("usdt__destination_tx"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                    BodySSBText(hash, kerning: 0, lineHeight: 20).textSelection(.enabled)
                 }
             }
             if let amount = bridge.refundAmount, let hash = bridge.refundTx {
-                SendSectionView(t("usdt__deposit_refunded"), labelKerning: 1, labelLineHeight: 18) { amountText(amount) }
-                SendSectionView(t("usdt__refund_tx"), labelKerning: 1, labelLineHeight: 18) {
-                    BodySSBText(hash, lineHeight: 20).textSelection(.enabled)
+                SendSectionView(t("usdt__deposit_refunded"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) { amountText(amount) }
+                SendSectionView(t("usdt__refund_tx"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                    BodySSBText(hash, kerning: 0, lineHeight: 20).textSelection(.enabled)
                 }
             }
         }
         if transfer.destination != .arbitrum, ![.failed, .replaced, .bridgeRefunded].contains(transfer.status) {
             SendSectionView(
                 t(transfer.status == .confirmed ? "usdt__recipient_gets" : "usdt__expected_amount"),
-                labelKerning: 1,
+                dividerSpacing: 15, labelKerning: 1,
                 labelLineHeight: 18
             ) {
                 amountText(transfer.receivedAmount)
@@ -269,13 +271,14 @@ struct UsdtDetailCell: View {
     let icon: String
     var valueColor: Color = .textPrimary
     var iconColor: Color = .usdtAccent
+    var valueKerning: CGFloat = 0.4
     var minimumValueHeight: CGFloat = 20
 
     var body: some View {
-        SendSectionView(title, labelKerning: 1, labelLineHeight: 18) {
+        SendSectionView(title, dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
             HStack(spacing: 4) {
                 Image(icon).resizable().scaledToFit().frame(width: 16, height: 16).foregroundColor(iconColor)
-                BodySSBText(value, textColor: valueColor, lineHeight: 20)
+                BodySSBText(value, textColor: valueColor, kerning: valueKerning, lineHeight: 20)
             }
             .frame(minHeight: 20, alignment: .leading)
             .frame(minHeight: minimumValueHeight, alignment: .topLeading)
@@ -297,9 +300,9 @@ struct UsdtActivityAmountHeader: View {
             CaptionMText(hideBalance ? displayedAmount : "$ " + displayedAmount, kerning: 1, lineHeight: 18)
             HStack(spacing: 16) {
                 HStack(spacing: 6) {
-                    DisplayText("<accent>\(isIncoming ? "+" : "−")</accent>",
-                                accentColor: .textSecondary, accentFont: Fonts.extraBold, fillsWidth: false)
-                    DisplayText(displayedAmount).lineLimit(1).minimumScaleFactor(0.5)
+                    DisplayText("<accent>\(isIncoming ? "+" : "-")</accent>",
+                                accentColor: .textSecondary, accentFont: Fonts.extraBold, fillsWidth: false, lineHeight: 44)
+                    DisplayText(displayedAmount, lineHeight: 44).lineLimit(1).minimumScaleFactor(0.5)
                 }
                 CircularIcon(icon: isIncoming ? "arrow-down" : "arrow-up", iconColor: .usdtAccent,
                              backgroundColor: .usdtAccent.opacity(0.16), size: 48)
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index a1beab28f..15471410c 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -25,10 +25,15 @@ struct UsdtDepositHistoryView: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
-            NavigationBar(title: selected == nil ? t("usdt__deposit_history") : t("usdt__receiving_title"), onBack: {
-                if selected == nil { dismiss() }
-                else { clearSelection() }
-            })
+            NavigationBar(
+                title: selected == nil ? t("usdt__deposit_history") : t("usdt__receiving_title"),
+                titleKerning: 0,
+                titleLineHeight: 26,
+                onBack: {
+                    if selected == nil { dismiss() }
+                    else { clearSelection() }
+                }
+            )
             .disabled(busy || recoveryActive)
             .padding(.bottom, 16)
             ScrollView(showsIndicators: false) {
@@ -47,7 +52,7 @@ struct UsdtDepositHistoryView: View {
                 else { await loadPage(0) }
             }
             if selected != nil {
-                CustomButton(title: t("usdt__deposit_history"), isDisabled: busy || recoveryActive) {
+                CustomButton(title: t("usdt__deposit_history"), isDisabled: busy || recoveryActive, titleKerning: -0.4, titleLineHeight: 20) {
                     clearSelection()
                     await loadPage(0)
                 }
@@ -102,8 +107,8 @@ struct UsdtDepositHistoryView: View {
 
     private var depositList: some View {
         VStack(alignment: .leading, spacing: 16) {
-            SendSectionView(t("usdt__provider_status"), labelKerning: 1, labelLineHeight: 18) {
-                BodySSBText(t("usdt__deposit_status_note"), lineHeight: 20)
+            SendSectionView(t("usdt__provider_status"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                BodySSBText(t("usdt__deposit_status_note"), kerning: 0, lineHeight: 20)
             }
             if deposits.isEmpty, !busy { BodySText(t("usdt__deposit_empty"), textColor: .textSecondary) }
             ForEach(deposits, id: \.id) { deposit in
@@ -128,30 +133,36 @@ struct UsdtDepositHistoryView: View {
                 BodySSBText(detail.deposit.asset + " · " + detail.deposit.networkLabel, lineHeight: 20)
             }
             if showDetails {
-                SendSectionView(t("wallet__activity_tx_id"), labelKerning: 1, labelLineHeight: 18) {
-                    BodySSBText(detail.deposit.sourceTx, lineHeight: 20).textSelection(.enabled)
+                SendSectionView(t("wallet__activity_tx_id"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                    BodySSBText(detail.deposit.sourceTx, kerning: 0, lineHeight: 20).textSelection(.enabled)
                 }
-                SendSectionView(t("usdt__deposit_reference"), labelKerning: 1, labelLineHeight: 18) {
-                    BodySSBText(detail.deposit.id, lineHeight: 20).textSelection(.enabled)
+                SendSectionView(t("usdt__deposit_reference"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                    BodySSBText(detail.deposit.id, kerning: 0, lineHeight: 20).textSelection(.enabled)
                 }
                 if !detail.canRequestRefund {
                     UsdtDetailCell(title: t("wallet__activity_status"), value: detail.statusText, icon: detail.statusIcon,
-                                   valueColor: detail.statusColor, iconColor: detail.statusColor)
+                                   valueColor: detail.statusColor, iconColor: detail.statusColor, valueKerning: 0)
                 }
                 if detail.canRequestRefund {
-                    SendSectionView(t("usdt__deposit_refund_heading"), labelKerning: 1, labelLineHeight: 18) {
-                        BodySSBText(t("usdt__deposit_refund_instructions", variables: ["network": detail.deposit.refundNetworkLabel]), lineHeight: 20)
+                    SendSectionView(t("usdt__deposit_refund_heading"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                        BodySSBText(
+                            t("usdt__deposit_refund_instructions", variables: ["network": detail.deposit.refundNetworkLabel]),
+                            kerning: 0,
+                            lineHeight: 20
+                        )
                     }
                     TextField(t("usdt__deposit_refund_address_network", variables: ["network": detail.deposit.refundNetworkLabel]),
-                              text: $refundAddress, axis: .vertical, testIdentifier: "UsdtRefundAddress")
+                              text: $refundAddress, axis: .vertical, testIdentifier: "UsdtRefundAddress", placeholderColor: .white50,
+                              minContentHeight: 20)
                         .textInputAutocapitalization(.never).autocorrectionDisabled().disabled(busy)
+                        .environment(\._lineHeightMultiple, 20 / (UIFont(name: Fonts.semiBold, size: 15)?.lineHeight ?? 20))
                 }
                 HStack(spacing: 16) {
                     if detail.canRequestRefund {
                         CustomButton(title: t("usdt__deposit_refund"), size: .small,
                                      icon: Image("coins").resizable().frame(width: 16, height: 16).foregroundColor(.usdtAccent),
                                      isDisabled: busy || refundAddress.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
-                                     isLoading: busy, shouldExpand: true) { confirmRefund = true }
+                                     isLoading: busy, shouldExpand: true, titleKerning: 0, titleLineHeight: 13) { confirmRefund = true }
                             .accessibilityIdentifier("UsdtDepositRefund")
                     }
                     detailsButton
@@ -161,13 +172,13 @@ struct UsdtDepositHistoryView: View {
                 }
                 if let code = detail.statusCode { BodySText(code, textColor: .textSecondary).textSelection(.enabled) }
                 if let tx = detail.order?.destinationTx {
-                    SendSectionView(t("usdt__destination_tx"), labelKerning: 1, labelLineHeight: 18) {
-                        BodySSBText(tx, lineHeight: 20).textSelection(.enabled)
+                    SendSectionView(t("usdt__destination_tx"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                        BodySSBText(tx, kerning: 0, lineHeight: 20).textSelection(.enabled)
                     }
                 }
                 if let tx = detail.order?.refundTx ?? detail.deposit.refundTx {
-                    SendSectionView(t("usdt__refund_tx"), labelKerning: 1, labelLineHeight: 18) {
-                        BodySSBText(tx, lineHeight: 20).textSelection(.enabled)
+                    SendSectionView(t("usdt__refund_tx"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) {
+                        BodySSBText(tx, kerning: 0, lineHeight: 20).textSelection(.enabled)
                     }
                 }
                 if detail.deposit.asset != "USDT" || UsdtDepositNetwork.named(detail.deposit.network) == nil {
@@ -177,14 +188,17 @@ struct UsdtDepositHistoryView: View {
             } else {
                 HStack(alignment: .top, spacing: 16) {
                     UsdtDetailCell(title: t("wallet__activity_status"), value: detail.statusText, icon: detail.statusIcon,
-                                   valueColor: detail.statusColor, iconColor: detail.statusColor)
+                                   valueColor: detail.statusColor, iconColor: detail.statusColor, valueKerning: 0)
                     UsdtDetailCell(title: t("usdt__receiving_network"), value: UsdtDestination.arbitrum.label, icon: "usdt-network")
                 }
                 UsdtDetailCell(title: t("usdt__sender_network"), value: detail.deposit.networkLabel, icon: "usdt-network")
                 if let order = detail.order, order.status != "refunded", let received = order.amountOut {
-                    SendSectionView(t("usdt__deposit_batch"), labelKerning: 1, labelLineHeight: 18) { BodySSBText(amount(received), lineHeight: 20) }
+                    SendSectionView(t("usdt__deposit_batch"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) { BodySSBText(
+                        amount(received),
+                        lineHeight: 20
+                    ) }
                     if let sent = order.amountIn, sent >= received {
-                        SendSectionView(t("usdt__deposit_cost"), labelKerning: 1, labelLineHeight: 18) { BodySSBText(
+                        SendSectionView(t("usdt__deposit_cost"), dividerSpacing: 15, labelKerning: 1, labelLineHeight: 18) { BodySSBText(
                             amount(sent - received),
                             lineHeight: 20
                         ) }
@@ -199,8 +213,12 @@ struct UsdtDepositHistoryView: View {
     private var detailsButton: some View {
         CustomButton(title: t(showDetails ? "common__hide_details" : "wallet__send_details"), size: .small,
                      icon: Image(showDetails ? "eye-slash" : "git-branch").resizable().frame(width: 16, height: 16)
-                         .foregroundColor(.usdtAccent), isDisabled: busy || recoveryActive, shouldExpand: true) { showDetails.toggle() }
-            .accessibilityIdentifier("UsdtDepositDetails")
+                         .foregroundColor(.usdtAccent), isDisabled: busy || recoveryActive, shouldExpand: true, titleKerning: 0,
+                     titleLineHeight: 13)
+        {
+            showDetails.toggle()
+        }
+        .accessibilityIdentifier("UsdtDepositDetails")
     }
 
     private func clearSelection() {
@@ -382,14 +400,17 @@ struct UsdtDepositRow: View {
         let completed = ["completed", "refunded"].contains(deposit.status)
         let color: Color = completed ? .usdtAccent : .yellowAccent
         ActivityRowContainer {
-            ActivityRowContent(title: deposit.networkLabel, subtitle: deposit.statusText) {
+            ActivityRowContent(title: deposit.networkLabel, subtitle: deposit.statusText, textKerning: 0,
+                               titleLineHeight: 22, subtitleLineHeight: 18, textSpacing: 0)
+            {
                 CircularIcon(icon: completed ? "check-circle" : "hourglass-simple", iconColor: color,
                              backgroundColor: color.opacity(0.16), size: 40)
             } amount: {
-                VStack(alignment: .trailing, spacing: 2) {
-                    BodyMSBText(deposit.asset == "USDT" ? amount + " USDT" : deposit.asset).lineLimit(1).minimumScaleFactor(0.7)
+                VStack(alignment: .trailing, spacing: 0) {
+                    BodyMSBText(deposit.asset == "USDT" ? amount + " USDT" : deposit.asset, kerning: 0, lineHeight: 22).lineLimit(1)
+                        .minimumScaleFactor(0.7)
                     if deposit.asset == "USDT" {
-                        CaptionBText(hideBalance ? amount : "$ " + amount, textColor: .textSecondary)
+                        CaptionBText(hideBalance ? amount : "$ " + amount, textColor: .textSecondary, kerning: 0, lineHeight: 18)
                     }
                 }
             }

From b522b8f1f033d7b82cec81feb3ce2ad661113b4a Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 15:09:08 -0500
Subject: [PATCH 54/62] fix: handle usdt send errors and prompt dismissal

---
 Bitkit/Components/Activity/ActivityList.swift | 10 ++++++++--
 Bitkit/Views/Wallets/UsdtSendView.swift       | 12 +++++-------
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |  8 +++++++-
 BitkitTests/WalletActivityTests.swift         | 18 ++++++++++++++++++
 journeys/usdt-opt-in.xml                      |  4 ++--
 journeys/usdt-wallet-navigation.xml           |  1 +
 6 files changed, 41 insertions(+), 12 deletions(-)

diff --git a/Bitkit/Components/Activity/ActivityList.swift b/Bitkit/Components/Activity/ActivityList.swift
index 3bc2c2e5d..bc76f4a1a 100644
--- a/Bitkit/Components/Activity/ActivityList.swift
+++ b/Bitkit/Components/Activity/ActivityList.swift
@@ -46,8 +46,7 @@ struct ActivityList: View {
             let end = activity.endDate.flatMap { Calendar.current.date(byAdding: .day, value: 1, to: Calendar.current.startOfDay(for: $0)) }
             let search = activity.searchText
             return matchesTab && (start.map { date >= $0 } ?? true) && (end.map { date < $0 } ?? true) &&
-                (search.isEmpty || transfer.recipient.localizedCaseInsensitiveContains(search) ||
-                    transfer.txHash?.localizedCaseInsensitiveContains(search) == true || "USDT".localizedCaseInsensitiveContains(search))
+                transfer.matchesActivitySearch(search)
         }
     }
 
@@ -59,3 +58,10 @@ struct ActivityList: View {
         }
     }
 }
+
+extension UsdtTransfer {
+    func matchesActivitySearch(_ search: String) -> Bool {
+        search.isEmpty || search.caseInsensitiveCompare("USDT") == .orderedSame ||
+            recipient.localizedCaseInsensitiveContains(search) || txHash?.localizedCaseInsensitiveContains(search) == true
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 312b9cf8c..7cfbebf2d 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -13,7 +13,6 @@ struct UsdtSendView: View {
     var onClose: (() -> Void)?
     @Environment(UsdtWalletManager.self) private var usdt
     @EnvironmentObject private var contactsManager: ContactsManager
-    @EnvironmentObject private var navigation: NavigationViewModel
     @EnvironmentObject private var currency: CurrencyViewModel
     @EnvironmentObject private var settings: SettingsViewModel
     @Environment(\.dismiss) private var dismiss
@@ -109,11 +108,6 @@ struct UsdtSendView: View {
         Group {
             if !settings.isUsdtEnabled, !submitted {
                 UsdtIntroContent(isEnablePrompt: true, onDecline: {
-                    if !embedded, !initialRecipient.isEmpty,
-                       navigation.currentRoute == .usdtPayment(recipient: initialRecipient, amount: initialAmount)
-                    {
-                        navigation.navigateBack()
-                    }
                     if let onClose { onClose() } else { dismiss() }
                 }, onEnable: { settings.usdtPreference = .enabled })
             } else if embedded { content }
@@ -640,7 +634,11 @@ struct UsdtSendView: View {
             if usdt.transfers.contains(where: { $0.id == quote.id }) {
                 submitted = true
             } else {
-                self.error = (error as? LocalizedError)?.errorDescription ?? UsdtWalletManager.message(for: error)
+                self.error = if error is UsdtError {
+                    UsdtWalletManager.message(for: error)
+                } else {
+                    (error as? LocalizedError)?.errorDescription ?? UsdtWalletManager.message(for: error)
+                }
                 self.quote = nil
             }
             Logger.warn("Failed to send USDT: \(UsdtWalletManager.message(for: error))", context: "UsdtSendView")
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index b2abee773..a12915895 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -76,7 +76,13 @@ struct UsdtWalletScreen: View {
             guard navigation.currentRoute != .usdtDepositHistory, !showSend, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
             sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount, usdtTransferId: tx.id))
         }
-        .sheet(isPresented: $showSend) {
+        .sheet(isPresented: $showSend, onDismiss: {
+            if !settings.isUsdtEnabled, !sendRecipient.isEmpty,
+               navigation.currentRoute == .usdtPayment(recipient: sendRecipient, amount: sendAmount)
+            {
+                navigation.navigateBack()
+            }
+        }) {
             Sheet(id: .send, data: SendSheetItem()) {
                 UsdtSendView(onDetails: { id in
                     showSend = false
diff --git a/BitkitTests/WalletActivityTests.swift b/BitkitTests/WalletActivityTests.swift
index 6258fcc62..1d1d0d540 100644
--- a/BitkitTests/WalletActivityTests.swift
+++ b/BitkitTests/WalletActivityTests.swift
@@ -3,6 +3,24 @@ import BitkitCore
 import XCTest
 
 final class WalletActivityTests: XCTestCase {
+    func testUsdtSearchMatchesFullAssetNameOrRecipientAndTransactionFragments() {
+        let transfer = UsdtTransfer(
+            sender: nil, id: "received", txHash: "0xAbCd5678", userOperationHash: nil, bridgeGuid: nil, orchestra: nil,
+            recipient: "0xEf901234", destination: .arbitrum, amount: 1_000_000, receivedAmount: 1_000_000, fee: nil,
+            isIncoming: true, status: .confirmed, timestamp: 1
+        )
+        for query in ["", "USDT", "usdt", "eF90", "aBcD"] {
+            XCTAssertTrue(transfer.matchesActivitySearch(query), query)
+        }
+        for query in ["u", "us", "t", "BTC", "no match"] {
+            XCTAssertFalse(transfer.matchesActivitySearch(query), query)
+        }
+        var unconfirmed = transfer
+        unconfirmed.txHash = nil
+        XCTAssertTrue(unconfirmed.matchesActivitySearch("eF90"))
+        XCTAssertFalse(unconfirmed.matchesActivitySearch("aBcD"))
+    }
+
     func testMergedActivityPositionsIncludeDateHeaders() throws {
         let today = Calendar.current.startOfDay(for: Date())
         let yesterday = try XCTUnwrap(Calendar.current.date(byAdding: .day, value: -1, to: today))
diff --git a/journeys/usdt-opt-in.xml b/journeys/usdt-opt-in.xml
index 007c84a4a..c1381bc7f 100644
--- a/journeys/usdt-opt-in.xml
+++ b/journeys/usdt-opt-in.xml
@@ -1,5 +1,5 @@
 <journey name="USDT Opt In">
-  <description>Use a fresh onboarded wallet with USDT services configured. The wallet has no USDT balance or pending transfers. Use owned payment links and existing requests; no payment is submitted.</description>
+  <description>Use a fresh onboarded wallet with USDT services configured. The wallet has no USDT balance or pending transfers. Use owned payment links and existing requests; no payment is submitted. The explicit-link enable prompt is a swipe-dismissable sheet on iOS; Android uses an alert with Cancel and Enable actions and blocks outside/Back dismissal.</description>
   <actions>
     <action>On Home, verify the New: USDT sheet (id "UsdtIntro") shows the Tether coin, DOLLARS? YOUR CALL heading, No Thanks and Enable USDT.</action>
     <action>Swipe the intro sheet down. Verify Home shows Savings and Spending without a USDT tile. Open Receive and verify there is no USDT tab, then close it.</action>
@@ -8,7 +8,7 @@
     <action>Open USDT Send and its network pill. Verify the USDT Network picker (id "UsdtNetworkPicker") uses rounded rows with Tether icons, a teal selection check, the recipient-network explanation and Tether coin illustration. Choose another supported network and verify the pill updates while retaining its network icon.</action>
     <action>Return to Settings and turn USDT off while the wallet is empty and all transfers are complete. Verify the USDT tile, receive tab and new Paykit receiving option disappear. Existing payment history remains stored.</action>
     <action>With completed USDT history and a zero balance, disable USDT and relaunch. While the balance loads or its refresh fails, history may keep the USDT tile visible, but the Settings switch stays off and can be enabled. Verify Receive and optional address sharing still omit USDT. Enable it and verify the switch stays on and cannot be disabled until the zero balance is confirmed.</action>
-    <action>Open an owned USDT payment link while USDT is off. Verify the Enable USDT prompt (id "UsdtEnablePrompt"). Decline and verify USDT stays off, the flow closes quietly, and no payment spinner or failure screen remains. Open the link again, enable USDT (id "UsdtEnablePromptContinue"), and verify the recipient and exact amount continue into the payment flow. Cancel without paying.</action>
+    <action>Open an owned USDT payment link while USDT is off. Verify the Enable USDT prompt (id "UsdtEnablePrompt"). Decline and verify USDT stays off, the flow returns to the previous screen, and no payment spinner or failure screen remains. Where interactive dismissal is available, open the link again and dismiss the prompt without tapping Cancel; verify the same quiet return with no USDT wallet or Send/Receive controls left open. Open the link again, enable USDT (id "UsdtEnablePromptContinue"), and verify the recipient and exact amount continue into the payment flow. Cancel without paying.</action>
     <action>With a funded wallet or an unresolved transfer, open Settings. Verify USDT is visibly on, greyed out and cannot be toggled. Verify the wallet, history and pending payment remain accessible.</action>
     <action>Restore an owned funded wallet whose USDT preference is absent or off. Verify USDT is enabled and its Settings switch is on and greyed out. Open Receive from Home and verify it keeps the normal default tab (Auto when available, otherwise Savings). Select the available USDT tab and verify its receiving address appears without an enable prompt. No payment is submitted.</action>
   </actions>
diff --git a/journeys/usdt-wallet-navigation.xml b/journeys/usdt-wallet-navigation.xml
index 4176ccbad..663acd4b3 100644
--- a/journeys/usdt-wallet-navigation.xml
+++ b/journeys/usdt-wallet-navigation.xml
@@ -9,5 +9,6 @@
     <action>Replace it with an owned valid EVM address. Continue to Amount, enter six decimal places and try a seventh; verify the amount remains limited to six. Close before requesting a quote.</action>
     <action>Set an amount and note in Bitcoin Receive, then close it. Open a fresh USDT Receive sheet and switch to Savings and Spending. Verify Savings shows a fresh Bitcoin QR with no previous amount or note. Spending shows a fresh Lightning QR when receive liquidity is available; an unfunded wallet shows the Spending receive setup instead. Verify hardware-wallet receive remains available when paired.</action>
     <action>Return Home and open Bitcoin Receive. Verify the Bitcoin address, network and amount controls remain separate from USDT.</action>
+    <action>With saved USDT activity, open All Activity. Search for USDT and usdt and verify both show USDT rows. Search for u, us or t and verify a USDT row appears only if its recipient or transaction ID contains the query. Verify a matching recipient or transaction-ID fragment still finds the row, and clearing search restores the list.</action>
   </actions>
 </journey>

From f55590557cd6401b35e4b18fde685c1b5ebef246 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 16:40:20 -0500
Subject: [PATCH 55/62] fix: preserve usdt receipts and align deposit details

---
 Bitkit/MainNavView.swift                      | 57 ++++++++++++++++++-
 .../Localization/en.lproj/Localizable.strings |  2 +
 Bitkit/Views/Wallets/UsdtActivityDetail.swift | 15 ++++-
 .../Wallets/UsdtDepositHistoryView.swift      | 12 ++--
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |  4 --
 BitkitTests/UsdtPaymentLinkTests.swift        |  4 --
 BitkitTests/UsdtWalletManagerTests.swift      | 38 +++++++++++++
 journeys/paykit-quoted-usdt.xml               |  2 +-
 journeys/usdt-bridge-details.xml              |  6 +-
 9 files changed, 117 insertions(+), 23 deletions(-)

diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 55c92a380..99f443790 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -1,3 +1,4 @@
+import BitkitCore
 import SwiftUI
 
 struct MainNavView: View {
@@ -23,6 +24,7 @@ struct MainNavView: View {
     @Environment(UsdtWalletManager.self) private var usdt
     @Environment(\.scenePhase) var scenePhase
 
+    @State private var usdtReceipts = UsdtReceiptQueue()
     @State private var showClipboardAlert = false
     @State private var clipboardUri: String?
     @State private var didResumePendingPubkyProfileSetup = false
@@ -58,6 +60,16 @@ struct MainNavView: View {
         )
     }
 
+    private var canPresentUsdtReceipt: Bool {
+        scenePhase == .active && !wallet.isRestoringWallet && !usdt.isSendPresented
+            && !sheets.isAnySheetOpen && !sheets.isReplacingSheet && navigation.currentRoute != .usdtDepositHistory
+    }
+
+    private func presentUsdtReceipt() {
+        guard let tx = usdtReceipts.takeNext(canPresent: canPresentUsdtReceipt) else { return }
+        sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount, usdtTransferId: tx.id))
+    }
+
     // Delay constants for clipboard processing
     private static let nodeReadyDelayNanoseconds: UInt64 = 500_000_000 // 0.5 seconds
     private static let statePropagationDelayNanoseconds: UInt64 = 500_000_000 // 0.5 seconds
@@ -187,6 +199,8 @@ struct MainNavView: View {
             item: $sheets.receivedTxSheetItem,
             onDismiss: {
                 sheets.hideSheetIfActive(.receivedTx, reason: "Received transaction sheet dismissed")
+                usdtReceipts.didDismiss()
+                presentUsdtReceipt()
             }
         ) {
             config in ReceivedTx(config: config)
@@ -301,9 +315,15 @@ struct MainNavView: View {
             }
         }
         .onReceive(usdt.receivedTxPublisher) { tx in
-            guard navigation.currentRoute?.isUsdtWalletRoute != true,
-                  !wallet.isRestoringWallet, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
-            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount, usdtTransferId: tx.id))
+            guard !wallet.isRestoringWallet else { return }
+            usdtReceipts.append(tx)
+            presentUsdtReceipt()
+        }
+        .onChange(of: canPresentUsdtReceipt) { _, ready in
+            if ready { presentUsdtReceipt() }
+        }
+        .onChange(of: wallet.isRestoringWallet) { _, restoring in
+            if restoring { usdtReceipts.removeAll() }
         }
         .onReceive(hwWalletManager.receivedTxPublisher) { tx in
             // New inbound transaction to a watched hardware wallet — show the received celebration.
@@ -316,6 +336,9 @@ struct MainNavView: View {
             DrawerView()
         }
         .onChange(of: sheets.activeSheetConfiguration?.id) { _, sheet in
+            if sheet == .receivedTx {
+                usdtReceipts.didPresent()
+            }
             if sheet != nil {
                 app.showDrawer = false
             }
@@ -926,3 +949,31 @@ struct MainNavView: View {
         return components.string ?? (url.scheme ?? "unknown")
     }
 }
+
+struct UsdtReceiptQueue {
+    private var transfers: [UsdtTransfer] = []
+    private var isPresenting = false
+
+    mutating func append(_ transfer: UsdtTransfer) {
+        guard !transfers.contains(where: { $0.id == transfer.id }) else { return }
+        transfers.append(transfer)
+    }
+
+    mutating func takeNext(canPresent: Bool) -> UsdtTransfer? {
+        guard canPresent, !isPresenting, !transfers.isEmpty else { return nil }
+        didPresent()
+        return transfers.removeFirst()
+    }
+
+    mutating func didPresent() {
+        isPresenting = true
+    }
+
+    mutating func didDismiss() {
+        isPresenting = false
+    }
+
+    mutating func removeAll() {
+        transfers.removeAll()
+    }
+}
diff --git a/Bitkit/Resources/Localization/en.lproj/Localizable.strings b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
index 548bd6b94..755177bdb 100644
--- a/Bitkit/Resources/Localization/en.lproj/Localizable.strings
+++ b/Bitkit/Resources/Localization/en.lproj/Localizable.strings
@@ -1840,6 +1840,7 @@
 "usdt__expected_amount" = "Expected amount";
 "usdt__failed" = "Failed";
 "usdt__fee_note" = "All fees are paid in USDT. Final fee may be lower.";
+"usdt__hide_details" = "Hide details";
 "usdt__history_sync" = "Older activity is still syncing. Your balance is up to date when the connection is available.";
 "usdt__maximum_fee" = "Maximum fee";
 "usdt__network_warning" = "Select the network used by the recipient. Sending to an address on the wrong network can lose funds.";
@@ -1876,6 +1877,7 @@
 "usdt__deposit_reference" = "Deposit reference";
 "usdt__deposit_refresh" = "Refresh";
 "usdt__deposit_refund" = "Request Refund";
+"usdt__deposit_refund_action" = "Request refund";
 "usdt__deposit_refunded" = "Refunded";
 "usdt__deposit_status_note" = "Your spendable balance updates when USDT arrives on Arbitrum.";
 "usdt__deposit_unavailable" = "Cross-network receiving is currently unavailable. Direct Arbitrum receive still works.";
diff --git a/Bitkit/Views/Wallets/UsdtActivityDetail.swift b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
index 0f16af337..c2b8d824c 100644
--- a/Bitkit/Views/Wallets/UsdtActivityDetail.swift
+++ b/Bitkit/Views/Wallets/UsdtActivityDetail.swift
@@ -44,8 +44,8 @@ struct UsdtActivityIcon: View {
     var body: some View {
         CircularIcon(
             icon: transfer.statusIcon,
-            iconColor: .usdtAccent,
-            backgroundColor: Color.usdtAccent.opacity(0.16),
+            iconColor: transfer.activityIconColor,
+            backgroundColor: transfer.activityIconColor.opacity(0.16),
             size: size
         )
     }
@@ -250,12 +250,21 @@ extension UsdtTransfer {
     var statusIcon: String {
         switch status {
         case .failed, .replaced, .bridgeFailed: "x-circle"
-        case .pending, .bridging, .bridgeNeedsAttention: "hourglass-simple"
+        case .pending, .bridgeNeedsAttention: "hourglass-simple"
+        case .bridging: "transfer"
         case .confirmed: isIncoming ? "arrow-down" : "arrow-up"
         case .bridgeRefunded: "arrow-down"
         }
     }
 
+    var activityIconColor: Color {
+        switch status {
+        case .failed, .replaced, .bridgeFailed: .redAccent
+        case .pending, .bridgeNeedsAttention: .yellowAccent
+        default: .usdtAccent
+        }
+    }
+
     var statusColor: Color {
         switch status {
         case .failed, .replaced: .redAccent
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index 15471410c..9965547e1 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -10,7 +10,7 @@ struct UsdtDepositHistoryView: View {
     @State private var nextOffset: UInt32?
     @State private var selected: UsdtDepositDetail?
     @State private var refundAddress = ""
-    @State private var showDetails = true
+    @State private var showDetails = false
     @State private var approved: RefundApproval?
     @State private var pageOffsets: [String: UInt32] = [:]
     @State private var confirmRefund = false
@@ -159,7 +159,7 @@ struct UsdtDepositHistoryView: View {
                 }
                 HStack(spacing: 16) {
                     if detail.canRequestRefund {
-                        CustomButton(title: t("usdt__deposit_refund"), size: .small,
+                        CustomButton(title: t("usdt__deposit_refund_action"), size: .small,
                                      icon: Image("coins").resizable().frame(width: 16, height: 16).foregroundColor(.usdtAccent),
                                      isDisabled: busy || refundAddress.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
                                      isLoading: busy, shouldExpand: true, titleKerning: 0, titleLineHeight: 13) { confirmRefund = true }
@@ -211,7 +211,7 @@ struct UsdtDepositHistoryView: View {
     }
 
     private var detailsButton: some View {
-        CustomButton(title: t(showDetails ? "common__hide_details" : "wallet__send_details"), size: .small,
+        CustomButton(title: t(showDetails ? "usdt__hide_details" : "wallet__send_details"), size: .small,
                      icon: Image(showDetails ? "eye-slash" : "git-branch").resizable().frame(width: 16, height: 16)
                          .foregroundColor(.usdtAccent), isDisabled: busy || recoveryActive, shouldExpand: true, titleKerning: 0,
                      titleLineHeight: 13)
@@ -227,7 +227,7 @@ struct UsdtDepositHistoryView: View {
         error = nil
         refundAddress = ""
         approved = nil
-        showDetails = true
+        showDetails = false
     }
 
     private func amount(_ value: UInt64?) -> String {
@@ -265,7 +265,7 @@ struct UsdtDepositHistoryView: View {
                 refundAddress = ""
                 approved = nil
                 message = nil
-                showDetails = true
+                showDetails = false
             }
             if ["completed", "refunded"].contains(detail.order?.status ?? detail.deposit.status) {
                 message = nil
@@ -410,7 +410,7 @@ struct UsdtDepositRow: View {
                     BodyMSBText(deposit.asset == "USDT" ? amount + " USDT" : deposit.asset, kerning: 0, lineHeight: 22).lineLimit(1)
                         .minimumScaleFactor(0.7)
                     if deposit.asset == "USDT" {
-                        CaptionBText(hideBalance ? amount : "$ " + amount, textColor: .textSecondary, kerning: 0, lineHeight: 18)
+                        CaptionBText(hideBalance ? amount : "$" + amount, textColor: .textSecondary, kerning: 0, lineHeight: 18)
                     }
                 }
             }
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index a12915895..ad3b98f5f 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -72,10 +72,6 @@ struct UsdtWalletScreen: View {
         }
         .padding(.horizontal, 16)
         .navigationBarHidden(true)
-        .onReceive(usdt.receivedTxPublisher) { tx in
-            guard navigation.currentRoute != .usdtDepositHistory, !showSend, !sheets.isAnySheetOpen, !sheets.isReplacingSheet else { return }
-            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: tx.amount, usdtTransferId: tx.id))
-        }
         .sheet(isPresented: $showSend, onDismiss: {
             if !settings.isUsdtEnabled, !sendRecipient.isEmpty,
                navigation.currentRoute == .usdtPayment(recipient: sendRecipient, amount: sendAmount)
diff --git a/BitkitTests/UsdtPaymentLinkTests.swift b/BitkitTests/UsdtPaymentLinkTests.swift
index 37c4fe51d..2af019373 100644
--- a/BitkitTests/UsdtPaymentLinkTests.swift
+++ b/BitkitTests/UsdtPaymentLinkTests.swift
@@ -8,10 +8,6 @@ final class UsdtPaymentLinkTests: XCTestCase {
         "ethereum:\(PaykitUsdt.token)@42161/transfer?address=\(recipient)"
     }
 
-    func testDepositHistoryDefersIncomingCelebrationDuringRefundReview() {
-        XCTAssertTrue(Route.usdtDepositHistory.isUsdtWalletRoute)
-    }
-
     func testPaymentLinkPreservesOptionalAtomicAmount() throws {
         XCTAssertEqual(try resolveUsdtPaymentRoute(input: uri, isEnabled: true), .usdtPayment(recipient: recipient, amount: ""))
         XCTAssertEqual(try resolveUsdtPaymentRoute(input: " \(uri)&uint256=10001\n", isEnabled: true),
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index edc89bdba..0623606b4 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -314,6 +314,44 @@ final class UsdtWalletManagerTests: XCTestCase {
         XCTAssertEqual(deposit.refundNetworkLabel, "BSC")
     }
 
+    func testIncomingCelebrationsWaitUntilPresentationIsAvailable() {
+        var receipts = UsdtReceiptQueue()
+        let sheets = SheetViewModel()
+        let first = transfer("first")
+        let second = transfer("second")
+
+        // Bitcoin and Lightning receipts share the same presentation.
+        sheets.showSheet(.receivedTx)
+        receipts.didPresent()
+        receipts.append(first)
+        receipts.append(first)
+        receipts.append(second)
+
+        XCTAssertNil(receipts.takeNext(canPresent: false))
+
+        sheets.receivedTxSheetItem = nil
+        XCTAssertNil(receipts.takeNext(canPresent: !sheets.isAnySheetOpen))
+        sheets.hideSheetIfActive(.receivedTx)
+        receipts.didDismiss()
+
+        XCTAssertEqual(receipts.takeNext(canPresent: true), first)
+        sheets.showSheet(.receivedTx)
+        XCTAssertNil(receipts.takeNext(canPresent: false))
+
+        // SwiftUI clears the binding before the sheet's dismissal animation finishes.
+        sheets.receivedTxSheetItem = nil
+        XCTAssertNil(receipts.takeNext(canPresent: !sheets.isAnySheetOpen))
+        sheets.hideSheetIfActive(.receivedTx)
+        receipts.didDismiss()
+
+        XCTAssertEqual(receipts.takeNext(canPresent: true), second)
+        sheets.showSheet(.receivedTx)
+        XCTAssertEqual(sheets.activeSheetConfiguration?.id, .receivedTx)
+        sheets.hideSheetIfActive(.receivedTx)
+        receipts.didDismiss()
+        XCTAssertNil(receipts.takeNext(canPresent: true))
+    }
+
     private func transfer(_ id: String, incoming: Bool = true, status: UsdtTransferStatus = .confirmed, amount: UInt64 = 1_000_000) -> UsdtTransfer {
         UsdtTransfer(
             sender: nil,
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index 0aaa2ac3a..a3a5cabe9 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -15,6 +15,6 @@
     <action>Create a USD subscription for 150,50 on a comma-decimal locale. Verify the amount review shows 150,50 USD and editing preserves that amount. Verify Accepted Payments appears below frequency, with USDT selected and Bitcoin unselected. Verify the description and icon controls are side by side. Propose it to the linked contact. On the payer, verify the subscription card and details show 150,50 USD, then review its recurrence and USDT payment method. Verify the subscription swipe uses USDT teal, then close before subscribing.</action>
     <action>Create a BTC subscription for 12,345 sats and verify Bitcoin is selected. Tap SubscriptionAccept-usdt; verify the amount converts to USD and only USDT is selected. Tap SubscriptionAccept-bitcoin; verify the amount returns to exactly 12,345 sats and only Bitcoin is selected, covering the enabled Savings and Spending methods.</action>
     <action>Repeat the subscription USDT and Bitcoin switches four times without editing. Verify every return to Bitcoin shows exactly 12,345 sats. Edit the amount to 10 USD, repeat the switches and verify every return to USDT shows exactly 10 USD. Close without proposing.</action>
-    <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01, then close without continuing to review.</action>
+    <action>Open a linked USDT-only contact that has published a private payment list. Verify the amount screen offers only USDT, enter 0.01, verify the USDT balance is labeled AVAILABLE rather than AVAILABLE (SPENDING), then close without continuing to review.</action>
   </actions>
 </journey>
diff --git a/journeys/usdt-bridge-details.xml b/journeys/usdt-bridge-details.xml
index 7da55ab68..a5bd4e7f5 100644
--- a/journeys/usdt-bridge-details.xml
+++ b/journeys/usdt-bridge-details.xml
@@ -4,13 +4,15 @@
     <action>Open the pending incoming USDT activity. Verify the Receiving USDT title, incoming amount, teal down arrow, yellow Pending status, receiving network, date, time, payment and available fee.</action>
     <action>Tap Details (id "UsdtActivityDetails"). Verify the real wallet transaction and available addresses are shown without inventing a provider deposit reference or refund eligibility.</action>
     <action>Open Cross-Network Deposits (id "UsdtDepositHistory"). Verify the Provider Status note says the spendable balance updates when USDT arrives on Arbitrum, and each row shows its source network, provider status and available amount.</action>
-    <action>Open a supported deposit that needs attention (id "UsdtDepositRow-{depositId}"). Verify its own source transaction and deposit reference are shown. Verify the refund instructions and address placeholder name that deposit's source network.</action>
-    <action>Enter an owned test refund address (id "UsdtRefundAddress") and tap Request Refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the exact deposit amount, network, full refund address and refund fee note. Cancel without submitting.</action>
+    <action>Open a supported deposit that needs attention (id "UsdtDepositRow-{depositId}"). Verify the summary appears first with the provider status and receiving network. Do not invent a deposit date or individual fee when the provider does not supply one. Tap Details (id "UsdtDepositDetails"). Verify its own source transaction and deposit reference are shown. Verify the refund instructions and address placeholder name that deposit's source network.</action>
+    <action>Enter an owned test refund address (id "UsdtRefundAddress") and tap Request refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the exact deposit amount, network, full refund address and refund fee note. Cancel without submitting.</action>
     <action>Tap Hide details (id "UsdtDepositDetails"), then Details again. Verify the provider status remains separate from wallet activity and the entered refund address is retained.</action>
     <action>Open completed, refunded and refund-in-progress deposit fixtures. Verify Request Refund is unavailable and the current provider status and available refund transaction are shown. An unsupported asset or network must show support guidance instead of a refund form.</action>
+    <action>While Cross-Network Deposits is open, inject a confirmed incoming USDT transfer through the isolated fixture. Verify no received sheet interrupts deposit details or refund review. Return to the USDT wallet and verify the received celebration appears once after any active sheet is dismissed.</action>
     <action>Open the outgoing delivering USDT activity. Verify the Delivering USDT title, outgoing amount, teal up arrow, yellow Delivering status and actual receiving network.</action>
     <action>Tap Details (id "UsdtActivityDetails"). Verify the source transaction, sender and recipient addresses, sender and recipient networks, Orchestra provider and bridge reference. Verify Open Block Explorer (id "UsdtActivityExplorer") and Hide details remain reachable.</action>
     <action>For a delayed, failed, refunding, refunded or support-needed bridge fixture, verify Contact Support (id "UsdtContactSupport") and Copy Details (id "UsdtCopyDetails") remain reachable from its details without submitting either action.</action>
+    <action>Return to the USDT activity list. Verify Pending uses a yellow hourglass and 16% yellow circle, Failed uses a red x-circle and 16% red circle, and Transferring uses the teal transfer arrows. Sent and Received remain teal.</action>
     <action>Open USDT Receive, then Network. Verify Cross-Network Deposits (id "UsdtDepositHistory") remains reachable before any Arbitrum receipt exists.</action>
   </actions>
 </journey>

From c348e73f8e8708514d10a5307d8eeffb1ef64a92 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 17:10:26 -0500
Subject: [PATCH 56/62] fix: localize usdt refund amounts

---
 Bitkit/Views/Wallets/UsdtDepositHistoryView.swift | 2 +-
 journeys/usdt-bridge-details.xml                  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index 9965547e1..ca8b59a11 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -345,7 +345,7 @@ extension UsdtDepositDetail {
 
     func refundConfirmation(address: String, hideBalance: Bool) -> String {
         t("usdt__deposit_refund_confirmation", variables: [
-            "amount": hideBalance ? "• • • • •" : deposit.amount.map { usdtFormatAmount(amount: $0) } ?? "—",
+            "amount": hideBalance ? "• • • • •" : deposit.amount.map { usdtOverviewAmount($0) } ?? "—",
             "network": UsdtDepositNetwork.named(deposit.network) == .bsc ? "BNB Smart Chain (BSC)" : deposit.networkLabel,
             "shortNetwork": deposit.refundNetworkLabel,
             "address": address,
diff --git a/journeys/usdt-bridge-details.xml b/journeys/usdt-bridge-details.xml
index a5bd4e7f5..21e53ea3f 100644
--- a/journeys/usdt-bridge-details.xml
+++ b/journeys/usdt-bridge-details.xml
@@ -5,7 +5,7 @@
     <action>Tap Details (id "UsdtActivityDetails"). Verify the real wallet transaction and available addresses are shown without inventing a provider deposit reference or refund eligibility.</action>
     <action>Open Cross-Network Deposits (id "UsdtDepositHistory"). Verify the Provider Status note says the spendable balance updates when USDT arrives on Arbitrum, and each row shows its source network, provider status and available amount.</action>
     <action>Open a supported deposit that needs attention (id "UsdtDepositRow-{depositId}"). Verify the summary appears first with the provider status and receiving network. Do not invent a deposit date or individual fee when the provider does not supply one. Tap Details (id "UsdtDepositDetails"). Verify its own source transaction and deposit reference are shown. Verify the refund instructions and address placeholder name that deposit's source network.</action>
-    <action>Enter an owned test refund address (id "UsdtRefundAddress") and tap Request refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the exact deposit amount, network, full refund address and refund fee note. Cancel without submitting.</action>
+    <action>Enter an owned test refund address (id "UsdtRefundAddress") and tap Request refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the deposit amount formatted like its list row, network, full refund address and refund fee note. In a comma locale, a 3.5 USDT deposit must display 3,50 USDT. Hidden balances must remain masked, and an unknown amount must remain a dash. Cancel without submitting.</action>
     <action>Tap Hide details (id "UsdtDepositDetails"), then Details again. Verify the provider status remains separate from wallet activity and the entered refund address is retained.</action>
     <action>Open completed, refunded and refund-in-progress deposit fixtures. Verify Request Refund is unavailable and the current provider status and available refund transaction are shown. An unsupported asset or network must show support guidance instead of a refund form.</action>
     <action>While Cross-Network Deposits is open, inject a confirmed incoming USDT transfer through the isolated fixture. Verify no received sheet interrupts deposit details or refund review. Return to the USDT wallet and verify the received celebration appears once after any active sheet is dismissed.</action>

From 99fbda19a9aca41699587bfcc77f3acc93318eff Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 17:22:40 -0500
Subject: [PATCH 57/62] test: verify localized usdt refund confirmation

---
 Bitkit/Views/Wallets/UsdtDepositHistoryView.swift |  4 ++--
 BitkitTests/UsdtWalletManagerTests.swift          | 15 +++++++++------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index ca8b59a11..05ce3912e 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -343,9 +343,9 @@ extension UsdtDepositDetail {
         ["completed", "refunded"].contains(order?.status ?? deposit.status) ? .usdtAccent : .yellowAccent
     }
 
-    func refundConfirmation(address: String, hideBalance: Bool) -> String {
+    func refundConfirmation(address: String, hideBalance: Bool, locale: Locale = .current) -> String {
         t("usdt__deposit_refund_confirmation", variables: [
-            "amount": hideBalance ? "• • • • •" : deposit.amount.map { usdtOverviewAmount($0) } ?? "—",
+            "amount": hideBalance ? "• • • • •" : deposit.amount.map { usdtOverviewAmount($0, locale: locale) } ?? "—",
             "network": UsdtDepositNetwork.named(deposit.network) == .bsc ? "BNB Smart Chain (BSC)" : deposit.networkLabel,
             "shortNetwork": deposit.refundNetworkLabel,
             "address": address,
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 0623606b4..c82e2149c 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -297,17 +297,20 @@ final class UsdtWalletManagerTests: XCTestCase {
         XCTAssertFalse(detail.canRequestRefund)
     }
 
-    func testRefundConfirmationShowsExactAmountNetworkAndFullAddress() {
+    func testRefundConfirmationShowsLocalizedAmountNetworkAndFullAddress() {
         let address = "0x1111222233334444555566667777888899990000"
         let deposit = UsdtDeposit(id: "deposit", network: "bsc", asset: "USDT", amount: 50_000_001,
                                   sourceTx: "source-tx", status: "held", code: nil, refundTx: nil)
         let detail = UsdtDepositDetail(deposit: deposit, order: nil)
-        let confirmation = detail.refundConfirmation(address: address, hideBalance: false)
-        for value in ["50.000001", "BNB Smart Chain (BSC)", address, "Refund fees may apply."] {
-            XCTAssertTrue(confirmation.contains(value), value)
+        for (identifier, amount) in [("en_US", "50.00"), ("de_DE", "50,00")] {
+            let confirmation = detail.refundConfirmation(address: address, hideBalance: false, locale: Locale(identifier: identifier))
+            for value in [amount, "BNB Smart Chain (BSC)", address, "Refund fees may apply."] {
+                XCTAssertTrue(confirmation.contains(value), value)
+            }
+            XCTAssertFalse(confirmation.contains("50.000001"))
         }
-        let hidden = detail.refundConfirmation(address: address, hideBalance: true)
-        XCTAssertFalse(hidden.contains("50.000001"))
+        let hidden = detail.refundConfirmation(address: address, hideBalance: true, locale: Locale(identifier: "en_US"))
+        XCTAssertFalse(hidden.contains("50.00"))
         XCTAssertTrue(hidden.contains("• • • • •"))
         XCTAssertTrue(hidden.contains(address))
         XCTAssertEqual(deposit.networkLabel, "BNB Smart Chain")

From 587c5429f481fece14c17355f4037b60b6a2e35a Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 17:52:32 -0500
Subject: [PATCH 58/62] fix: split main navigation view for reliable
 compilation

---
 Bitkit/MainNavView.swift | 494 ++++++++++++++++++++-------------------
 1 file changed, 255 insertions(+), 239 deletions(-)

diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 99f443790..1803707a8 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -74,7 +74,7 @@ struct MainNavView: View {
     private static let nodeReadyDelayNanoseconds: UInt64 = 500_000_000 // 0.5 seconds
     private static let statePropagationDelayNanoseconds: UInt64 = 500_000_000 // 0.5 seconds
 
-    var body: some View {
+    private var navigationWithGeneralSheets: some View {
         NavigationStack(path: $navigation.path) {
             navigationContent
         }
@@ -171,231 +171,223 @@ struct MainNavView: View {
         ) {
             config in NotificationsSheet(config: config)
         }
-        .sheet(
-            item: $sheets.paymentRequestsSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.paymentRequests, reason: "Payment requests sheet dismissed")
-            }
-        ) {
-            config in PaymentRequestsSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.subscriptionSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.subscription, reason: "Subscription sheet dismissed")
-            }
-        ) {
-            config in SubscriptionSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.receiveSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.receive, reason: "Receive sheet dismissed")
+    }
+
+    private var navigationWithPaymentSheets: some View {
+        navigationWithGeneralSheets
+            .sheet(
+                item: $sheets.paymentRequestsSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.paymentRequests, reason: "Payment requests sheet dismissed")
+                }
+            ) {
+                config in PaymentRequestsSheet(config: config)
             }
-        ) {
-            config in ReceiveSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.receivedTxSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.receivedTx, reason: "Received transaction sheet dismissed")
-                usdtReceipts.didDismiss()
-                presentUsdtReceipt()
+            .sheet(
+                item: $sheets.subscriptionSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.subscription, reason: "Subscription sheet dismissed")
+                }
+            ) {
+                config in SubscriptionSheet(config: config)
             }
-        ) {
-            config in ReceivedTx(config: config)
-        }
-        .sheet(
-            item: $sheets.btcpayConnectionSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.btcpayConnection, reason: "BTCPay connection sheet dismissed")
+            .sheet(
+                item: $sheets.receiveSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.receive, reason: "Receive sheet dismissed")
+                }
+            ) {
+                config in ReceiveSheet(config: config)
+            }
+            .sheet(
+                item: $sheets.receivedTxSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.receivedTx, reason: "Received transaction sheet dismissed")
+                    usdtReceipts.didDismiss()
+                    presentUsdtReceipt()
+                }
+            ) {
+                config in ReceivedTx(config: config)
             }
-        ) {
-            config in BTCPayConnectionSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.scannerSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.scanner, reason: "Scanner sheet dismissed")
+            .sheet(
+                item: $sheets.btcpayConnectionSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.btcpayConnection, reason: "BTCPay connection sheet dismissed")
+                }
+            ) {
+                config in BTCPayConnectionSheet(config: config)
             }
-        ) {
-            config in ScannerSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.securitySheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.security, reason: "Security sheet dismissed")
+            .sheet(
+                item: $sheets.scannerSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.scanner, reason: "Scanner sheet dismissed")
+                }
+            ) {
+                config in ScannerSheet(config: config)
             }
-        ) {
-            config in SecuritySheet(config: config)
-        }
-        .sheet(item: $sheets.usdtIntroSheetItem, onDismiss: {
-            sheets.hideSheetIfActive(.usdtIntro, reason: "USDT intro dismissed")
-        }) { config in
-            UsdtIntroSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.quickpaySheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.quickpay, reason: "Quickpay sheet dismissed")
-                app.hasSeenQuickpayIntro = true
+            .sheet(
+                item: $sheets.securitySheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.security, reason: "Security sheet dismissed")
+                }
+            ) {
+                config in SecuritySheet(config: config)
+            }
+            .sheet(item: $sheets.usdtIntroSheetItem, onDismiss: {
+                sheets.hideSheetIfActive(.usdtIntro, reason: "USDT intro dismissed")
+            }) { config in
+                UsdtIntroSheet(config: config)
+            }
+            .sheet(
+                item: $sheets.quickpaySheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.quickpay, reason: "Quickpay sheet dismissed")
+                    app.hasSeenQuickpayIntro = true
+                }
+            ) {
+                config in QuickpaySheet(config: config)
             }
-        ) {
-            config in QuickpaySheet(config: config)
-        }
-        .sheet(
-            item: $sheets.sendSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.send, reason: "Send sheet dismissed")
+            .sheet(
+                item: $sheets.sendSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.send, reason: "Send sheet dismissed")
+                }
+            ) {
+                config in SendSheet(config: config)
             }
-        ) {
-            config in SendSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.forceTransferSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.forceTransfer, reason: "Force transfer sheet dismissed")
+            .sheet(
+                item: $sheets.forceTransferSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.forceTransfer, reason: "Force transfer sheet dismissed")
+                }
+            ) {
+                config in ForceTransferSheet(config: config)
             }
-        ) {
-            config in ForceTransferSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.widgetsSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.widgets, reason: "Widgets sheet dismissed")
+            .sheet(
+                item: $sheets.widgetsSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.widgets, reason: "Widgets sheet dismissed")
+                }
+            ) {
+                config in WidgetsSheet(config: config)
             }
-        ) {
-            config in WidgetsSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.hardwareConnectSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.hardwareConnect, reason: "Hardware connect sheet dismissed")
+    }
+
+    private var navigationWithHardwareSheets: some View {
+        navigationWithPaymentSheets
+            .sheet(
+                item: $sheets.hardwareConnectSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.hardwareConnect, reason: "Hardware connect sheet dismissed")
+                }
+            ) {
+                config in HardwareConnectSheet(config: config)
             }
-        ) {
-            config in HardwareConnectSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.hardwarePairingSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.hardwarePairing, reason: "Hardware pairing sheet dismissed")
+            .sheet(
+                item: $sheets.hardwarePairingSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.hardwarePairing, reason: "Hardware pairing sheet dismissed")
+                }
+            ) {
+                config in HardwarePairingSheet(config: config)
             }
-        ) {
-            config in HardwarePairingSheet(config: config)
-        }
-        .sheet(
-            item: $sheets.renameHardwareWalletSheetItem,
-            onDismiss: {
-                sheets.hideSheetIfActive(.renameHardwareWallet, reason: "Rename hardware wallet sheet dismissed")
+            .sheet(
+                item: $sheets.renameHardwareWalletSheetItem,
+                onDismiss: {
+                    sheets.hideSheetIfActive(.renameHardwareWallet, reason: "Rename hardware wallet sheet dismissed")
+                }
+            ) {
+                config in RenameHardwareWalletSheet(config: config)
+            }
+            .onChange(of: trezorManager.showPairingCode) { _, needsCode in
+                // A hardware device asked for its one-time pairing code (e.g. during reconnect);
+                // surface the app-wide Pair Device sheet. Hidden again once submitted/cancelled.
+                if needsCode {
+                    guard !sheets.hardwareConnectHandlesPairing else { return }
+                    if let activeId = sheets.activeSheetConfiguration?.id,
+                       activeId == .send || activeId == .receive
+                    {
+                        return
+                    }
+                    sheets.showSheet(.hardwarePairing)
+                } else {
+                    sheets.hideSheetIfActive(.hardwarePairing, reason: "Pairing code resolved")
+                }
             }
-        ) {
-            config in RenameHardwareWalletSheet(config: config)
-        }
-        .onChange(of: trezorManager.showPairingCode) { _, needsCode in
-            // A hardware device asked for its one-time pairing code (e.g. during reconnect);
-            // surface the app-wide Pair Device sheet. Hidden again once submitted/cancelled.
-            if needsCode {
-                guard !sheets.hardwareConnectHandlesPairing else { return }
-                if let activeId = sheets.activeSheetConfiguration?.id,
-                   activeId == .send || activeId == .receive
-                {
-                    return
+    }
+
+    private var navigationWithReceipts: some View {
+        navigationWithHardwareSheets
+            .task(id: scenePhase) {
+                guard usdt.isConfigured, scenePhase == .active else { return }
+                while !Task.isCancelled {
+                    await usdt.refresh(includeHistory: true)
+                    let pending = usdt.transfers.contains { $0.status == .pending }
+                    try? await Task.sleep(for: .seconds(pending ? 10 : 30))
                 }
-                sheets.showSheet(.hardwarePairing)
-            } else {
-                sheets.hideSheetIfActive(.hardwarePairing, reason: "Pairing code resolved")
             }
-        }
-        .task(id: scenePhase) {
-            guard usdt.isConfigured, scenePhase == .active else { return }
-            while !Task.isCancelled {
-                await usdt.refresh(includeHistory: true)
-                let pending = usdt.transfers.contains { $0.status == .pending }
-                try? await Task.sleep(for: .seconds(pending ? 10 : 30))
+            .onReceive(usdt.receivedTxPublisher) { tx in
+                guard !wallet.isRestoringWallet else { return }
+                usdtReceipts.append(tx)
+                presentUsdtReceipt()
             }
-        }
-        .onReceive(usdt.receivedTxPublisher) { tx in
-            guard !wallet.isRestoringWallet else { return }
-            usdtReceipts.append(tx)
-            presentUsdtReceipt()
-        }
-        .onChange(of: canPresentUsdtReceipt) { _, ready in
-            if ready { presentUsdtReceipt() }
-        }
-        .onChange(of: wallet.isRestoringWallet) { _, restoring in
-            if restoring { usdtReceipts.removeAll() }
-        }
-        .onReceive(hwWalletManager.receivedTxPublisher) { tx in
-            // New inbound transaction to a watched hardware wallet — show the received celebration.
-            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, sats: tx.sats))
-        }
-        .accentColor(.white)
-        .overlay {
-            TabBar()
-                .ignoresSafeArea(.keyboard)
-            DrawerView()
-        }
-        .onChange(of: sheets.activeSheetConfiguration?.id) { _, sheet in
-            if sheet == .receivedTx {
-                usdtReceipts.didPresent()
+            .onChange(of: canPresentUsdtReceipt) { _, ready in
+                if ready { presentUsdtReceipt() }
             }
-            if sheet != nil {
-                app.showDrawer = false
+            .onChange(of: wallet.isRestoringWallet) { _, restoring in
+                if restoring { usdtReceipts.removeAll() }
             }
-        }
-        .onChange(of: scenePhase) { _, newPhase in
-            if newPhase == .active {
-                // Update permissions in case user changed them in OS settings
-                notificationManager.updateNotificationPermission()
-                cameraManager.refreshPermission()
+            .onReceive(hwWalletManager.receivedTxPublisher) { tx in
+                // New inbound transaction to a watched hardware wallet — show the received celebration.
+                sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, sats: tx.sats))
             }
-        }
-        .onChange(of: scenePhase, initial: true) { _, newPhase in
-            guard newPhase == .active else { return }
-            handleClipboardIfEnabled()
-        }
-        .onChange(of: notificationManager.authorizationStatus) { _, newStatus in
-            // Handle notification permission changes
-            if newStatus == .authorized {
-                settings.enableNotifications = true
-                notificationManager.requestPermission()
-            } else {
-                settings.enableNotifications = false
-                notificationManager.unregister()
+            .accentColor(.white)
+            .overlay {
+                TabBar()
+                    .ignoresSafeArea(.keyboard)
+                DrawerView()
             }
-        }
-        .onChange(of: notificationManager.deviceToken) { _, token in
-            // Register with backend if device token changed and notifications are enabled
-            if let token, settings.enableNotifications {
-                Task {
-                    do {
-                        try await notificationManager.registerWithBackend(deviceToken: token)
-                    } catch {
-                        Logger.error("Failed to sync push notifications with backend: \(error)")
-                        app.toast(
-                            type: .error,
-                            title: t("other__notification_registration_failed_title"),
-                            description: t("other__notification_registration_failed_description")
-                        )
-                    }
+            .onChange(of: sheets.activeSheetConfiguration?.id) { _, sheet in
+                if sheet == .receivedTx {
+                    usdtReceipts.didPresent()
+                }
+                if sheet != nil {
+                    app.showDrawer = false
                 }
             }
-        }
-        .onChange(of: settings.enableNotifications) { _, newValue in
-            Task {
-                await paykitPaymentRequestManager.synchronizeSubscriptionNotifications(enabled: newValue)
-            }
-            // Handle notification enable/disable
-            if newValue {
-                // Request permission in case user was not prompted yet
-                notificationManager.requestPermission()
+    }
 
-                if let token = notificationManager.deviceToken {
+    var body: some View {
+        navigationWithReceipts
+            .onChange(of: scenePhase) { _, newPhase in
+                if newPhase == .active {
+                    // Update permissions in case user changed them in OS settings
+                    notificationManager.updateNotificationPermission()
+                    cameraManager.refreshPermission()
+                }
+            }
+            .onChange(of: scenePhase, initial: true) { _, newPhase in
+                guard newPhase == .active else { return }
+                handleClipboardIfEnabled()
+            }
+            .onChange(of: notificationManager.authorizationStatus) { _, newStatus in
+                // Handle notification permission changes
+                if newStatus == .authorized {
+                    settings.enableNotifications = true
+                    notificationManager.requestPermission()
+                } else {
+                    settings.enableNotifications = false
+                    notificationManager.unregister()
+                }
+            }
+            .onChange(of: notificationManager.deviceToken) { _, token in
+                // Register with backend if device token changed and notifications are enabled
+                if let token, settings.enableNotifications {
                     Task {
                         do {
                             try await notificationManager.registerWithBackend(deviceToken: token)
                         } catch {
-                            Logger.error("Failed to sync push notifications: \(error)")
+                            Logger.error("Failed to sync push notifications with backend: \(error)")
                             app.toast(
                                 type: .error,
                                 title: t("other__notification_registration_failed_title"),
@@ -404,48 +396,72 @@ struct MainNavView: View {
                         }
                     }
                 }
-            } else {
-                // Disable notifications (unregister)
-                notificationManager.unregister()
             }
-        }
-        .task(id: canHandleDeepLinks) {
-            guard canHandleDeepLinks else { return }
-            await handlePendingDeepLink()
-        }
-        .onChange(of: app.pendingDeepLinkURL) { _, url in
-            guard canHandleDeepLinks, url != nil else { return }
-            Task { await handlePendingDeepLink() }
-        }
-        .task(id: wallet.nodeLifecycleState == .running) {
-            guard canHandleDeepLinks,
-                  wallet.nodeLifecycleState == .running,
-                  let url = app.pendingDeepLinkURL,
-                  !PubkyContactLink.matches(url)
-            else { return }
-            await handlePendingDeepLink()
-        }
-        .onChange(of: canPrepareContactDeepLink) { _, canPrepare in
-            guard canHandleDeepLinks, canPrepare else { return }
-            Task { await handlePendingDeepLink() }
-        }
-        .onChange(of: isContactDeepLinkReady) { _, isReady in
-            guard canHandleDeepLinks, isReady else { return }
-            Task { await handlePendingDeepLink() }
-        }
-        .alert(
-            t("other__clipboard_redirect_title"),
-            isPresented: $showClipboardAlert
-        ) {
-            Button(t("common__ok")) {
-                processClipboardUri()
+            .onChange(of: settings.enableNotifications) { _, newValue in
+                Task {
+                    await paykitPaymentRequestManager.synchronizeSubscriptionNotifications(enabled: newValue)
+                }
+                // Handle notification enable/disable
+                if newValue {
+                    // Request permission in case user was not prompted yet
+                    notificationManager.requestPermission()
+
+                    if let token = notificationManager.deviceToken {
+                        Task {
+                            do {
+                                try await notificationManager.registerWithBackend(deviceToken: token)
+                            } catch {
+                                Logger.error("Failed to sync push notifications: \(error)")
+                                app.toast(
+                                    type: .error,
+                                    title: t("other__notification_registration_failed_title"),
+                                    description: t("other__notification_registration_failed_description")
+                                )
+                            }
+                        }
+                    }
+                } else {
+                    // Disable notifications (unregister)
+                    notificationManager.unregister()
+                }
             }
-            Button(t("common__dialog_cancel"), role: .cancel) {
-                clipboardUri = nil
+            .task(id: canHandleDeepLinks) {
+                guard canHandleDeepLinks else { return }
+                await handlePendingDeepLink()
+            }
+            .onChange(of: app.pendingDeepLinkURL) { _, url in
+                guard canHandleDeepLinks, url != nil else { return }
+                Task { await handlePendingDeepLink() }
+            }
+            .task(id: wallet.nodeLifecycleState == .running) {
+                guard canHandleDeepLinks,
+                      wallet.nodeLifecycleState == .running,
+                      let url = app.pendingDeepLinkURL,
+                      !PubkyContactLink.matches(url)
+                else { return }
+                await handlePendingDeepLink()
+            }
+            .onChange(of: canPrepareContactDeepLink) { _, canPrepare in
+                guard canHandleDeepLinks, canPrepare else { return }
+                Task { await handlePendingDeepLink() }
+            }
+            .onChange(of: isContactDeepLinkReady) { _, isReady in
+                guard canHandleDeepLinks, isReady else { return }
+                Task { await handlePendingDeepLink() }
+            }
+            .alert(
+                t("other__clipboard_redirect_title"),
+                isPresented: $showClipboardAlert
+            ) {
+                Button(t("common__ok")) {
+                    processClipboardUri()
+                }
+                Button(t("common__dialog_cancel"), role: .cancel) {
+                    clipboardUri = nil
+                }
+            } message: {
+                Text(t("other__clipboard_redirect_msg"))
             }
-        } message: {
-            Text(t("other__clipboard_redirect_msg"))
-        }
     }
 
     // MARK: - Loading View

From a33d89106a349a51526988c3182fb2ee11740a18 Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 18:41:44 -0500
Subject: [PATCH 59/62] fix: preserve receipt and refund presentation state

---
 Bitkit/MainNavView.swift                      |  2 +-
 Bitkit/ViewModels/SheetViewModel.swift        |  4 ++++
 .../Wallets/UsdtDepositHistoryView.swift      | 22 ++++++++++++++-----
 Bitkit/Views/Wallets/UsdtReceiveView.swift    |  4 ----
 BitkitTests/SheetViewModelTests.swift         |  9 ++++++++
 BitkitTests/UsdtWalletManagerTests.swift      | 21 ++++++++++++++++++
 journeys/usdt-bridge-details.xml              |  3 ++-
 7 files changed, 53 insertions(+), 12 deletions(-)

diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index 1803707a8..d2730ad42 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -62,7 +62,7 @@ struct MainNavView: View {
 
     private var canPresentUsdtReceipt: Bool {
         scenePhase == .active && !wallet.isRestoringWallet && !usdt.isSendPresented
-            && !sheets.isAnySheetOpen && !sheets.isReplacingSheet && navigation.currentRoute != .usdtDepositHistory
+            && sheets.canPresentReceivedTx && navigation.currentRoute != .usdtDepositHistory
     }
 
     private func presentUsdtReceipt() {
diff --git a/Bitkit/ViewModels/SheetViewModel.swift b/Bitkit/ViewModels/SheetViewModel.swift
index c84b5bdec..382cf546c 100644
--- a/Bitkit/ViewModels/SheetViewModel.swift
+++ b/Bitkit/ViewModels/SheetViewModel.swift
@@ -132,6 +132,10 @@ class SheetViewModel: ObservableObject {
         return activeSheetConfiguration != nil
     }
 
+    var canPresentReceivedTx: Bool {
+        !isReplacingSheet && (activeSheetConfiguration == nil || activeSheetConfiguration?.id == .receive)
+    }
+
     private func playHaptics(for sheetId: SheetID) {
         sheetId == .receivedTx ? Haptics.notify(.success) : Haptics.play(.openSheet)
     }
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index 05ce3912e..549220dfe 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -99,7 +99,7 @@ struct UsdtDepositHistoryView: View {
                     try Task.checkCancellation()
                 } catch { return }
                 guard !recoveryActive else { return }
-                await loadDetail(id)
+                await loadDetail(id, isRefreshing: true)
             }
         }
         .interactiveDismissDisabled(busy || pin)
@@ -254,13 +254,20 @@ struct UsdtDepositHistoryView: View {
         } catch is CancellationError {} catch { self.error = UsdtWalletManager.message(for: error) }
     }
 
-    private func loadDetail(_ id: String) async {
+    private func loadDetail(_ id: String, isRefreshing: Bool = false) async {
         guard !busy else { return }
-        busy = true
-        error = nil
-        defer { busy = false }
+        let previous = selected
+        guard !isRefreshing || previous?.deposit.id == id else { return }
+        if !isRefreshing {
+            busy = true
+            error = nil
+        }
+        defer { if !isRefreshing { busy = false } }
         do {
             let detail = try await usdt.depositDetail(id: id, offset: pageOffsets[id] ?? 0)
+            try Task.checkCancellation()
+            guard !isRefreshing || (!busy && !recoveryActive && selected == previous) else { return }
+            error = nil
             if selected?.deposit.id != id {
                 refundAddress = ""
                 approved = nil
@@ -271,7 +278,10 @@ struct UsdtDepositHistoryView: View {
                 message = nil
             }
             updateSelection(detail)
-        } catch is CancellationError {} catch { self.error = UsdtWalletManager.message(for: error) }
+        } catch is CancellationError {} catch {
+            guard !isRefreshing || (!busy && !recoveryActive && selected == previous) else { return }
+            self.error = UsdtWalletManager.message(for: error)
+        }
     }
 
     private func updateSelection(_ detail: UsdtDepositDetail) {
diff --git a/Bitkit/Views/Wallets/UsdtReceiveView.swift b/Bitkit/Views/Wallets/UsdtReceiveView.swift
index 58801609a..f0f770a82 100644
--- a/Bitkit/Views/Wallets/UsdtReceiveView.swift
+++ b/Bitkit/Views/Wallets/UsdtReceiveView.swift
@@ -72,10 +72,6 @@ struct UsdtReceiveView: View {
         .padding(.horizontal, 16)
         .background(Color.gray7)
         .preference(key: SheetBackgroundPreferenceKey.self, value: .gray7)
-        .onReceive(usdt.receivedTxPublisher) { transfer in
-            guard sheets.activeSheetConfiguration?.id == .receive else { return }
-            sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: transfer.amount, usdtTransferId: transfer.id))
-        }
         .task(id: scenePhase) {
             guard scenePhase == .active else { return }
             while !Task.isCancelled {
diff --git a/BitkitTests/SheetViewModelTests.swift b/BitkitTests/SheetViewModelTests.swift
index 7e2086a5e..5181fc9da 100644
--- a/BitkitTests/SheetViewModelTests.swift
+++ b/BitkitTests/SheetViewModelTests.swift
@@ -3,6 +3,15 @@ import XCTest
 
 @MainActor
 final class SheetViewModelTests: XCTestCase {
+    func testReceivedTransactionCanReplaceOnlyReceive() {
+        let sheets = SheetViewModel()
+        XCTAssertTrue(sheets.canPresentReceivedTx)
+        for id in SheetID.allCases {
+            sheets.activeSheetConfiguration = SheetConfiguration(id: id, data: nil)
+            XCTAssertEqual(sheets.canPresentReceivedTx, id == .receive, id.rawValue)
+        }
+    }
+
     func testLateDismissOfPreviousSheetKeepsNextSheetOpen() {
         let sheets = SheetViewModel()
 
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index c82e2149c..53622c088 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -355,6 +355,27 @@ final class UsdtWalletManagerTests: XCTestCase {
         XCTAssertNil(receipts.takeNext(canPresent: true))
     }
 
+    func testIncomingCelebrationReplacesReceiveAndDoesNotRepeatOnDismiss() async throws {
+        var receipts = UsdtReceiptQueue()
+        let sheets = SheetViewModel()
+        let received = transfer("received")
+        sheets.showSheet(.receive)
+        receipts.append(received)
+
+        let next = try XCTUnwrap(receipts.takeNext(canPresent: sheets.canPresentReceivedTx))
+        sheets.showSheet(.receivedTx, data: ReceivedTxSheetDetails(type: .onchain, usdtAmount: next.amount, usdtTransferId: next.id))
+        XCTAssertTrue(sheets.isReplacingSheet)
+        XCTAssertFalse(sheets.canPresentReceivedTx)
+        XCTAssertNil(receipts.takeNext(canPresent: sheets.canPresentReceivedTx))
+
+        try await Task.sleep(for: .milliseconds(800))
+        XCTAssertEqual(sheets.activeSheetConfiguration?.id, .receivedTx)
+        XCTAssertEqual((sheets.activeSheetConfiguration?.data as? ReceivedTxSheetDetails)?.usdtTransferId, received.id)
+        sheets.hideSheetIfActive(.receivedTx)
+        receipts.didDismiss()
+        XCTAssertNil(receipts.takeNext(canPresent: sheets.canPresentReceivedTx))
+    }
+
     private func transfer(_ id: String, incoming: Bool = true, status: UsdtTransferStatus = .confirmed, amount: UInt64 = 1_000_000) -> UsdtTransfer {
         UsdtTransfer(
             sender: nil,
diff --git a/journeys/usdt-bridge-details.xml b/journeys/usdt-bridge-details.xml
index 21e53ea3f..fec660fc6 100644
--- a/journeys/usdt-bridge-details.xml
+++ b/journeys/usdt-bridge-details.xml
@@ -5,7 +5,7 @@
     <action>Tap Details (id "UsdtActivityDetails"). Verify the real wallet transaction and available addresses are shown without inventing a provider deposit reference or refund eligibility.</action>
     <action>Open Cross-Network Deposits (id "UsdtDepositHistory"). Verify the Provider Status note says the spendable balance updates when USDT arrives on Arbitrum, and each row shows its source network, provider status and available amount.</action>
     <action>Open a supported deposit that needs attention (id "UsdtDepositRow-{depositId}"). Verify the summary appears first with the provider status and receiving network. Do not invent a deposit date or individual fee when the provider does not supply one. Tap Details (id "UsdtDepositDetails"). Verify its own source transaction and deposit reference are shown. Verify the refund instructions and address placeholder name that deposit's source network.</action>
-    <action>Enter an owned test refund address (id "UsdtRefundAddress") and tap Request refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the deposit amount formatted like its list row, network, full refund address and refund fee note. In a comma locale, a 3.5 USDT deposit must display 3,50 USDT. Hidden balances must remain masked, and an unknown amount must remain a dash. Cancel without submitting.</action>
+    <action>Enter an owned test refund address (id "UsdtRefundAddress") slowly across two background refreshes. Verify the field stays enabled and focused, the keyboard remains open, and every typed character is retained while the provider status updates. Then tap Request refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the deposit amount formatted like its list row, network, full refund address and refund fee note. In a comma locale, a 3.5 USDT deposit must display 3,50 USDT. Hidden balances must remain masked, and an unknown amount must remain a dash. Cancel without submitting.</action>
     <action>Tap Hide details (id "UsdtDepositDetails"), then Details again. Verify the provider status remains separate from wallet activity and the entered refund address is retained.</action>
     <action>Open completed, refunded and refund-in-progress deposit fixtures. Verify Request Refund is unavailable and the current provider status and available refund transaction are shown. An unsupported asset or network must show support guidance instead of a refund form.</action>
     <action>While Cross-Network Deposits is open, inject a confirmed incoming USDT transfer through the isolated fixture. Verify no received sheet interrupts deposit details or refund review. Return to the USDT wallet and verify the received celebration appears once after any active sheet is dismissed.</action>
@@ -13,6 +13,7 @@
     <action>Tap Details (id "UsdtActivityDetails"). Verify the source transaction, sender and recipient addresses, sender and recipient networks, Orchestra provider and bridge reference. Verify Open Block Explorer (id "UsdtActivityExplorer") and Hide details remain reachable.</action>
     <action>For a delayed, failed, refunding, refunded or support-needed bridge fixture, verify Contact Support (id "UsdtContactSupport") and Copy Details (id "UsdtCopyDetails") remain reachable from its details without submitting either action.</action>
     <action>Return to the USDT activity list. Verify Pending uses a yellow hourglass and 16% yellow circle, Failed uses a red x-circle and 16% red circle, and Transferring uses the teal transfer arrows. Sent and Received remain teal.</action>
+    <action>Open USDT Receive and inject one confirmed incoming USDT transfer through the isolated fixture. Verify Receive is replaced by one received celebration. Dismiss it and verify the same transfer is not celebrated again; a different subsequent transfer must still be shown.</action>
     <action>Open USDT Receive, then Network. Verify Cross-Network Deposits (id "UsdtDepositHistory") remains reachable before any Arbitrum receipt exists.</action>
   </actions>
 </journey>

From 4caa785ef436fde35d579a75a31c610dd64b6fed Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Wed, 14 Oct 2026 20:15:18 -0500
Subject: [PATCH 60/62] perf: reuse valid usdt payment quotes

---
 Bitkit/Models/UsdtPreparedQuote.swift     | 13 +++++++++
 Bitkit/Views/Wallets/UsdtSendView.swift   | 20 +++++++++++--
 BitkitTests/UsdtPreparedQuoteTests.swift  | 34 +++++++++++++++++++++++
 journeys/usdt-send-review-and-details.xml |  1 +
 4 files changed, 65 insertions(+), 3 deletions(-)
 create mode 100644 Bitkit/Models/UsdtPreparedQuote.swift
 create mode 100644 BitkitTests/UsdtPreparedQuoteTests.swift

diff --git a/Bitkit/Models/UsdtPreparedQuote.swift b/Bitkit/Models/UsdtPreparedQuote.swift
new file mode 100644
index 000000000..befb34cd5
--- /dev/null
+++ b/Bitkit/Models/UsdtPreparedQuote.swift
@@ -0,0 +1,13 @@
+import BitkitCore
+import Foundation
+
+struct UsdtPreparedQuote {
+    let quote: UsdtQuote
+    let amount: String
+    let sender: String
+
+    func matches(recipient: String, amount: String, destination: UsdtDestination, sender: String, now: Date = Date()) -> Bool {
+        !sender.isEmpty && self.sender == sender && self.amount == amount && quote.recipient == recipient && quote.destination == destination
+            && Double(quote.expiresAt) > now.timeIntervalSince1970 + 5
+    }
+}
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 7cfbebf2d..20e556851 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -24,6 +24,7 @@ struct UsdtSendView: View {
     @State private var destinations = Env.usdtDestinations
     @State private var quote: UsdtQuote?
     @State private var maximumQuote: UsdtQuote?
+    @State private var preparedQuote: UsdtPreparedQuote?
     @State private var isMaximumAmount = false
     @State private var preparingMaximum = false
     @State private var editingRecipient = false
@@ -115,7 +116,7 @@ struct UsdtSendView: View {
         }
         .preference(key: SheetBackgroundPreferenceKey.self, value: .gray7)
         .onAppear { usdt.isSendPresented = true }
-        .onDisappear { usdt.isSendPresented = false }
+        .onDisappear { usdt.isSendPresented = false; preparedQuote = nil }
         .task(id: settings.isUsdtEnabled) {
             if !embedded {
                 do { destinations = try await usdt.sendDestinations() }
@@ -127,7 +128,7 @@ struct UsdtSendView: View {
                   (try? parsePaykitAmountInput(asset: .usdt, value: amount)) != nil else { return }
             busy = true
             defer { busy = false }
-            do { quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination) }
+            do { quote = try await prepareQuote() }
             catch { self.error = UsdtWalletManager.message(for: error) }
         }
     }
@@ -324,7 +325,7 @@ struct UsdtSendView: View {
                         quote = prepared
                         amount = usdtFormatAmount(amount: prepared.amount)
                     } else {
-                        quote = try await usdt.quote(recipient: recipient, amount: amount, destination: destination)
+                        quote = try await prepareQuote()
                     }
                     showDetails = false
                     confirmedWarnings = []
@@ -559,10 +560,22 @@ struct UsdtSendView: View {
         error = nil
     }
 
+    private func prepareQuote() async throws -> UsdtQuote {
+        if let preparedQuote, preparedQuote.matches(recipient: recipient, amount: amount, destination: destination, sender: usdt.address) {
+            return preparedQuote.quote
+        }
+        preparedQuote = nil
+        let sender = usdt.address
+        let result = try await usdt.quote(recipient: recipient, amount: amount, destination: destination)
+        preparedQuote = UsdtPreparedQuote(quote: result, amount: amount, sender: sender)
+        return result
+    }
+
     private func useMaximum() async {
         guard !busy, !embedded else { return }
         busy = true
         preparingMaximum = true
+        preparedQuote = nil
         error = nil
         defer { busy = false; preparingMaximum = false }
         do {
@@ -624,6 +637,7 @@ struct UsdtSendView: View {
         busy = true
         error = nil
         maximumQuote = nil
+        preparedQuote = nil
         defer { if !submitted { busy = false } }
         do {
             if let sendPayment { try await sendPayment(quote) }
diff --git a/BitkitTests/UsdtPreparedQuoteTests.swift b/BitkitTests/UsdtPreparedQuoteTests.swift
new file mode 100644
index 000000000..5f35961f1
--- /dev/null
+++ b/BitkitTests/UsdtPreparedQuoteTests.swift
@@ -0,0 +1,34 @@
+@testable import Bitkit
+import BitkitCore
+import XCTest
+
+final class UsdtPreparedQuoteTests: XCTestCase {
+    private let sender = "0x2222222222222222222222222222222222222222"
+    private let recipient = "0x1111111111111111111111111111111111111111"
+
+    private var prepared: UsdtPreparedQuote {
+        UsdtPreparedQuote(
+            quote: UsdtQuote(bridgeProvider: nil, id: "quote", recipient: recipient, destination: .arbitrum,
+                             amount: 1_000_000, receivedAmount: 1_000_000, maximumFee: 20, expiresAt: 120),
+            amount: "1", sender: sender
+        )
+    }
+
+    func testUnchangedPaymentKeepsTheApprovedFeeUntilTheExpiryBuffer() {
+        XCTAssertTrue(prepared.matches(recipient: recipient, amount: "1", destination: .arbitrum, sender: sender,
+                                       now: Date(timeIntervalSince1970: 114)))
+        for timestamp in [115.0, 119.0, 120.0, 121.0] {
+            XCTAssertFalse(prepared.matches(recipient: recipient, amount: "1", destination: .arbitrum, sender: sender,
+                                            now: Date(timeIntervalSince1970: timestamp)), "timestamp \(timestamp)")
+        }
+    }
+
+    func testDifferentPaymentOrWalletRequiresANewQuote() {
+        let now = Date(timeIntervalSince1970: 100)
+        XCTAssertFalse(prepared.matches(recipient: sender, amount: "1", destination: .arbitrum, sender: sender, now: now))
+        XCTAssertFalse(prepared.matches(recipient: recipient, amount: "2", destination: .arbitrum, sender: sender, now: now))
+        XCTAssertFalse(prepared.matches(recipient: recipient, amount: "1", destination: .polygon, sender: sender, now: now))
+        XCTAssertFalse(prepared.matches(recipient: recipient, amount: "1", destination: .arbitrum, sender: recipient, now: now))
+        XCTAssertFalse(prepared.matches(recipient: recipient, amount: "1", destination: .arbitrum, sender: "", now: now))
+    }
+}
diff --git a/journeys/usdt-send-review-and-details.xml b/journeys/usdt-send-review-and-details.xml
index 1edb96b80..da2c22bcb 100644
--- a/journeys/usdt-send-review-and-details.xml
+++ b/journeys/usdt-send-review-and-details.xml
@@ -7,6 +7,7 @@
     <action>From recipient entry with another network selected, paste an explicit Arbitrum USDT URI. Verify the selected network becomes Arbitrum and the link amount is retained. A plain 0x address preserves the selected network.</action>
     <action>Tap MAX. Verify it fills a positive amount below the balance and remains on Amount. Continue and verify the payment plus maximum fee fits within the balance. Back out without swiping.</action>
     <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note in the scrollable details. Displayed amounts round to cents; nonzero values below one cent show &lt;0.01. Hide Details restores the illustration. Cancel without paying.</action>
+    <action>Prepare an ordinary amount and note the payment, fee and maximum total in Details. Go back to Amount and immediately continue without editing; verify the same review values return. Go back, change the amount and continue; verify the payment reflects the new amount. Go back, wait until the quote expires (at most two minutes) and continue; verify a new quote is obtained or an error leaves the amount editable, rather than displaying expired fees. Cancel without swiping.</action>
     <action>Prepare a cross-network payment and continue. Verify You send labels the entered amount and Recipient gets appears directly beneath it, with an approximation marker for Orchestra. Verify the recipient amount follows the quote rather than assuming it equals the sent amount. Without scrolling, verify Show Details (id "UsdtReviewDetails"), Maximum total debit (id "UsdtMaximumTotal") and its value are fully visible above Swipe To Pay. Show Details and verify Hide Details remains visible above the maximum, Payment is labelled You send, and the fee note can be read by scrolling without overlapping the pinned total. For Orchestra, also verify the deducted bridge cost is fully readable when scrolled into view. Cancel without paying.</action>
     <action>Open an existing sent USDT activity. Verify the heading is Sent USDT, the signed amount includes the actual fee, and summary rows show Status/Network, Date/Time and Payment/Fee with teal icons. Open Details and verify transaction ID, known sender, recipient and source/destination networks; Open Block Explorer stays at the bottom.</action>
     <action>Open an existing received activity. Verify Received USDT and a positive amount. Verify Details shows the verified sender when available and does not invent one for older unknown records. Check pending, failed and transferring rows use their matching icons, and transferring shows its destination.</action>

From 49033c765c9b612aed05d6127e7f781a35538e5a Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Thu, 15 Oct 2026 03:42:03 -0500
Subject: [PATCH 61/62] fix: prefer funded usdt for quoted requests

---
 Bitkit/ViewModels/AppViewModel.swift          |  9 +++++--
 .../PaykitPaymentRequestServiceTests.swift    | 25 +++++++++++++++++++
 journeys/paykit-quoted-usdt.xml               |  1 +
 3 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/Bitkit/ViewModels/AppViewModel.swift b/Bitkit/ViewModels/AppViewModel.swift
index f818f84ac..d8760d68c 100644
--- a/Bitkit/ViewModels/AppViewModel.swift
+++ b/Bitkit/ViewModels/AppViewModel.swift
@@ -45,8 +45,13 @@ struct ContactPaymentContext: Equatable {
     ) -> Bool {
         guard endpoints.contains(where: { $0.methodId == .usdtArbitrum }) else { return false }
         if !endpoints.contains(where: { $0.methodId != .usdtArbitrum }) { return true }
-        return isUsdtEnabled && (incomingPaymentRequest.map { $0.amount.asset != .btc } == true ||
-            (onchainBalanceSats == 0 && !canSendLightning && usdtBalance > 0))
+        guard isUsdtEnabled else { return false }
+        if let request = incomingPaymentRequest, request.amount.asset != .btc {
+            let now = Date()
+            guard let payment = try? request.payment(using: .usdtArbitrum, at: now), payment.isValid(at: now) else { return false }
+            return usdtBalance >= payment.amount.atomic
+        }
+        return onchainBalanceSats == 0 && !canSendLightning && usdtBalance > 0
     }
 
     init(
diff --git a/BitkitTests/PaykitPaymentRequestServiceTests.swift b/BitkitTests/PaykitPaymentRequestServiceTests.swift
index 9bedd380c..a2b6b0857 100644
--- a/BitkitTests/PaykitPaymentRequestServiceTests.swift
+++ b/BitkitTests/PaykitPaymentRequestServiceTests.swift
@@ -11,6 +11,31 @@ import XCTest
 
 @MainActor
 final class PaykitPaymentRequestServiceTests: XCTestCase {
+    func testDollarRequestsPreferUsdtOnlyWhenTheQuotedAmountIsCovered() throws {
+        let bitcoin = PublicPaykitService.Endpoint(
+            methodId: .regtestOnchainP2wpkh,
+            value: "bcrt1qexample",
+            min: nil,
+            max: nil,
+            rawPayload: "bcrt1qexample"
+        )
+        let usdt = try PaykitUsdt.endpoint(address: "0x1111111111111111111111111111111111111111")
+        let endpoints = [bitcoin, usdt]
+        let rates = [ConversionRate(asset: "btc", value: "0.00001"), ConversionRate(asset: "usdt", value: "1"),
+                     ConversionRate(asset: "usdt-arbitrum", value: "1.2345678")]
+        let record = try paymentRequestRecord(amount: "1", asset: "usd", conversion: .fixed(rates: rates),
+                                              endpoints: endpoints.map(\.methodId.rawValue))
+        let request = try PaykitPaymentRequest.parseIncoming(record: record, now: Date(), network: .regtest).get()
+        let context = ContactPaymentContext(publicKey: request.counterparty, incomingPaymentRequest: request, endpoints: endpoints)
+        for (balance, expected): (UInt64, Bool) in [(0, false), (1_000_000, false), (1_234_567, false), (1_234_568, true), (2_000_000, true)] {
+            XCTAssertEqual(context.prefersUsdt(onchainBalanceSats: 0, usdtBalance: balance), expected, "balance \(balance)")
+            XCTAssertEqual(context.prefersUsdt(onchainBalanceSats: 100_000, canSendLightning: true, usdtBalance: balance), expected)
+        }
+        XCTAssertFalse(context.prefersUsdt(onchainBalanceSats: 0, usdtBalance: 2_000_000, isUsdtEnabled: false))
+        let usdtOnly = ContactPaymentContext(publicKey: request.counterparty, incomingPaymentRequest: request, endpoints: [usdt])
+        XCTAssertTrue(usdtOnly.prefersUsdt(onchainBalanceSats: 100_000, usdtBalance: 0))
+    }
+
     func testMonthlyCostCombinesAssetsUsingTheWalletRate() {
         let now = Date()
         let amounts = [
diff --git a/journeys/paykit-quoted-usdt.xml b/journeys/paykit-quoted-usdt.xml
index a3a5cabe9..bd97b2a6f 100644
--- a/journeys/paykit-quoted-usdt.xml
+++ b/journeys/paykit-quoted-usdt.xml
@@ -11,6 +11,7 @@
     <action>Deselect all receiving choices and verify sending the request is disabled. Select only USDT, enter 150,50 USD on the comma-decimal locale, select an expiry and send the request. Verify the sent screen, outgoing request card and request details all show 150,50 USD. Reopen the amount editor on a new request and verify typed trailing zeros are preserved.</action>
     <action>On the payer using the same comma-decimal locale, verify the incoming request card and details show 150,50 USD. Open the request and verify Amount represents exactly 150.50 USDT with USDT selected as the payment method, the amount cannot be edited, and no Bitcoin funding source is offered. Close without continuing to review.</action>
     <action>Reopen the unpaid USDT request and wait for its Amount screen. Tap Back and verify the send sheet closes without showing a Bitcoin confirmation or a Swipe To Pay control. Reopen the same request and verify its amount and USDT payment method are preserved. Close without paying.</action>
+    <action>Create a USD request accepting Bitcoin and USDT whose quoted USDT amount is greater than the payer's USDT balance. On the payer, open the request and verify Bitcoin starts selected; USDT remains available for manual selection. Close without continuing. Repeat with a request whose quoted USDT amount is covered by that balance and verify USDT starts selected. This initial choice covers the requested amount only; fees are checked when preparing payment.</action>
     <action>Create a BTC request accepting Bitcoin and USDT. On the payer's Amount screen, switch between available Savings, Spending and USDT sources. Verify the displayed amount preserves the request's quoted value and cannot be edited. Close without continuing.</action>
     <action>Create a USD subscription for 150,50 on a comma-decimal locale. Verify the amount review shows 150,50 USD and editing preserves that amount. Verify Accepted Payments appears below frequency, with USDT selected and Bitcoin unselected. Verify the description and icon controls are side by side. Propose it to the linked contact. On the payer, verify the subscription card and details show 150,50 USD, then review its recurrence and USDT payment method. Verify the subscription swipe uses USDT teal, then close before subscribing.</action>
     <action>Create a BTC subscription for 12,345 sats and verify Bitcoin is selected. Tap SubscriptionAccept-usdt; verify the amount converts to USD and only USDT is selected. Tap SubscriptionAccept-bitcoin; verify the amount returns to exactly 12,345 sats and only Bitcoin is selected, covering the enabled Savings and Spending methods.</action>

From 767789ad3430679f7958d79418acf50579cecf0b Mon Sep 17 00:00:00 2001
From: benk10 <ben.kaufman10@gmail.com>
Date: Thu, 15 Oct 2026 04:30:38 -0500
Subject: [PATCH 62/62] fix: preserve usdt recovery and payment details

---
 Bitkit/MainNavView.swift                      |  2 +-
 Bitkit/Managers/UsdtWalletManager.swift       | 43 ++++++++++++-------
 Bitkit/Models/UsdtPreparedQuote.swift         |  8 ++++
 .../Services/PaykitUsdtPaymentService.swift   | 27 +++++++++---
 .../PaymentRequests/PaymentRequestsView.swift |  2 +-
 .../Views/Wallets/Send/SendAmountView.swift   |  2 +-
 .../Wallets/UsdtDepositHistoryView.swift      |  2 +-
 Bitkit/Views/Wallets/UsdtSendView.swift       | 12 ++++--
 Bitkit/Views/Wallets/UsdtWalletScreen.swift   |  4 ++
 .../PaykitPaymentStateBackupTests.swift       |  9 ++--
 BitkitTests/UsdtDisplayTests.swift            |  6 +++
 BitkitTests/UsdtPreparedQuoteTests.swift      | 12 ++++++
 BitkitTests/UsdtWalletManagerTests.swift      | 26 ++++++++++-
 Docs/USDT.md                                  |  4 +-
 journeys/usdt-bridge-details.xml              |  2 +-
 journeys/usdt-opt-in.xml                      |  1 +
 journeys/usdt-send-review-and-details.xml     |  1 +
 17 files changed, 126 insertions(+), 37 deletions(-)

diff --git a/Bitkit/MainNavView.swift b/Bitkit/MainNavView.swift
index d2730ad42..d92741cd3 100644
--- a/Bitkit/MainNavView.swift
+++ b/Bitkit/MainNavView.swift
@@ -321,7 +321,7 @@ struct MainNavView: View {
             .task(id: scenePhase) {
                 guard usdt.isConfigured, scenePhase == .active else { return }
                 while !Task.isCancelled {
-                    await usdt.refresh(includeHistory: true)
+                    if usdt.shouldRefresh(enabled: settings.isUsdtEnabled) { await usdt.refresh(includeHistory: true) }
                     let pending = usdt.transfers.contains { $0.status == .pending }
                     try? await Task.sleep(for: .seconds(pending ? 10 : 30))
                 }
diff --git a/Bitkit/Managers/UsdtWalletManager.swift b/Bitkit/Managers/UsdtWalletManager.swift
index 41680d911..801fecb26 100644
--- a/Bitkit/Managers/UsdtWalletManager.swift
+++ b/Bitkit/Managers/UsdtWalletManager.swift
@@ -30,6 +30,8 @@ final class UsdtWalletManager {
     var isSendPresented = false
     private var core: UsdtWallet?
     private let storageDirectory: URL
+    private let rpcUrl: String?
+    private let bundlerUrl: String?
     private let loadCredentials: @MainActor () async throws -> (String, String?)
     private var wiping = false
     private var activeOperations = 0
@@ -42,7 +44,19 @@ final class UsdtWalletManager {
     private var idleWaiter: CheckedContinuation<Void, Never>?
 
     var isConfigured: Bool {
-        Env.isUsdtEnabled
+        Env.isUsdtEnabled && rpcUrl != nil && bundlerUrl != nil
+    }
+
+    var hasStoredWallet: Bool {
+        get throws {
+            guard FileManager.default.fileExists(atPath: storageDirectory.path) else { return false }
+            return try FileManager.default.contentsOfDirectory(at: storageDirectory, includingPropertiesForKeys: nil)
+                .contains { $0.lastPathComponent.hasPrefix("usdt-") && $0.pathExtension == "sqlite" }
+        }
+    }
+
+    func shouldRefresh(enabled: Bool) -> Bool {
+        enabled || hasProtectedFunds || (balance == nil && (try? hasStoredWallet) == true)
     }
 
     var hasProtectedFunds: Bool {
@@ -90,6 +104,8 @@ final class UsdtWalletManager {
 
     init(
         storageDirectory: URL = Env.bitkitCoreStorage(walletIndex: 0),
+        rpcUrl: String? = Env.usdtRpcUrl,
+        bundlerUrl: String? = Env.usdtBundlerUrl,
         loadCredentials: @escaping @MainActor () async throws -> (String, String?) = {
             try await ServiceQueue.background(.core, wrapErrors: false) {
                 guard let mnemonic = try Keychain.loadString(key: .bip39Mnemonic(index: 0)) else { throw UsdtError.InvalidCredentials }
@@ -98,6 +114,8 @@ final class UsdtWalletManager {
         }
     ) {
         self.storageDirectory = storageDirectory
+        self.rpcUrl = rpcUrl
+        self.bundlerUrl = bundlerUrl
         self.loadCredentials = loadCredentials
     }
 
@@ -174,25 +192,17 @@ final class UsdtWalletManager {
     }
 
     func backupSnapshot() async throws -> String? {
-        guard isConfigured else {
-            if FileManager.default.fileExists(atPath: storageDirectory.path) {
-                let files = try FileManager.default.contentsOfDirectory(at: storageDirectory, includingPropertiesForKeys: nil)
-                guard !files.contains(where: { $0.lastPathComponent.hasPrefix("usdt-") && $0.pathExtension == "sqlite" }) else {
-                    throw UsdtError.NotConfigured
-                }
-            }
-            return nil
-        }
+        guard try hasStoredWallet else { return nil }
         try beginOperation()
         defer { finishOperation() }
-        let wallet = try await wallet()
+        let wallet = try await wallet(requiresNetwork: false)
         return try await ServiceQueue.background(.core, wrapErrors: false) { try wallet.exportBackup() }
     }
 
     func restoreBackup(_ snapshot: String) async throws {
         try beginOperation()
         defer { finishOperation() }
-        let wallet = try await wallet()
+        let wallet = try await wallet(requiresNetwork: false)
         try await wallet.restoreBackup(snapshot: snapshot)
         pendingDepositIds.removeAll()
         transfers = try wallet.history()
@@ -402,11 +412,14 @@ final class UsdtWalletManager {
         }
     }
 
-    private func wallet() async throws -> UsdtWallet {
-        guard isConfigured, let bundlerUrl = Env.usdtBundlerUrl, let rpcUrl = Env.usdtRpcUrl else { throw UsdtError.NotConfigured }
+    private func wallet(requiresNetwork: Bool = true) async throws -> UsdtWallet {
+        if requiresNetwork, !isConfigured { throw UsdtError.NotConfigured }
         if let core { return core }
         if let initialization { return try await initialization.value }
-        let task = Task { try await initializeWallet(bundlerUrl: bundlerUrl, rpcUrl: rpcUrl) }
+        // Core's constructor requires URLs even for local export/restore. Network operations remain configuration-gated.
+        let task = Task {
+            try await initializeWallet(bundlerUrl: bundlerUrl ?? "http://127.0.0.1:1", rpcUrl: rpcUrl ?? "http://127.0.0.1:1")
+        }
         initialization = task
         defer { initialization = nil }
         return try await task.value
diff --git a/Bitkit/Models/UsdtPreparedQuote.swift b/Bitkit/Models/UsdtPreparedQuote.swift
index befb34cd5..a037d8876 100644
--- a/Bitkit/Models/UsdtPreparedQuote.swift
+++ b/Bitkit/Models/UsdtPreparedQuote.swift
@@ -11,3 +11,11 @@ struct UsdtPreparedQuote {
             && Double(quote.expiresAt) > now.timeIntervalSince1970 + 5
     }
 }
+
+extension UsdtQuote {
+    var totalCost: UInt64 {
+        let deductedFee = amount - min(amount, receivedAmount)
+        let (cost, overflow) = maximumFee.addingReportingOverflow(deductedFee)
+        return overflow ? UInt64.max : cost
+    }
+}
diff --git a/Bitkit/Services/PaykitUsdtPaymentService.swift b/Bitkit/Services/PaykitUsdtPaymentService.swift
index 6025655cc..aaf0400d5 100644
--- a/Bitkit/Services/PaykitUsdtPaymentService.swift
+++ b/Bitkit/Services/PaykitUsdtPaymentService.swift
@@ -77,7 +77,8 @@ final class PaykitUsdtPaymentService {
     private var activeIdentity: String?
     private var reconciling = false
     private var preparing = false
-    private var restoreGeneration = 0
+    private var stateGeneration = 0
+    private var sending = false
     private(set) var resumableRequests: Set<PaykitPaymentRequest.ID> = []
     private var releasedAttempts: [Attempt] = []
     private var boundRequestIds: Set<PaykitPaymentRequest.ID>?
@@ -95,7 +96,7 @@ final class PaykitUsdtPaymentService {
 
     func restoreBackup(_ backup: PaykitUsdtStateBackup) throws {
         boundRequestIds = nil
-        restoreGeneration &+= 1
+        stateGeneration &+= 1
         releasedAttempts = []
         resumableRequests = []
         var state = try load()
@@ -123,6 +124,10 @@ final class PaykitUsdtPaymentService {
               wallet: UsdtWalletManager, authorize: @escaping @MainActor () async throws -> Void) async throws
     {
         let submissionDeadline = try context.incomingPaymentRequest?.submissionDeadline(quoteId: paymentTerms?.quoteId)
+        guard !sending else { throw PaykitPaymentRequestError.operationInProgress }
+        sending = true
+        stateGeneration += 1
+        defer { sending = false }
         try setPaymentStarted(quoteId: quote.id, started: true)
         do {
             try await wallet.send(quote, submissionDeadline: submissionDeadline) {
@@ -319,7 +324,7 @@ final class PaykitUsdtPaymentService {
     }
 
     func reconcile(wallet: UsdtWalletManager) async {
-        guard wallet.isConfigured else {
+        guard wallet.isConfigured, UsdtPreference.isEnabled() || (try? wallet.hasStoredWallet) == true else {
             boundRequestIds = nil
             releasedAttempts = []
             resumableRequests = []
@@ -347,8 +352,8 @@ final class PaykitUsdtPaymentService {
         paymentRequests: () async throws -> [Paykit.PaymentRequestRecord],
         verifyPayment: (UsdtPaymentProofBinding, UsdtPaymentProof) async throws -> UsdtVerifiedPayment?
     ) async {
-        guard !reconciling else { return }
-        let generation = restoreGeneration
+        guard !reconciling, !sending else { return }
+        let generation = stateGeneration
         reconciling = true
         defer { reconciling = false }
         boundRequestIds = nil
@@ -363,11 +368,19 @@ final class PaykitUsdtPaymentService {
             publish(state)
             var resumable: [Attempt] = []
             var released: [Attempt] = []
-            for attempt in state.attempts where attempt.wallet == owner && attempt.identity == identity {
+            for var attempt in state.attempts where attempt.wallet == owner && attempt.identity == identity {
                 guard let requestId = attempt.requestId else { continue }
                 do {
                     try Task.checkCancellation()
                     let transfer = try await storedTransfer(attempt.quoteId)
+                    guard stateGeneration == generation else { return }
+                    if transfer == nil, attempt.paymentStarted {
+                        var current = try load()
+                        guard let index = current.attempts.firstIndex(of: attempt) else { continue }
+                        attempt.paymentStarted = false
+                        current.attempts[index] = attempt
+                        try save(current)
+                    }
                     let unexecuted = (transfer == nil && !attempt.paymentStarted) || transfer?.status == .failed || transfer?.status == .replaced
                     if unexecuted { resumable.append(attempt) }
                     if unexecuted, attempt.proof == nil, !attempt.proofQueued {
@@ -409,7 +422,7 @@ final class PaykitUsdtPaymentService {
                     Logger.warn("Unable to reconcile Paykit USDT payment attempt: \(error)", context: "PaykitUsdt")
                 }
             }
-            guard restoreGeneration == generation, activeWallet == owner, activeIdentity == identity else { return }
+            guard stateGeneration == generation, activeWallet == owner, activeIdentity == identity else { return }
             let currentState = try load()
             resumableRequests = Set(resumable.filter { currentState.attempts.contains($0) }.compactMap(\.requestId))
             releasedAttempts = released.filter { currentState.attempts.contains($0) }
diff --git a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
index b07e17598..8bd4e7b63 100644
--- a/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
+++ b/Bitkit/Views/PaymentRequests/PaymentRequestsView.swift
@@ -735,6 +735,6 @@ private extension PaykitUsdtPaymentService.Receipt {
         let key = !verified ? "wallet__payment_request_status_pending" :
             underpaid ? "wallet__payment_request_underpaid" :
             afterExpiry ? "wallet__payment_request_after_expiry" : "wallet__payment_request_payment_verified"
-        return t(key) + " · " + usdtOverviewAmount(amount.atomic) + " USDT"
+        return t(key) + " · " + usdtExactAmount(amount.atomic) + " USDT"
     }
 }
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
index 4419f28d8..453ef120e 100644
--- a/Bitkit/Views/Wallets/Send/SendAmountView.swift
+++ b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -282,7 +282,7 @@ struct SendAmountView: View {
                 }
             }
         }
-        .task { await usdt.refresh() }
+        .task { if usdt.shouldRefresh(enabled: settings.isUsdtEnabled) { await usdt.refresh() } }
         .onChange(of: paymentRequests.pendingRequests) { updateRequestAmount() }
         .onChange(of: app.selectedWalletToPayFrom) { _, newValue in
             // Recalculate max sendable amount when switching wallet types
diff --git a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
index 549220dfe..2717b0192 100644
--- a/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
+++ b/Bitkit/Views/Wallets/UsdtDepositHistoryView.swift
@@ -355,7 +355,7 @@ extension UsdtDepositDetail {
 
     func refundConfirmation(address: String, hideBalance: Bool, locale: Locale = .current) -> String {
         t("usdt__deposit_refund_confirmation", variables: [
-            "amount": hideBalance ? "• • • • •" : deposit.amount.map { usdtOverviewAmount($0, locale: locale) } ?? "—",
+            "amount": hideBalance ? "• • • • •" : deposit.amount.map { usdtExactAmount($0, locale: locale) } ?? "—",
             "network": UsdtDepositNetwork.named(deposit.network) == .bsc ? "BNB Smart Chain (BSC)" : deposit.networkLabel,
             "shortNetwork": deposit.refundNetworkLabel,
             "address": address,
diff --git a/Bitkit/Views/Wallets/UsdtSendView.swift b/Bitkit/Views/Wallets/UsdtSendView.swift
index 20e556851..4f7f0f6be 100644
--- a/Bitkit/Views/Wallets/UsdtSendView.swift
+++ b/Bitkit/Views/Wallets/UsdtSendView.swift
@@ -97,6 +97,7 @@ struct UsdtSendView: View {
         if showingNetworks { return t("usdt__receive_network_title") }
         if submitted, !busy {
             if submittedStatus == .confirmed { return t("usdt__payment_sent") }
+            if error != nil { return t("wallet__payment_request_expired") }
             if submittedStatus == .bridgeRefunded { return t("usdt__deposit_refunded") }
             if bridgeNeedsAttention { return t("usdt__bridge_attention") }
             return t(submissionFailed ? "wallet__send_error_tx_failed" : "usdt__submitted")
@@ -491,7 +492,9 @@ struct UsdtSendView: View {
                 UsdtAmountHeader(amount: usdtFormatAmount(amount: quote.amount), displayAmount: usdtOverviewAmount(quote.amount))
                     .padding(.bottom, 32)
             }
-            if submittedStatus == .bridgeRefunded {
+            if let error {
+                BodyMText(error, textColor: .textSecondary)
+            } else if submittedStatus == .bridgeRefunded {
                 BodyMText(t("usdt__bridge_refunded_description"), textColor: .textSecondary)
             } else if submittedStatus != .confirmed {
                 BodyMText(t(bridgeNeedsAttention ? "usdt__bridge_attention" : submissionFailed ? "usdt__send_failed_description"
@@ -601,8 +604,8 @@ struct UsdtSendView: View {
         var warnings: [String] = []
         if let balance = usdt.balance, quote.amount > balance / 2 { warnings.append("wallet__send_dialog2") }
         if settings.warnWhenSendingOver100, quote.amount > 100_000_000 { warnings.append("wallet__send_dialog1") }
-        if quote.maximumFee > 10_000_000 { warnings.append("wallet__send_dialog4") }
-        if quote.maximumFee > quote.amount / 2 { warnings.append("wallet__send_dialog3") }
+        if quote.totalCost > 10_000_000 { warnings.append("wallet__send_dialog4") }
+        if quote.totalCost > quote.amount / 2 { warnings.append("wallet__send_dialog3") }
         if let next = warnings.first(where: { !confirmedWarnings.contains($0) }) {
             warning = next
             return
@@ -647,6 +650,9 @@ struct UsdtSendView: View {
         } catch is CancellationError {} catch {
             if usdt.transfers.contains(where: { $0.id == quote.id }) {
                 submitted = true
+                if case UsdtError.SubmissionDeadlineExpired = error {
+                    self.error = UsdtWalletManager.message(for: error)
+                }
             } else {
                 self.error = if error is UsdtError {
                     UsdtWalletManager.message(for: error)
diff --git a/Bitkit/Views/Wallets/UsdtWalletScreen.swift b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
index ad3b98f5f..f77d504af 100644
--- a/Bitkit/Views/Wallets/UsdtWalletScreen.swift
+++ b/Bitkit/Views/Wallets/UsdtWalletScreen.swift
@@ -196,6 +196,10 @@ func usdtOverviewAmount(_ amount: UInt64, locale: Locale = .current) -> String {
     return (Decimal(amount) / 1_000_000).formatted(format)
 }
 
+func usdtExactAmount(_ amount: UInt64, locale: Locale = .current) -> String {
+    (Decimal(amount) / 1_000_000).formatted(.number.precision(.fractionLength(2 ... 6)).locale(locale))
+}
+
 func usdtInputAmount(_ amount: String, locale: Locale = .current) -> String {
     amount.replacingOccurrences(of: ".", with: locale.decimalSeparator ?? ".")
 }
diff --git a/BitkitTests/PaykitPaymentStateBackupTests.swift b/BitkitTests/PaykitPaymentStateBackupTests.swift
index 338f4c424..98253c9e8 100644
--- a/BitkitTests/PaykitPaymentStateBackupTests.swift
+++ b/BitkitTests/PaykitPaymentStateBackupTests.swift
@@ -151,7 +151,8 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
     @MainActor
     func testUnsubmittedUsdtBindingRequiresCurrentJournalEvidenceAfterRestart() async throws {
         let service = PaykitUsdtPaymentService()
-        let attempt = unsubmittedUsdtAttempt()
+        var attempt = unsubmittedUsdtAttempt()
+        attempt.paymentStarted = true
         let requestId = try XCTUnwrap(attempt.requestId)
         try saveUsdtAttempts([attempt])
         XCTAssertTrue(service.hasBinding(for: requestId))
@@ -200,7 +201,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
             XCTAssertFalse(service.hasBinding(for: requestId))
             XCTAssertTrue(PaykitUsdtPaymentService().hasBinding(for: requestId))
             await reconcileUsdt(service)
-            XCTAssertTrue(service.hasBinding(for: requestId))
+            XCTAssertFalse(service.hasBinding(for: requestId))
             for hasProof in [false, true] {
                 var protected = attempt
                 protected.proofQueued = !hasProof
@@ -242,7 +243,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
             XCTAssertTrue(service.hasBinding(for: requestId))
             if changed != replacement {
                 await reconcileUsdt(service)
-                XCTAssertTrue(service.hasBinding(for: requestId))
+                XCTAssertEqual(service.hasBinding(for: requestId), changed != started)
             }
         }
         try saveUsdtAttempts([attempt])
@@ -276,7 +277,7 @@ final class PaykitPaymentStateBackupTests: XCTestCase {
         try service.restoreBackup(PaykitUsdtStateBackup(attempts: [.init(attempt)], receipts: []))
         XCTAssertTrue(service.hasBinding(for: requestId))
         await reconcileUsdt(service)
-        XCTAssertTrue(service.hasBinding(for: requestId))
+        XCTAssertFalse(service.hasBinding(for: requestId))
     }
 
     @MainActor
diff --git a/BitkitTests/UsdtDisplayTests.swift b/BitkitTests/UsdtDisplayTests.swift
index 14900327c..b49a51856 100644
--- a/BitkitTests/UsdtDisplayTests.swift
+++ b/BitkitTests/UsdtDisplayTests.swift
@@ -3,6 +3,12 @@ import Foundation
 import XCTest
 
 final class UsdtDisplayTests: XCTestCase {
+    func testExactAmountsPreserveTokenPrecisionAndLocaleSeparators() {
+        XCTAssertEqual(usdtExactAmount(4_996_000, locale: Locale(identifier: "en_US")), "4.996")
+        XCTAssertEqual(usdtExactAmount(1_234_567, locale: Locale(identifier: "de_DE")), "1,234567")
+        XCTAssertEqual(usdtExactAmount(3_500_000, locale: Locale(identifier: "de_DE")), "3,50")
+    }
+
     func testBitcoinEquivalentRequiresFreshRateAndFitsDisplayBounds() {
         let now = Date(timeIntervalSince1970: 1_800_000_000)
         let rate = PaykitExchangeRate(price: "100000", timestamp: now)
diff --git a/BitkitTests/UsdtPreparedQuoteTests.swift b/BitkitTests/UsdtPreparedQuoteTests.swift
index 5f35961f1..ce037867c 100644
--- a/BitkitTests/UsdtPreparedQuoteTests.swift
+++ b/BitkitTests/UsdtPreparedQuoteTests.swift
@@ -14,6 +14,18 @@ final class UsdtPreparedQuoteTests: XCTestCase {
         )
     }
 
+    func testQuotedCostIncludesDeductedBridgeFeesWithoutUnsignedOverflow() {
+        var quote = prepared.quote
+        XCTAssertEqual(quote.totalCost, 20)
+        quote.receivedAmount = 400_000
+        XCTAssertEqual(quote.totalCost, 600_020)
+        quote.maximumFee = UInt64.max
+        XCTAssertEqual(quote.totalCost, UInt64.max)
+        quote.receivedAmount = 2_000_000
+        quote.maximumFee = 20
+        XCTAssertEqual(quote.totalCost, 20)
+    }
+
     func testUnchangedPaymentKeepsTheApprovedFeeUntilTheExpiryBuffer() {
         XCTAssertTrue(prepared.matches(recipient: recipient, amount: "1", destination: .arbitrum, sender: sender,
                                        now: Date(timeIntervalSince1970: 114)))
diff --git a/BitkitTests/UsdtWalletManagerTests.swift b/BitkitTests/UsdtWalletManagerTests.swift
index 53622c088..573ec9f6a 100644
--- a/BitkitTests/UsdtWalletManagerTests.swift
+++ b/BitkitTests/UsdtWalletManagerTests.swift
@@ -4,6 +4,29 @@ import XCTest
 
 @MainActor
 final class UsdtWalletManagerTests: XCTestCase {
+    func testOfflineBackupDoesNotCreateAnUnusedWalletAndPreservesRestoredHistory() async throws {
+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: directory) }
+        let manager = UsdtWalletManager(storageDirectory: directory, rpcUrl: nil, bundlerUrl: nil, loadCredentials: {
+            ("test test test test test test test test test test test junk", nil)
+        })
+        XCTAssertFalse(manager.shouldRefresh(enabled: false))
+        let empty = try await manager.backupSnapshot()
+        XCTAssertNil(empty)
+        XCTAssertFalse(FileManager.default.fileExists(atPath: directory.path))
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let address = try usdtAddress(mnemonic: "test test test test test test test test test test test junk", passphrase: nil)
+        let snapshot = "{\"identity\":\"42161:\(address)\",\"transfers\":[]}"
+        try await manager.restoreBackup(snapshot)
+        let restored = try await manager.backupSnapshot()
+        XCTAssertNotNil(restored)
+        XCTAssertTrue(try manager.hasStoredWallet)
+        do {
+            _ = try await manager.paymentEndpoint()
+            XCTFail("Local backup access must not enable network operations")
+        } catch UsdtError.NotConfigured {}
+    }
+
     func testEndpointPublicationOmitsUnavailableUsdtAndPropagatesCancellation() async throws {
         try XCTSkipUnless(Env.isUsdtEnabled)
         let unavailable = UsdtWalletManager(loadCredentials: { throw UsdtError.InvalidCredentials })
@@ -302,12 +325,11 @@ final class UsdtWalletManagerTests: XCTestCase {
         let deposit = UsdtDeposit(id: "deposit", network: "bsc", asset: "USDT", amount: 50_000_001,
                                   sourceTx: "source-tx", status: "held", code: nil, refundTx: nil)
         let detail = UsdtDepositDetail(deposit: deposit, order: nil)
-        for (identifier, amount) in [("en_US", "50.00"), ("de_DE", "50,00")] {
+        for (identifier, amount) in [("en_US", "50.000001"), ("de_DE", "50,000001")] {
             let confirmation = detail.refundConfirmation(address: address, hideBalance: false, locale: Locale(identifier: identifier))
             for value in [amount, "BNB Smart Chain (BSC)", address, "Refund fees may apply."] {
                 XCTAssertTrue(confirmation.contains(value), value)
             }
-            XCTAssertFalse(confirmation.contains("50.000001"))
         }
         let hidden = detail.refundConfirmation(address: address, hideBalance: true, locale: Locale(identifier: "en_US"))
         XCTAssertFalse(hidden.contains("50.00"))
diff --git a/Docs/USDT.md b/Docs/USDT.md
index db43fa020..eeb444d8a 100644
--- a/Docs/USDT.md
+++ b/Docs/USDT.md
@@ -11,7 +11,7 @@ USDT uses Arbitrum One regardless of the Bitcoin network setting. Builds use the
 | `USDT_DEPOSITS_URL` | `https://bitkit.to/v1/usdt/deposits` |
 | `USDT_RPC_URL` | `https://bitkit.to/v1/usdt/chain-rpc` |
 
-Xcode build settings override these defaults. Local runs also accept process environment and launch-argument overrides. For local E2E testing, override all four URLs with the matching local service routes. Clearing the RPC or bundler build setting disables USDT; clearing the deposits or bridges setting disables that provider API.
+Xcode build settings override these defaults. Local runs also accept process environment and launch-argument overrides. For local E2E testing, override all four URLs with the matching local service routes. Clearing the RPC or bundler build setting disables USDT network operations; local recovery-data backup and restore remain available. Clearing the deposits or bridges setting disables that provider API.
 
 Optional `USDT_DEPOSITS_URL` enables wallet-signed Orchestra deposits. Provider keys remain on the service. Source support covers Ethereum, Tron, Solana, Polygon, Base and BNB Smart Chain, subject to explicit service enablement and live route availability. Each source requires funded acceptance before release. Users approve a source-network refund address when requesting an eligible refund; unconverted Tron refunds require provider support. History and addresses recover under the same provider partner account. Linked order amounts are batch totals. Outbound USDT0 destinations are enabled with `USDT_BRIDGE_NETWORKS`, a comma-separated subset of `ethereum,polygon,plasma,stable`, matching the service configuration. An empty USDT0 network list disables USDT0 bridging; Orchestra destinations are discovered separately through `USDT_BRIDGES_URL`. Paykit always uses direct Arbitrum payments.
 
@@ -25,6 +25,8 @@ History catch-up is deferred while the USDT send sheet is open. Balance and pend
 
 ## Enabling USDT
 
+Unused wallets do not create USDT storage or poll the gateway merely for Home refreshes or backups. Existing wallet journals still allow payment/proof recovery while USDT is off.
+
 USDT starts off. The introductory sheet offers Enable USDT and No Thanks; dismissing it without a choice allows it to return next launch. Settings > General > Payments > USDT (Tether) changes the choice later.
 
 When off, USDT is hidden from new payment choices, Paykit offers and authorization details. Combined Bitcoin and USDT authorization continues with Bitcoin and omits the USDT address; a USDT-only authorization is unavailable. Authorization never asks to enable USDT. Automatic clipboard detection ignores USDT addresses and links while retaining Bitcoin and Lightning detection.
diff --git a/journeys/usdt-bridge-details.xml b/journeys/usdt-bridge-details.xml
index fec660fc6..07c9d93c6 100644
--- a/journeys/usdt-bridge-details.xml
+++ b/journeys/usdt-bridge-details.xml
@@ -5,7 +5,7 @@
     <action>Tap Details (id "UsdtActivityDetails"). Verify the real wallet transaction and available addresses are shown without inventing a provider deposit reference or refund eligibility.</action>
     <action>Open Cross-Network Deposits (id "UsdtDepositHistory"). Verify the Provider Status note says the spendable balance updates when USDT arrives on Arbitrum, and each row shows its source network, provider status and available amount.</action>
     <action>Open a supported deposit that needs attention (id "UsdtDepositRow-{depositId}"). Verify the summary appears first with the provider status and receiving network. Do not invent a deposit date or individual fee when the provider does not supply one. Tap Details (id "UsdtDepositDetails"). Verify its own source transaction and deposit reference are shown. Verify the refund instructions and address placeholder name that deposit's source network.</action>
-    <action>Enter an owned test refund address (id "UsdtRefundAddress") slowly across two background refreshes. Verify the field stays enabled and focused, the keyboard remains open, and every typed character is retained while the provider status updates. Then tap Request refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the deposit amount formatted like its list row, network, full refund address and refund fee note. In a comma locale, a 3.5 USDT deposit must display 3,50 USDT. Hidden balances must remain masked, and an unknown amount must remain a dash. Cancel without submitting.</action>
+    <action>Enter an owned test refund address (id "UsdtRefundAddress") slowly across two background refreshes. Verify the field stays enabled and focused, the keyboard remains open, and every typed character is retained while the provider status updates. Then tap Request refund (id "UsdtDepositRefund"). Verify Confirm Refund shows the exact deposit amount with up to six decimals, network, full refund address and refund fee note. In a comma locale, a 3.5 USDT deposit must display 3,50 USDT. Hidden balances must remain masked, and an unknown amount must remain a dash. Cancel without submitting.</action>
     <action>Tap Hide details (id "UsdtDepositDetails"), then Details again. Verify the provider status remains separate from wallet activity and the entered refund address is retained.</action>
     <action>Open completed, refunded and refund-in-progress deposit fixtures. Verify Request Refund is unavailable and the current provider status and available refund transaction are shown. An unsupported asset or network must show support guidance instead of a refund form.</action>
     <action>While Cross-Network Deposits is open, inject a confirmed incoming USDT transfer through the isolated fixture. Verify no received sheet interrupts deposit details or refund review. Return to the USDT wallet and verify the received celebration appears once after any active sheet is dismissed.</action>
diff --git a/journeys/usdt-opt-in.xml b/journeys/usdt-opt-in.xml
index c1381bc7f..c4bea8ddb 100644
--- a/journeys/usdt-opt-in.xml
+++ b/journeys/usdt-opt-in.xml
@@ -4,6 +4,7 @@
     <action>On Home, verify the New: USDT sheet (id "UsdtIntro") shows the Tether coin, DOLLARS? YOUR CALL heading, No Thanks and Enable USDT.</action>
     <action>Swipe the intro sheet down. Verify Home shows Savings and Spending without a USDT tile. Open Receive and verify there is no USDT tab, then close it.</action>
     <action>Terminate and relaunch the app. Verify the USDT intro returns. Tap No Thanks (id "UsdtIntroDecline"), relaunch again, and verify the intro does not return.</action>
+    <action>While USDT remains off on this fresh wallet, use the local gateway request log to verify Home and wallet backups do not request the wallet's USDT balance or history. Bitcoin and Lightning continue normally.</action>
     <action>Open Settings, General, Payments. Verify USDT (Tether) (id "UsdtSettingsToggle") is off. Enable it, return Home, and verify the USDT tile appears. Open Receive and verify the USDT tab appears.</action>
     <action>Open USDT Send and its network pill. Verify the USDT Network picker (id "UsdtNetworkPicker") uses rounded rows with Tether icons, a teal selection check, the recipient-network explanation and Tether coin illustration. Choose another supported network and verify the pill updates while retaining its network icon.</action>
     <action>Return to Settings and turn USDT off while the wallet is empty and all transfers are complete. Verify the USDT tile, receive tab and new Paykit receiving option disappear. Existing payment history remains stored.</action>
diff --git a/journeys/usdt-send-review-and-details.xml b/journeys/usdt-send-review-and-details.xml
index da2c22bcb..2209f76bb 100644
--- a/journeys/usdt-send-review-and-details.xml
+++ b/journeys/usdt-send-review-and-details.xml
@@ -9,6 +9,7 @@
     <action>Enter a smaller amount and continue. Verify the collapsed review shows the amount, coin illustration, Show Details and teal Swipe To Pay. Show Details reveals Pay from, Network, Payment, Fee and Address, with the fee note in the scrollable details. Displayed amounts round to cents; nonzero values below one cent show &lt;0.01. Hide Details restores the illustration. Cancel without paying.</action>
     <action>Prepare an ordinary amount and note the payment, fee and maximum total in Details. Go back to Amount and immediately continue without editing; verify the same review values return. Go back, change the amount and continue; verify the payment reflects the new amount. Go back, wait until the quote expires (at most two minutes) and continue; verify a new quote is obtained or an error leaves the amount editable, rather than displaying expired fees. Cancel without swiping.</action>
     <action>Prepare a cross-network payment and continue. Verify You send labels the entered amount and Recipient gets appears directly beneath it, with an approximation marker for Orchestra. Verify the recipient amount follows the quote rather than assuming it equals the sent amount. Without scrolling, verify Show Details (id "UsdtReviewDetails"), Maximum total debit (id "UsdtMaximumTotal") and its value are fully visible above Swipe To Pay. Show Details and verify Hide Details remains visible above the maximum, Payment is labelled You send, and the fee note can be read by scrolling without overlapping the pinned total. For Orchestra, also verify the deducted bridge cost is fully readable when scrolled into view. Cancel without paying.</action>
+    <action>Using the local quote fixture, prepare a 5 USDT bridge with 2 USDT received and a small network fee. Try to proceed and verify the fee-over-half-value warning appears before payment authentication. Cancel without paying.</action>
     <action>Open an existing sent USDT activity. Verify the heading is Sent USDT, the signed amount includes the actual fee, and summary rows show Status/Network, Date/Time and Payment/Fee with teal icons. Open Details and verify transaction ID, known sender, recipient and source/destination networks; Open Block Explorer stays at the bottom.</action>
     <action>Open an existing received activity. Verify Received USDT and a positive amount. Verify Details shows the verified sender when available and does not invent one for older unknown records. Check pending, failed and transferring rows use their matching icons, and transferring shows its destination.</action>
     <action>Prepare a contact payment that accepts multiple payment methods. Open the payment-source button and verify the balance menu shows Savings, Spending, any paired hardware wallet and USDT. Unsupported methods are disabled. Select a supported method and verify its label, available balance and payable amount update. Cancel without paying.</action>