Fix crash caused by early profile access (#1401)

RadixWallet/Clients/RadixConnectClient/RadixConnectClient+Interface.swift

@@ -43,6 +43,8 @@ struct RadixConnectClient: DependencyKey, Sendable {
 	var sendRequest: SendRequest
 
 	var handleDappDeepLink: HandleDappDeepLink
+
+	var startNotifyingConnectorWithAccounts: StartNotifyingConnectorWithAccounts
 }
 
 extension RadixConnectClient {
@@ -70,4 +72,6 @@ extension RadixConnectClient {
 
 	typealias ConnectToP2PLinks = @Sendable (P2PLinks) async throws -> Void
 	typealias HandleDappDeepLink = @Sendable (URL) async throws -> Void
+
+	typealias StartNotifyingConnectorWithAccounts = @Sendable () async throws -> Void
 }

RadixWallet/Clients/RadixConnectClient/RadixConnectClient+Live.swift

@@ -14,25 +14,6 @@ extension RadixConnectClient {
 		let radixConnectMobile = RadixConnectMobile()
 		let localNetworkAuthorization = LocalNetworkAuthorization()
 
-		Task {
-			@Dependency(\.accountsClient) var accountsClient
-			for try await accounts in await accountsClient.accountsOnCurrentNetwork() {
-				guard !Task.isCancelled else { return }
-				try? await sendAccountListMessage(accounts: accounts)
-			}
-		}
-
-		Task {
-			let connectedClients = await rtcClients.connectClients()
-				.filter { updates in
-					!updates.flatMap(\.idsOfConnectedPeerConnections).isEmpty
-				}
-			for try await updates in connectedClients {
-				guard !Task.isCancelled else { return }
-				sendAccountListMessageAfterConnect()
-			}
-		}
-
 		@Sendable
 		func sendAccountListMessageAfterConnect() {
 			Task {
@@ -176,6 +157,28 @@ extension RadixConnectClient {
 					errorQueue.schedule(error)
 					throw error
 				}
+			},
+			startNotifyingConnectorWithAccounts: {
+				try await withThrowingTaskGroup(of: Void.self) { group in
+					group.addTask {
+						@Dependency(\.accountsClient) var accountsClient
+						for try await accounts in await accountsClient.accountsOnCurrentNetwork() {
+							guard !Task.isCancelled else { return }
+							try? await sendAccountListMessage(accounts: accounts)
+						}
+					}
+
+					group.addTask {
+						let connectedClients = await rtcClients.connectClients()
+							.filter { updates in
+								!updates.flatMap(\.idsOfConnectedPeerConnections).isEmpty
+							}
+						for try await updates in connectedClients {
+							guard !Task.isCancelled else { return }
+							sendAccountListMessageAfterConnect()
+						}
+					}
+				}
 			}
 		)
 	}()

RadixWallet/Clients/RadixConnectClient/RadixConnectClient+Test.swift

@@ -18,7 +18,8 @@ extension RadixConnectClient: TestDependencyKey {
 		receiveMessages: unimplemented("\(Self.self).receiveMessages"),
 		sendResponse: unimplemented("\(Self.self).sendResponse"),
 		sendRequest: unimplemented("\(Self.self).sendRequest"),
-		handleDappDeepLink: unimplemented("\(Self.self).sendRequest")
+		handleDappDeepLink: unimplemented("\(Self.self).sendRequest"),
+		startNotifyingConnectorWithAccounts: unimplemented("\(Self.self).startNotifyingConnectorWithAccounts")
 	)
 }
 
@@ -37,7 +38,8 @@ extension RadixConnectClient {
 		receiveMessages: { AsyncLazySequence([]).eraseToAnyAsyncSequence() },
 		sendResponse: { _, _ in },
 		sendRequest: { _, _ in 0 },
-		handleDappDeepLink: { _ in }
+		handleDappDeepLink: { _ in },
+		startNotifyingConnectorWithAccounts: {}
 	)
 }
 #endif // DEBUG

RadixWallet/Features/AccountRecoveryScan/Children/AccountRecoveryScanInProgress/AccountRecoveryScanInProgress+View.swift

@@ -13,9 +13,9 @@ extension AccountRecoveryScanInProgress.State {
 
 	private var isManualScan: Bool {
 		switch mode {
-		case .privateHD:
+		case .createProfile:
 			false
-		case .factorSourceWithID:
+		case .addAccounts:
 			true
 		}
 	}

RadixWallet/Features/AccountRecoveryScan/Children/AccountRecoveryScanInProgress/AccountRecoveryScanInProgress.swift

@@ -27,15 +27,15 @@ struct AccountRecoveryScanInProgress: Sendable, FeatureReducer {
 		var destination: Destination.State? = nil
 
 		enum Mode: Sendable, Hashable {
-			case privateHD(PrivateHierarchicalDeterministicFactorSource)
-			case factorSourceWithID(id: FactorSourceIDFromHash, Loadable<FactorSource> = .idle)
+			case createProfile(PrivateHierarchicalDeterministicFactorSource)
+			case addAccounts(factorSourceId: FactorSourceIDFromHash, Loadable<FactorSource> = .idle)
 		}
 
 		var factorSourceIDFromHash: FactorSourceIDFromHash {
 			switch mode {
-			case let .privateHD(privateHD):
+			case let .createProfile(privateHD):
 				privateHD.factorSource.id
-			case let .factorSourceWithID(id, _):
+			case let .addAccounts(id, _):
 				id
 			}
 		}
@@ -110,20 +110,19 @@ struct AccountRecoveryScanInProgress: Sendable, FeatureReducer {
 	private let destinationPath: WritableKeyPath<State, PresentationState<Destination.State>> = \.$destination
 
 	@Dependency(\.dismiss) var dismiss
-	@Dependency(\.accountsClient) var accountsClient
 	@Dependency(\.factorSourcesClient) var factorSourcesClient
 	@Dependency(\.onLedgerEntitiesClient) var onLedgerEntitiesClient
 
 	func reduce(into state: inout State, internalAction: InternalAction) -> Effect<Action> {
 		switch internalAction {
 		case .initiate:
 			switch state.mode {
-			case .privateHD:
+			case .createProfile:
 				return derivePublicKeys(state: &state)
-			case .factorSourceWithID:
+			case .addAccounts:
 				state.status = .loadingFactorSource
 				let id = state.factorSourceIDFromHash
-				state.mode = .factorSourceWithID(id: id, .loading)
+				state.mode = .addAccounts(factorSourceId: id, .loading)
 				return .run { [forOlympiaAccounts = state.forOlympiaAccounts] send in
 					let result = await TaskResult<IndicesUsedByFactorSource> {
 						try await factorSourcesClient.indicesOfEntitiesControlledByFactorSource(
@@ -151,8 +150,8 @@ struct AccountRecoveryScanInProgress: Sendable, FeatureReducer {
 				state.networkID = networkID
 			}
 
-			state.mode = .factorSourceWithID(
-				id: state.factorSourceIDFromHash,
+			state.mode = .addAccounts(
+				factorSourceId: state.factorSourceIDFromHash,
 				.success(
 					indicesUsedByFactorSource.factorSource
 				)
@@ -217,10 +216,14 @@ struct AccountRecoveryScanInProgress: Sendable, FeatureReducer {
 				assert(factorSourceID == id.asGeneral)
 				assert(networkID == state.networkID)
 				loggerGlobal.debug("Creating accounts with networkID: \(networkID)")
-				return .run { send in
+				return .run { [mode = state.mode] send in
 					let accounts = await publicHDKeys.enumerated().asyncMap { localOffset, publicHDKey in
 						let offset = localOffset + globalOffset
-						let appearanceID = await accountsClient.nextAppearanceID(networkID, offset)
+						let appearanceID = await getAccountAppearanceID(
+							mode: mode,
+							offset: offset,
+							networkID: networkID
+						)
 						return Account(
 							networkID: networkID,
 							factorInstance: .init(factorSourceId: id, publicKey: publicHDKey),
@@ -256,6 +259,20 @@ struct AccountRecoveryScanInProgress: Sendable, FeatureReducer {
 	func reduceDismissedDestination(into state: inout State) -> Effect<Action> {
 		.run { _ in await dismiss() }
 	}
+
+	private func getAccountAppearanceID(
+		mode: State.Mode,
+		offset: Int,
+		networkID: NetworkID
+	) async -> AppearanceID {
+		switch mode {
+		case .createProfile:
+			return AppearanceID.fromNumberOfAccounts(offset)
+		case .addAccounts:
+			@Dependency(\.accountsClient) var accountsClient
+			return await accountsClient.nextAppearanceID(networkID, offset)
+		}
+	}
 }
 
 extension AccountRecoveryScanInProgress {
@@ -305,7 +322,7 @@ extension AccountRecoveryScanInProgress {
 		}
 		let factorSourceOption: DerivePublicKeys.State.FactorSourceOption
 		switch state.mode {
-		case let .factorSourceWithID(_, loadableState):
+		case let .addAccounts(_, loadableState):
 			switch loadableState {
 			case let .success(factorSource):
 				factorSourceOption = .specific(factorSource)
@@ -315,7 +332,7 @@ extension AccountRecoveryScanInProgress {
 				assertionFailure(errorMsg)
 				return .send(.delegate(.failed))
 			}
-		case let .privateHD(privateHDFactorSource):
+		case let .createProfile(privateHDFactorSource):
 			factorSourceOption = .specificPrivateHDFactorSource(privateHDFactorSource)
 		}
 

RadixWallet/Features/AccountRecoveryScan/Coordinator/AccountRecoveryScanCoordinator.swift

@@ -37,13 +37,13 @@ struct AccountRecoveryScanCoordinator: Sendable, FeatureReducer {
 			switch purpose {
 			case let .addAccounts(id, forOlympiaAccounts):
 				AccountRecoveryScanInProgress.State(
-					mode: .factorSourceWithID(id: id),
+					mode: .addAccounts(factorSourceId: id),
 					forOlympiaAccounts: forOlympiaAccounts
 				)
 
 			case let .createProfile(privateHDFactorSource):
 				AccountRecoveryScanInProgress.State(
-					mode: .privateHD(privateHDFactorSource),
+					mode: .createProfile(privateHDFactorSource),
 					forOlympiaAccounts: false
 				)
 			}

RadixWallet/Features/MainFeature/Main+Reducer.swift

@@ -56,6 +56,7 @@ struct Main: Sendable, FeatureReducer {
 	@Dependency(\.securityCenterClient) var securityCenterClient
 	@Dependency(\.accountLockersClient) var accountLockersClient
 	@Dependency(\.deepLinkHandlerClient) var deepLinkHandlerClient
+	@Dependency(\.radixConnectClient) var radixConnectClient
 
 	init() {}
 
@@ -82,6 +83,7 @@ struct Main: Sendable, FeatureReducer {
 				.merge(with: startMonitoringSecurityCenterEffect())
 				.merge(with: startMonitoringAccountLockersEffect())
 				.merge(with: gatewayValuesEffect())
+				.merge(with: startNotifyingConnectorWithAccounts())
 		}
 	}
 
@@ -125,6 +127,16 @@ struct Main: Sendable, FeatureReducer {
 		}
 	}
 
+	private func startNotifyingConnectorWithAccounts() -> Effect<Action> {
+		.run { _ in
+			do {
+				try await radixConnectClient.startNotifyingConnectorWithAccounts()
+			} catch {
+				loggerGlobal.notice("radixConnectClient.startNotifyingConnectorWithAccounts failed: \(error)")
+			}
+		}
+	}
+
 	func reduce(into state: inout State, childAction: ChildAction) -> Effect<Action> {
 		switch childAction {
 		case .home(.delegate(.displaySettings)):

RadixWalletTests/Features/MainFeatureTests/MainFeatureTests.swift

@@ -35,6 +35,7 @@ final class MainFeatureTests: TestCase {
 				.dependency(\.securityCenterClient, .noop)
 				.dependency(\.deepLinkHandlerClient, .noop)
 				.dependency(\.accountLockersClient, .noop)
+				.dependency(\.radixConnectClient, .noop)
 		}
 
 		XCTAssertFalse(store.state.showIsUsingTestnetBanner)