Home Screen load laggines

RadixWallet/Clients/AccountPortfoliosClient/AccountPortfoliosClient+Interface.swift

@@ -10,6 +10,8 @@ public struct AccountPortfoliosClient: Sendable {
 	/// Will return the portfolio after fetch, as well will notify any subscribes through `portfolioForAccount`
 	public var fetchAccountPortfolio: FetchAccountPortfolio
 
+	public var portfolioUpdates: PortfolioUpdates
+
 	/// Subscribe to portfolio changes for a given account address
 	public var portfolioForAccount: PortfolioForAccount
 
@@ -21,6 +23,8 @@ extension AccountPortfoliosClient {
 	public typealias FetchAccountPortfolio = @Sendable (_ address: AccountAddress, _ forceResfresh: Bool) async throws -> AccountPortfolio
 	public typealias FetchAccountPortfolios = @Sendable (_ addresses: [AccountAddress], _ forceResfresh: Bool) async throws -> [AccountPortfolio]
 	public typealias PortfolioForAccount = @Sendable (_ address: AccountAddress) async -> AnyAsyncSequence<AccountPortfolio>
+
+	public typealias PortfolioUpdates = @Sendable () -> AnyAsyncSequence<Loadable<[AccountPortfolio]>>
 	public typealias Portfolios = @Sendable () -> [AccountPortfolio]
 }
 

RadixWallet/Clients/AccountPortfoliosClient/AccountPortfoliosClient+Live.swift

@@ -137,6 +137,11 @@ extension AccountPortfoliosClient: DependencyKey {
 
 				return portfolio
 			},
+			portfolioUpdates: {
+				state.portfoliosSubject
+					.map { $0.map { Array($0.values) } }
+					.eraseToAnyAsyncSequence()
+			},
 			portfolioForAccount: { address in
 				await state.portfolioForAccount(address)
 			},

RadixWallet/Clients/AccountPortfoliosClient/AccountPortfoliosClient+Mock.swift

@@ -4,14 +4,15 @@ extension AccountPortfoliosClient: TestDependencyKey {
 
 	public static let testValue = AccountPortfoliosClient(
 		fetchAccountPortfolios: unimplemented("\(AccountPortfoliosClient.self).fetchAccountPortfolios"),
-		fetchAccountPortfolio: unimplemented("\(AccountPortfoliosClient.self).fetchAccountPortfolio"),
+		fetchAccountPortfolio: unimplemented("\(AccountPortfoliosClient.self).fetchAccountPortfolio"), portfolioUpdates: unimplemented("\(AccountPortfoliosClient.self).fetchAccountPortfolio"),
 		portfolioForAccount: unimplemented("\(AccountPortfoliosClient.self).portfolioForAccount"),
 		portfolios: unimplemented("\(AccountPortfoliosClient.self).portfolios")
 	)
 
 	public static let noop = AccountPortfoliosClient(
 		fetchAccountPortfolios: { _, _ in throw NoopError() },
 		fetchAccountPortfolio: { _, _ in throw NoopError() },
+		portfolioUpdates: { fatalError() },
 		portfolioForAccount: { _ in fatalError() },
 		portfolios: { fatalError() }
 	)

RadixWallet/Clients/AccountPortfoliosClient/AccountPortfoliosClient+State.swift

@@ -45,7 +45,7 @@ extension AccountPortfoliosClient.State {
 	}
 
 	func portfolioForAccount(_ address: AccountAddress) -> AnyAsyncSequence<AccountPortfoliosClient.AccountPortfolio> {
-		portfoliosSubject.compactMap { $0[address].unwrap()?.wrappedValue }.eraseToAnyAsyncSequence()
+		portfoliosSubject.compactMap { $0[address].unwrap()?.wrappedValue }.removeDuplicates().eraseToAnyAsyncSequence()
 	}
 
 	private func setOrUpdateAccountPortfolio(_ portfolio: AccountPortfoliosClient.AccountPortfolio) {

RadixWallet/Core/FeaturePrelude/Loadable.swift

@@ -223,7 +223,7 @@ extension Loadable {
 		}
 	}
 
-	public func firstd(where predicate: (Value.Element) -> Bool) -> Loadable<Value.Element?> where Value: Sequence {
+	public func first(where predicate: (Value.Element) -> Bool) -> Loadable<Value.Element?> where Value: Sequence {
 		switch self {
 		case .idle:
 			return .idle
@@ -307,16 +307,29 @@ extension Loadable {
     public mutating func refresh(
         from other: Loadable<Value>,
         valueChangeMap: (_ old: Value, _ new: Value) -> Value = { _, new in new }
-    ) {
+    ) where Value: Equatable {
         switch (self, other) {
-        // If `other` is success, update the content regardless of the current state
-        case let (.success(oldValue), .success(newValue)):
-            self = .success(valueChangeMap(oldValue, newValue))
-        case let (_, .success(otherValue)):
+        // Update to success if no current value
+        case let (.idle, .success(otherValue)),
+            let (.loading, .success(otherValue)),
+            let (.failure, .success(otherValue)):
+
             self = .success(otherValue)
+
+        // Update to new value only if it changed
+        case let (.success(oldValue), .success(newValue)):
+            if oldValue != newValue {
+                self = .success(valueChangeMap(oldValue, newValue))
+            }
+
         // If current state is success, don't update if `other` is loading or failed
         case (.success, _):
             break
+
+        case (.loading, .loading),
+            (.idle, .idle):
+            break
+
         // If current state is other than .success
         case let (_, other):
             self = other

RadixWallet/Features/AssetsFeature/AssetsView+Reducer.swift

@@ -250,6 +250,8 @@ public struct AssetsView: Sendable, FeatureReducer {
 extension AccountPortfoliosClient.AccountPortfolio {
 	mutating func refresh(from portfolio: AccountPortfoliosClient.AccountPortfolio) {
 		self.account = portfolio.account
+		self.isCurrencyAmountVisible = portfolio.isCurrencyAmountVisible
+		self.fiatCurrency = portfolio.fiatCurrency
 		self.stakeUnitDetails.refresh(from: portfolio.stakeUnitDetails)
 		self.poolUnitDetails.refresh(from: portfolio.poolUnitDetails)
 	}

RadixWallet/Features/HomeFeature/Children/AccountRow/Home+AccountRow+Reducer.swift

@@ -8,15 +8,15 @@ extension Home {
 			public var id: AccountAddress { account.address }
 			public var accountWithInfo: AccountWithInfo
 
-			public var portfolio: Loadable<AccountPortfoliosClient.AccountPortfolio>
+			public var accountWithResources: Loadable<OnLedgerEntity.Account>
 			public var showFiatWorth: Bool = true
 			public var totalFiatWorth: Loadable<FiatWorth>
 
 			public init(
 				account: Profile.Network.Account
 			) {
 				self.accountWithInfo = .init(account: account)
-				self.portfolio = .loading
+				self.accountWithResources = .loading
 				self.totalFiatWorth = .loading
 			}
 		}
@@ -29,7 +29,8 @@ extension Home {
 		}
 
 		public enum InternalAction: Sendable, Equatable {
-			case accountPortfolioUpdate(AccountPortfoliosClient.AccountPortfolio)
+			case accountUpdated(OnLedgerEntity.Account)
+			case fiatWorthUpdated(Loadable<FiatWorth>)
 			case checkAccountAccessToMnemonic
 		}
 
@@ -47,20 +48,17 @@ extension Home {
 			switch viewAction {
 			case .task:
 				let accountAddress = state.account.address
-				if state.portfolio.wrappedValue == nil {
-					state.portfolio = .loading
-				}
-
 				self.checkAccountAccessToMnemonic(state: &state)
 
 				return .run { send in
-					for try await accountPortfolio in await accountPortfoliosClient.portfolioForAccount(accountAddress) {
+					for try await fiatWorth in await accountPortfoliosClient.portfolioForAccount(accountAddress).map(\.totalFiatWorth).removeDuplicates() {
 						guard !Task.isCancelled else {
 							return
 						}
-						await send(.internal(.accountPortfolioUpdate(accountPortfolio)))
+						await send(.internal(.fiatWorthUpdated(fiatWorth)))
 					}
 				}
+
 			case .exportMnemonicButtonTapped:
 				return .send(.delegate(.exportMnemonic))
 
@@ -74,23 +72,26 @@ extension Home {
 
 		public func reduce(into state: inout State, internalAction: InternalAction) -> Effect<Action> {
 			switch internalAction {
-			case let .accountPortfolioUpdate(portfolio):
-				state.isDappDefinitionAccount = portfolio.account.metadata.accountType == .dappDefinition
+			case let .accountUpdated(account):
+				assert(account.address == state.account.address)
 
-				assert(portfolio.account.address == state.account.address)
+				state.isDappDefinitionAccount = account.metadata.accountType == .dappDefinition
+				state.accountWithResources.refresh(from: .success(account))
 
-				state.portfolio = .success(portfolio)
-				state.totalFiatWorth.refresh(from: portfolio.totalFiatWorth)
 				return .send(.internal(.checkAccountAccessToMnemonic))
 
 			case .checkAccountAccessToMnemonic:
 				checkAccountAccessToMnemonic(state: &state)
 				return .none
+
+			case let .fiatWorthUpdated(fiatWorth):
+				state.totalFiatWorth.refresh(from: fiatWorth)
+				return .none
 			}
 		}
 
 		private func checkAccountAccessToMnemonic(state: inout State) {
-			state.checkAccountAccessToMnemonic(portfolio: state.portfolio.account.wrappedValue)
+			state.checkAccountAccessToMnemonic(portfolio: state.accountWithResources.wrappedValue)
 		}
 	}
 }

RadixWallet/Features/HomeFeature/Children/AccountRow/Home+AccountRow+View.swift

@@ -47,15 +47,15 @@ extension Home.AccountRow {
 			self.appearanceID = state.account.appearanceID
 			self.showFiatWorth = state.showFiatWorth
 			self.fiatWorth = state.totalFiatWorth
-			self.isLoadingResources = state.portfolio.isLoading
+			self.isLoadingResources = state.accountWithResources.isLoading
 
 			self.tag = .init(state: state)
 			self.isLedgerAccount = state.isLedgerAccount
 
 			self.mnemonicHandlingCallToAction = state.mnemonicHandlingCallToAction
 
 			// Resources
-			guard let portfolio = state.portfolio.wrappedValue else {
+			guard let accountWithResources = state.accountWithResources.wrappedValue else {
 				self.fungibleResourceIcons = []
 				self.nonFungibleResourcesCount = 0
 				self.stakedValidatorsCount = 0
@@ -64,13 +64,13 @@ extension Home.AccountRow {
 				return
 			}
 
-			let fungibleResources = portfolio.account.fungibleResources
+			let fungibleResources = accountWithResources.fungibleResources
 			let xrdIcon: [Thumbnail.TokenContent] = fungibleResources.xrdResource != nil ? [.xrd] : []
 			let otherIcons: [Thumbnail.TokenContent] = fungibleResources.nonXrdResources.map { .other($0.metadata.iconURL) }
 			self.fungibleResourceIcons = xrdIcon + otherIcons
-			self.nonFungibleResourcesCount = portfolio.account.nonFungibleResources.count
-			self.stakedValidatorsCount = portfolio.account.poolUnitResources.radixNetworkStakes.count
-			self.poolUnitsCount = portfolio.account.poolUnitResources.poolUnits.count
+			self.nonFungibleResourcesCount = accountWithResources.nonFungibleResources.count
+			self.stakedValidatorsCount = accountWithResources.poolUnitResources.radixNetworkStakes.count
+			self.poolUnitsCount = accountWithResources.poolUnitResources.poolUnits.count
 		}
 	}
 

RadixWallet/Features/HomeFeature/Coordinator/Home.swift

@@ -47,6 +47,7 @@ public struct Home: Sendable, FeatureReducer {
 		case loadedShouldWriteDownPersonasSeedPhrase(Bool)
 		case currentGatewayChanged(to: Radix.Gateway)
 		case shouldShowNPSSurvey(Bool)
+		case accountsResourcesLoaded(Loadable<[OnLedgerEntity.Account]>)
 	}
 
 	public enum ChildAction: Sendable, Equatable {
@@ -151,6 +152,7 @@ public struct Home: Sendable, FeatureReducer {
 			.merge(with: loadShouldWriteDownPersonasSeedPhrase())
 			.merge(with: loadGateways())
 			.merge(with: loadNPSSurveyStatus())
+			.merge(with: loadAccountResources())
 
 		case .createAccountButtonTapped:
 			state.destination = .createAccount(
@@ -206,6 +208,14 @@ public struct Home: Sendable, FeatureReducer {
 			errorQueue.schedule(error)
 			return .none
 
+		case let .accountsResourcesLoaded(accountsResources):
+			state.accountRows.mutateAll { row in
+				if let accountResources = accountsResources.first(where: { $0.address == row.id }).unwrap() {
+					row.accountWithResources.refresh(from: accountResources)
+				}
+			}
+			return .none
+
 		case let .loadedShouldWriteDownPersonasSeedPhrase(shouldBackup):
 			state.shouldWriteDownPersonasSeedPhrase = shouldBackup
 			return .none
@@ -372,6 +382,15 @@ public struct Home: Sendable, FeatureReducer {
 			await npsSurveyClient.uploadUserFeedback(feedback)
 		}
 	}
+
+	private func loadAccountResources() -> Effect<Action> {
+		.run { send in
+			for try await accountResources in accountPortfoliosClient.portfolioUpdates().map { $0.map { $0.map(\.account) } }.removeDuplicates() {
+				guard !Task.isCancelled else { return }
+				await send(.internal(.accountsResourcesLoaded(accountResources)))
+			}
+		}
+	}
 }
 
 extension Home.State {