Refactor swap quote streaming & loading UI

DRadmir · DRadmir · commit e8820247d036 · 2026-03-18T15:37:35.000+05:00
Introduce streaming-aware state and loading UI for swap quotes. Add isStreaming to SwapSceneViewModel and include it in isLoading; replace incremental accumulator with applyQuotes/selectQuote logic and add minInputAmountError handling to pick the smallest min amount. Wire loading indicators into UI by adding isLoading to SwapChangeView and SwapTokenView (renaming showLoading -&gt; isLoading and showing LoadingView when appropriate). Add SwapQuotesProviderMock for tests and update testkit mocks (SwapperProviderData, SwapperProviderType, SwapperQuote) to support provider-specific mocks. Update SwapSceneViewModel tests to assert provider selection preservation and min-amount error behavior. Remove unused SwapQuoteStreamEvent type. Also allow injecting a custom quotesProvider into the SwapSceneViewModel mock helper.
diff --git a/Features/Swap/Sources/Scenes/SwapScene.swift b/Features/Swap/Sources/Scenes/SwapScene.swift
@@ -94,7 +94,8 @@ extension SwapScene {
         } footer: {
             SwapChangeView(
                 fromId: $model.pairSelectorModel.fromAssetId,
-                toId: $model.pairSelectorModel.toAssetId
+                toId: $model.pairSelectorModel.toAssetId,
+                isLoading: model.isLoading
             )
                 .padding(.top, .small)
                 .frame(maxWidth: .infinity)
@@ -110,7 +111,7 @@ extension SwapScene {
             SwapTokenView(
                 model: model.swapTokenModel(type: .receive(chains: [], assetIds: [])),
                 text: $model.toValue,
-                showLoading: model.isLoading,
+                isLoading: model.isLoading,
                 disabledTextField: true,
                 onBalanceAction: {},
                 onSelectAssetAction: model.onSelectAssetReceive
diff --git a/Features/Swap/Sources/ViewModels/SwapSceneViewModel.swift b/Features/Swap/Sources/ViewModels/SwapSceneViewModel.swift
@@ -15,6 +15,7 @@ import BalanceService
 import PriceService
 import enum Gemstone.SwapperError
 import struct Gemstone.SwapperQuote
+import struct Gemstone.SwapperProviderType
 import Formatters
 import Validators
 
@@ -30,6 +31,8 @@ public final class SwapSceneViewModel {
     public var swapState: SwapState = .init()
     public var isPresentingInfoSheet: SwapSheetType?
 
+    private(set) var isStreaming: Bool = false
+
     public let fromAssetQuery: ObservableQuery<AssetRequestOptional>
     public let toAssetQuery: ObservableQuery<AssetRequestOptional>
 
@@ -113,7 +116,7 @@ public final class SwapSceneViewModel {
     }
 
     var isLoading: Bool {
-        swapState.quotes.isLoading
+        swapState.quotes.isLoading || isStreaming
     }
 
     var assetIds: [AssetId] {
@@ -339,32 +342,36 @@ extension SwapSceneViewModel {
     }
     private func performFetch(input: SwapQuoteInput) async {
         do {
+            let preferredProvider = selectedSwapQuote?.data.provider
             swapState.swapTransferData = .noData
             swapState.quotes = .loading
+            isStreaming = true
             resetToValue()
 
-            var accumulated: [SwapperQuote] = []
+            var quotes: [SwapperQuote] = []
             var errors: [Error] = []
 
             for await result in swapQuotesProvider.fetchQuotes(wallet: wallet, input: input) {
                 try Task.checkCancellation()
 
                 switch result {
                 case .success(let quote):
-                    accumulated.append(quote)
-                    applyAccumulatedQuotes(&accumulated)
+                    quotes.append(quote)
+                    applyQuotes(&quotes)
                 case .failure(let error):
                     errors.append(error)
                 }
             }
 
             try Task.checkCancellation()
 
-            if accumulated.isEmpty {
-                let swapError = prioritizedSwapError(errors) ?? SwapperError.NoQuoteAvailable
+            if quotes.isEmpty {
+                let swapError = minInputAmountError(errors) ?? SwapperError.NoQuoteAvailable
                 swapState.quotes = .error(swapError)
                 selectedSwapQuote = nil
                 amountInputModel.update(error: nil)
+            } else {
+                selectedSwapQuote = quotes.first(where: { $0.data.provider == preferredProvider }) ?? quotes.first
             }
         } catch {
             if !error.isCancelled && !Task.isCancelled {
@@ -374,28 +381,25 @@ extension SwapSceneViewModel {
                 debugLog("SwapScene get quotes error: \(error)")
             }
         }
+        isStreaming = false
     }
 
-    private func applyAccumulatedQuotes(_ accumulated: inout [SwapperQuote]) {
-        accumulated.sort { BigInt.fromString($0.toValue) > BigInt.fromString($1.toValue) }
-        swapState.quotes = .data(accumulated)
-        selectedSwapQuote = accumulated.first
+    private func applyQuotes(_ quotes: inout [SwapperQuote]) {
+        quotes.sort { BigInt.fromString($0.toValue) > BigInt.fromString($1.toValue) }
+        swapState.quotes = .data(quotes)
+        selectedSwapQuote = quotes.first
         if let selectedSwapQuote, let asset = toAsset?.asset {
             applyQuote(selectedSwapQuote, asset: asset)
         }
     }
 
-    private func prioritizedSwapError(_ errors: [Error]) -> SwapperError? {
-        let inputErrors: [(BigInt?, String?)] = errors.compactMap { error in
-            guard let swapperError = error as? SwapperError, case .InputAmountError(let minAmount) = swapperError else { return nil }
-            return (minAmount.flatMap { BigInt($0) }, minAmount)
-        }
-        guard !inputErrors.isEmpty else { return nil }
-        if let best = inputErrors.filter({ $0.0 != nil }).min(by: { ($0.0 ?? 0) < ($1.0 ?? 0) }) {
-            let adjusted = best.0.map { String($0.increase(byPercent: 10)) }
-            return .InputAmountError(minAmount: adjusted)
+    private func minInputAmountError(_ errors: [Error]) -> SwapperError? {
+        let minAmounts: [BigInt] = errors.compactMap { error in
+            guard case .InputAmountError(let minAmount) = error as? SwapperError else { return nil }
+            return minAmount.flatMap { BigInt($0) }
         }
-        return .InputAmountError(minAmount: nil)
+        guard let min = minAmounts.min() else { return nil }
+        return .InputAmountError(minAmount: String(min.increase(byPercent: 10)))
     }
 
     private func performUpdate(for assetIds: [AssetId]) async {
diff --git a/Features/Swap/Sources/Views/SwapChangeView.swift b/Features/Swap/Sources/Views/SwapChangeView.swift
@@ -2,31 +2,40 @@
 
 import Foundation
 import SwiftUI
+import Components
 import Style
 import Primitives
 
 struct SwapChangeView: View {
     @Binding private var fromId: AssetId?
     @Binding private var toId: AssetId?
+    var isLoading: Bool
 
     init(
         fromId: Binding<AssetId?> = .constant(.none),
-        toId: Binding<AssetId?> = .constant(.none)
+        toId: Binding<AssetId?> = .constant(.none),
+        isLoading: Bool = false
     ) {
         _fromId = fromId
         _toId = toId
+        self.isLoading = isLoading
     }
 
     var body: some View {
-        Button {
-            swap(&fromId, &toId)
-        } label: {
-            Images.System.arrowSwap
-                .resizable()
-                .renderingMode(.template)
-                .scaledToFit()
+        if isLoading {
+            LoadingView(tint: Colors.gray)
                 .frame(size: .large)
-                .foregroundStyle(Colors.gray)
+        } else {
+            Button {
+                swap(&fromId, &toId)
+            } label: {
+                Images.System.arrowSwap
+                    .resizable()
+                    .renderingMode(.template)
+                    .scaledToFit()
+                    .frame(size: .large)
+                    .foregroundStyle(Colors.gray)
+            }
         }
     }
 }
diff --git a/Features/Swap/Sources/Views/SwapTokenView.swift b/Features/Swap/Sources/Views/SwapTokenView.swift
@@ -8,7 +8,7 @@ import Primitives
 struct SwapTokenView: View {
     let model: SwapTokenViewModel
     @Binding var text: String
-    var showLoading: Bool = false
+    var isLoading: Bool = false
     var disabledTextField: Bool = false
     var onBalanceAction: (() -> Void)
     var onSelectAssetAction: (() -> Void)
@@ -26,19 +26,14 @@ struct SwapTokenView: View {
             }
         }
     }
-    
+
     private var inputView: some View {
-        HStack {
-            if showLoading {
-                LoadingView()
-            }
-            TextField(showLoading ? "" : String.zero, text: $text)
-                .keyboardType(.decimalPad)
-                .foregroundStyle(Colors.black)
-                .font(.app.title1)
-                .disabled(disabledTextField)
-                .multilineTextAlignment(.leading)
-        }
+        TextField(String.zero, text: $text)
+            .keyboardType(.decimalPad)
+            .foregroundStyle(isLoading ? Colors.gray : Colors.black)
+            .font(.app.title1)
+            .disabled(disabledTextField)
+            .multilineTextAlignment(.leading)
     }
 
     private var fiatBalanceView: some View {
diff --git a/Features/Swap/Tests/SwapTests/SwapSceneViewModelTests.swift b/Features/Swap/Tests/SwapTests/SwapSceneViewModelTests.swift
@@ -11,6 +11,8 @@ import SwapServiceTestKit
 import BigInt
 import protocol Gemstone.GemSwapperProtocol
 import enum Gemstone.SwapperError
+import struct Gemstone.SwapperQuote
+import struct Gemstone.SwapperProviderType
 import Keystore
 import KeystoreTestKit
 import Primitives
@@ -132,6 +134,34 @@ struct SwapSceneViewModelTests {
         #expect(model.fetchTrigger?.isImmediate == true)
     }
 
+    @Test
+    func preservesProviderSelectionOnRefresh() async {
+        let quoteA = SwapperQuote.mock(toValue: "100", data: .mock(provider: .mock(id: .uniswapV3)))
+        let quoteB = SwapperQuote.mock(toValue: "200", data: .mock(provider: .mock(id: .thorchain)))
+        let model = SwapSceneViewModel.mock(quotesProvider: SwapQuotesProviderMock(results: [.success(quoteA), .success(quoteB)]))
+
+        await model.fetch()
+        model.onFinishSwapProviderSelection(quoteA)
+
+        #expect(model.selectedSwapQuote?.data.provider.id == .uniswapV3)
+
+        await model.fetch()
+
+        #expect(model.selectedSwapQuote?.data.provider.id == .uniswapV3)
+    }
+
+    @Test
+    func minAmountErrorPicksSmallest() async {
+        let model = SwapSceneViewModel.mock(quotesProvider: SwapQuotesProviderMock(results: [
+            .failure(SwapperError.InputAmountError(minAmount: "2000")),
+            .failure(SwapperError.InputAmountError(minAmount: "1000")),
+        ]))
+
+        await model.fetch()
+
+        #expect(model.buttonViewModel.buttonAction == .useMinAmount(amount: "1100", asset: .mockEthereum()))
+    }
+
     // MARK: - Private methods
 
     private func model(
@@ -147,7 +177,7 @@ struct SwapSceneViewModelTests {
 }
 
 extension SwapSceneViewModel {
-    static func mock(swapper: GemSwapperProtocol = GemSwapperMock()) -> SwapSceneViewModel {
+    static func mock(swapper: GemSwapperProtocol = GemSwapperMock(), quotesProvider: SwapQuotesProvidable? = nil) -> SwapSceneViewModel {
         let model = SwapSceneViewModel(
             preferences: .mock(),
             input: .init(
@@ -156,7 +186,7 @@ extension SwapSceneViewModel {
             ),
             balanceUpdater: .mock(),
             priceUpdater: .mock(),
-            swapQuotesProvider: SwapQuotesProvider(swapService: .mock(swapper: swapper)),
+            swapQuotesProvider: quotesProvider ?? SwapQuotesProvider(swapService: .mock(swapper: swapper)),
             swapQuoteDataProvider: SwapQuoteDataProvider(keystore: LocalKeystore.mock(), swapService: .mock(swapper: swapper))
         )
         model.fromAssetQuery.value = .mock(asset: .mockEthereum(), balance: .mock())
@@ -170,3 +200,4 @@ extension SwapSceneViewModel {
 private struct TestError: Error, RetryableError {
     var isRetryAvailable: Bool = true
 }
+
diff --git a/Packages/FeatureServices/SwapService/SwapQuoteStreamEvent.swift b/Packages/FeatureServices/SwapService/SwapQuoteStreamEvent.swift
diff --git a/Packages/FeatureServices/SwapService/TestKit/SwapQuotesProviderMock.swift b/Packages/FeatureServices/SwapService/TestKit/SwapQuotesProviderMock.swift
@@ -0,0 +1,27 @@
+// Copyright (c). Gem Wallet. All rights reserved.
+
+import SwapService
+import Primitives
+import struct Gemstone.SwapperQuote
+
+public struct SwapQuotesProviderMock: SwapQuotesProvidable {
+    private let results: [Result<SwapperQuote, Error>]
+
+    public init(results: [Result<SwapperQuote, Error>]) {
+        self.results = results
+    }
+
+    public func supportedAssets(for assetId: AssetId) -> ([Primitives.Chain], [Primitives.AssetId]) {
+        ([], [])
+    }
+
+    public func fetchQuotes(wallet: Wallet, input: SwapQuoteInput) -> AsyncStream<Result<SwapperQuote, Error>> {
+        let results = self.results
+        return AsyncStream { continuation in
+            for result in results {
+                continuation.yield(result)
+            }
+            continuation.finish()
+        }
+    }
+}
diff --git a/Packages/FeatureServices/SwapService/TestKit/Types+Mock/SwapperProviderData+TestKit.swift b/Packages/FeatureServices/SwapService/TestKit/Types+Mock/SwapperProviderData+TestKit.swift
@@ -2,12 +2,13 @@
 
 import Foundation
 import struct Gemstone.SwapperProviderData
+import struct Gemstone.SwapperProviderType
 import struct Gemstone.SwapperRoute
 
-extension SwapperProviderData {
-    static func mock() -> SwapperProviderData {
+public extension SwapperProviderData {
+    static func mock(provider: SwapperProviderType = .mock()) -> SwapperProviderData {
         SwapperProviderData(
-            provider: .mock(),
+            provider: provider,
             slippageBps: 50,
             routes: [.mock()]
         )
diff --git a/Packages/FeatureServices/SwapService/TestKit/Types+Mock/SwapperProviderType+TestKit.swift b/Packages/FeatureServices/SwapService/TestKit/Types+Mock/SwapperProviderType+TestKit.swift
@@ -5,12 +5,12 @@ import enum Gemstone.SwapperProvider
 import struct Gemstone.SwapperProviderType
 
 public extension SwapperProviderType {
-    static func mock() -> SwapperProviderType {
+    static func mock(id: SwapperProvider = .pancakeswapV3) -> SwapperProviderType {
         SwapperProviderType(
-            id: .pancakeswapV3,
-            name: "PancakeSwap",
+            id: id,
+            name: "\(id)",
             protocol: "v3",
-            protocolId: "pancakeswap_v3",
+            protocolId: "\(id)_v3",
             mode: .onChain
         )
     }
diff --git a/Packages/FeatureServices/SwapService/TestKit/Types+Mock/SwapperQuote+TestKit.swift b/Packages/FeatureServices/SwapService/TestKit/Types+Mock/SwapperQuote+TestKit.swift
@@ -1,18 +1,20 @@
 // Copyright (c). Gem Wallet. All rights reserved.
 
 import Foundation
+import struct Gemstone.SwapperProviderData
 import struct Gemstone.SwapperQuote
 
 public extension SwapperQuote {
     static func mock(
         fromValue: String = "1000000000000000000",
         toValue: String = "250000000000",
+        data: SwapperProviderData = .mock(),
         etaInSeconds: UInt32? = nil
     ) -> SwapperQuote {
         SwapperQuote(
             fromValue: fromValue,
             toValue: toValue,
-            data: .mock(),
+            data: data,
             request: .mock(),
             etaInSeconds: etaInSeconds
         )
