[WIP] ABW-2121 Save accounts needing recovery in UserDefaults

Package.swift

@@ -22,6 +22,9 @@ package.addModules([
 			"AssetTransferFeature",
 			"AccountPortfoliosClient",
 			"AssetsFeature",
+			"ImportMnemonicFeature",
+			"ProfileBackupsFeature",
+			"BackupsClient",
 		],
 		tests: .yes()
 	),
@@ -30,6 +33,7 @@ package.addModules([
 		dependencies: [
 			"AccountPortfoliosClient",
 			"FactorSourcesClient", // check if `device` or `ledger` controlled for security prompting
+			"AccountDetailsFeature", // "shield buttons"
 		],
 		tests: .no
 	),
@@ -242,6 +246,8 @@ package.addModules([
 			"AccountsClient",
 			"AppPreferencesClient",
 			"CreateAccountFeature",
+			"ImportMnemonicFeature",
+			"ProfileBackupsFeature", // actually only ImportMnemonicsFlowCoodinator, might split it out in future
 		],
 		tests: .yes()
 	),
@@ -388,26 +394,27 @@ package.addModules([
 		dependencies: [
 			"AccountsClient",
 			"AddLedgerFactorSourceFeature",
-			"ImportOlympiaLedgerAccountsAndFactorSourcesFeature",
 			"AppPreferencesClient",
 			"AuthorizedDAppsFeature",
 			"CacheClient",
-			"DeviceFactorSourceClient",
 			"DebugInspectProfileFeature",
+			"DeviceFactorSourceClient",
+			"DisplayEntitiesControlledByMnemonicFeature",
+			"EditPersonaFeature",
+			"EngineKit",
+			"FactorSourcesClient", // Check if user has any ledgers
+			"FaucetClient", //  EpochForWhenLastUsedByAccountAddress
 			"GatewayAPI",
 			"GatewaySettingsFeature",
-			"DisplayEntitiesControlledByMnemonicFeature",
 			"ImportMnemonicFeature",
-			"FactorSourcesClient", // Check if user has any ledgers
+			"ImportOlympiaLedgerAccountsAndFactorSourcesFeature",
 			"ImportLegacyWalletClient",
 			"P2PLinksFeature",
 			"PersonasFeature",
 			"RadixConnectClient",
+			"ProfileBackupsFeature",
 			"ScanQRFeature",
 			"SecurityStructureConfigurationListFeature",
-			"EditPersonaFeature",
-			"ProfileBackupsFeature",
-			"EngineKit",
 		],
 		tests: .yes()
 	),

Sources/Clients/FactorSourcesClient/FactorSourcesClient+Interface.swift

@@ -46,7 +46,7 @@ extension FactorSourcesClient {
 	public typealias GetFactorSources = @Sendable () async throws -> FactorSources
 	public typealias FactorSourcesAsyncSequence = @Sendable () async -> AnyAsyncSequence<FactorSources>
 	public typealias AddPrivateHDFactorSource = @Sendable (AddPrivateHDFactorSourceRequest) async throws -> FactorSourceID
-	public typealias CheckIfHasOlympiaFactorSourceForAccounts = @Sendable (NonEmpty<OrderedSet<OlympiaAccountToMigrate>>) async -> FactorSourceID.FromHash?
+	public typealias CheckIfHasOlympiaFactorSourceForAccounts = @Sendable (BIP39.WordCount, NonEmpty<OrderedSet<OlympiaAccountToMigrate>>) async -> FactorSourceID.FromHash?
 	public typealias SaveFactorSource = @Sendable (FactorSource) async throws -> Void
 	public typealias UpdateFactorSource = @Sendable (FactorSource) async throws -> Void
 	public typealias GetSigningFactors = @Sendable (GetSigningFactorsRequest) async throws -> SigningFactors
@@ -257,10 +257,7 @@ extension MnemonicWithPassphrase {
 	) throws -> Bool {
 		let hdRoot = try self.hdRoot()
 
-		for account in accounts {
-			let path = account.0
-			let publicKey = account.1
-
+		for (path, publicKey) in accounts {
 			let derivedPublicKey: SLIP10.PublicKey = try {
 				switch publicKey.curve {
 				case .secp256k1:

Sources/Clients/FactorSourcesClient/FactorSourcesClient+Test.swift

@@ -28,7 +28,7 @@ extension FactorSourcesClient: TestDependencyKey {
 		getFactorSources: { throw NoopError() },
 		factorSourcesAsyncSequence: { AsyncLazySequence([]).eraseToAnyAsyncSequence() },
 		addPrivateHDFactorSource: { _ in throw NoopError() },
-		checkIfHasOlympiaFactorSourceForAccounts: { _ in nil },
+		checkIfHasOlympiaFactorSourceForAccounts: { _, _ in nil },
 		saveFactorSource: { _ in },
 		updateFactorSource: { _ in },
 		getSigningFactors: { _ in throw NoopError() },

Sources/Clients/FactorSourcesClientLive/FactorSourcesClient+Live.swift

@@ -66,28 +66,38 @@ extension FactorSourcesClient: DependencyKey {
 
 				return factorSourceID
 			},
-			checkIfHasOlympiaFactorSourceForAccounts: { softwareAccounts -> FactorSourceID.FromHash? in
+			checkIfHasOlympiaFactorSourceForAccounts: { wordCount, softwareAccounts -> FactorSourceID.FromHash? in
 				guard softwareAccounts.allSatisfy({ $0.accountType == .software }) else {
 					assertionFailure("Unexpectedly received hardware account, unable to verify.")
 					return nil
 				}
 				do {
 					// Might be empty, if it is, we will just return nil (for-loop below not run).
-					let factorSourceIDs = try await getFactorSources()
+					let olympiaDeviceFactorSources: [DeviceFactorSource] = try await getFactorSources()
 						.filter(\.supportsOlympia)
 						.filter { $0.kind == .device }
-						.map(\.id)
+						.compactMap {
+							guard
+								let deviceFactorSource = try? $0.extract(as: DeviceFactorSource.self),
+								deviceFactorSource.hint.mnemonicWordCount == wordCount
+							else {
+								return nil
+							}
+							return deviceFactorSource
+						}
+
+					let factorSourceIDs = olympiaDeviceFactorSources.map(\.id)
 
 					for factorSourceID in factorSourceIDs {
-						guard let mnemonic = try await secureStorageClient.loadMnemonicByFactorSourceID(factorSourceID, .importOlympiaAccounts) else {
+						guard let mnemonic = try await secureStorageClient.loadMnemonicByFactorSourceID(factorSourceID.embed(), .importOlympiaAccounts) else {
 							continue
 						}
-						guard try mnemonic.validatePublicKeys(of: softwareAccounts) else {
+						guard (try? mnemonic.validatePublicKeys(of: softwareAccounts)) == true else {
 							continue
 						}
 						// YES Managed to validate all software accounts against existing factor source
 						loggerGlobal.debug("Existing factor source found for selected Olympia software accounts.")
-						return factorSourceID.extract(FactorSourceID.FromHash.self)
+						return factorSourceID
 					}
 
 					return nil // Did not find any Olympia `.device` factor sources

Sources/Clients/FaucetClient/FaucetClient+Interface.swift

@@ -132,3 +132,43 @@ extension DependencyValues {
 		set { self[FaucetClient.self] = newValue }
 	}
 }
+
+extension UserDefaultsClient {
+	public func loadEpochForWhenLastUsedByAccountAddress() -> EpochForWhenLastUsedByAccountAddress {
+		(try? loadCodable(key: .epochForWhenLastUsedByAccountAddress)) ?? .init()
+	}
+
+	public func saveEpochForWhenLastUsedByAccountAddress(_ value: EpochForWhenLastUsedByAccountAddress) async {
+		// not important enough to propagate error
+		try? await save(codable: value, forKey: .epochForWhenLastUsedByAccountAddress)
+	}
+}
+
+// MARK: - EpochForWhenLastUsedByAccountAddress
+// internal for tests
+public struct EpochForWhenLastUsedByAccountAddress: Codable, Hashable, Sendable {
+	public struct EpochForAccount: Codable, Sendable, Hashable, Identifiable {
+		public typealias ID = AccountAddress
+		public var id: ID { accountAddress }
+		public let accountAddress: AccountAddress
+		public var epoch: Epoch
+	}
+
+	public var epochForAccounts: IdentifiedArrayOf<EpochForAccount>
+	public init(epochForAccounts: IdentifiedArrayOf<EpochForAccount> = .init()) {
+		self.epochForAccounts = epochForAccounts
+	}
+
+	public mutating func update(epoch: Epoch, for id: AccountAddress) {
+		if var existing = epochForAccounts[id: id] {
+			existing.epoch = epoch
+			epochForAccounts[id: id] = existing
+		} else {
+			epochForAccounts.append(.init(accountAddress: id, epoch: epoch))
+		}
+	}
+
+	public func getEpoch(for accountAddress: AccountAddress) -> Epoch? {
+		epochForAccounts[id: accountAddress]?.epoch
+	}
+}

Sources/Clients/FaucetClient/FaucetClient+Live.swift

@@ -8,8 +8,6 @@ import SubmitTransactionClient
 import TransactionClient
 
 let minimumNumberOfEpochsPassedForFaucetToBeReused = 1
-// internal for tests
-let epochForWhenLastUsedByAccountAddressKey = "faucet.epochForWhenLastUsedByAccountAddressKey"
 
 // MARK: - FaucetClient + DependencyKey
 extension FaucetClient: DependencyKey {
@@ -114,7 +112,7 @@ extension FaucetClient: DependencyKey {
 		#if DEBUG
 		let createFungibleToken: CreateFungibleToken = { request in
 			let networkID = await gatewaysClient.getCurrentNetworkID()
-			let manifest = try try ManifestBuilder.manifestForCreateFungibleToken(
+			let manifest = try ManifestBuilder.manifestForCreateFungibleToken(
 				account: request.recipientAccountAddress,
 				networkID: networkID
 			)
@@ -169,56 +167,3 @@ extension FaucetClient: DependencyKey {
 		#endif // DEBUG
 	}()
 }
-
-private extension UserDefaultsClient {
-	func loadEpochForWhenLastUsedByAccountAddress() -> EpochForWhenLastUsedByAccountAddress {
-		@Dependency(\.jsonDecoder) var jsonDecoder
-		if
-			let data = self.dataForKey(epochForWhenLastUsedByAccountAddressKey),
-			let epochs = try? jsonDecoder().decode(EpochForWhenLastUsedByAccountAddress.self, from: data)
-		{
-			return epochs
-		} else {
-			return .init()
-		}
-	}
-
-	func saveEpochForWhenLastUsedByAccountAddress(_ value: EpochForWhenLastUsedByAccountAddress) async {
-		@Dependency(\.jsonEncoder) var jsonEncoder
-		do {
-			let data = try jsonEncoder().encode(value)
-			await self.setData(data, epochForWhenLastUsedByAccountAddressKey)
-		} catch {
-			// Not important enough to throw...
-		}
-	}
-}
-
-// MARK: - EpochForWhenLastUsedByAccountAddress
-// internal for tests
-struct EpochForWhenLastUsedByAccountAddress: Codable, Hashable, Sendable {
-	struct EpochForAccount: Codable, Sendable, Hashable, Identifiable {
-		typealias ID = AccountAddress
-		var id: ID { accountAddress }
-		let accountAddress: AccountAddress
-		var epoch: Epoch
-	}
-
-	var epochForAccounts: IdentifiedArrayOf<EpochForAccount>
-	init(epochForAccounts: IdentifiedArrayOf<EpochForAccount> = .init()) {
-		self.epochForAccounts = epochForAccounts
-	}
-
-	mutating func update(epoch: Epoch, for id: AccountAddress) {
-		if var existing = epochForAccounts[id: id] {
-			existing.epoch = epoch
-			epochForAccounts[id: id] = existing
-		} else {
-			epochForAccounts.append(.init(accountAddress: id, epoch: epoch))
-		}
-	}
-
-	func getEpoch(for accountAddress: AccountAddress) -> Epoch? {
-		epochForAccounts[id: accountAddress]?.epoch
-	}
-}

Sources/Clients/ProfileStore/ProfileStore.swift

@@ -13,7 +13,7 @@ import SecureStorageClient
 /// and if user has enabled: the keychain item syncs to iCloud
 /// as well.
 ///
-/// This actor is meant **not** meant to be used directly by the
+/// This actor is **not** meant to be used directly by the
 /// apps reducers, but rather always indirectly, via the live
 /// implementations of a set of clients (dependencies), e.g.:
 /// * AccountsClient
@@ -636,17 +636,15 @@ struct EphemeralProfile: Sendable, Hashable {
 }
 
 extension UserDefaultsClient {
-	static let activeProfileID = "profile.activeProfileID"
-
-	func getActiveProfileID() -> ProfileSnapshot.Header.ID? {
-		stringForKey(Self.activeProfileID).flatMap(UUID.init(uuidString:))
+	public func getActiveProfileID() -> ProfileSnapshot.Header.ID? {
+		stringForKey(.activeProfileID).flatMap(UUID.init(uuidString:))
 	}
 
-	func setActiveProfileID(_ id: ProfileSnapshot.Header.UsedDeviceInfo.ID) async {
-		await setString(id.uuidString, Self.activeProfileID)
+	public func setActiveProfileID(_ id: ProfileSnapshot.Header.UsedDeviceInfo.ID) async {
+		await setString(id.uuidString, .activeProfileID)
 	}
 
-	func removeActiveProfileID() async {
-		await remove(Self.activeProfileID)
+	public func removeActiveProfileID() async {
+		await remove(.activeProfileID)
 	}
 }

Sources/Core/FeaturePrelude/UserDefaultsClient+AccountRecovery.swift

@@ -0,0 +1,41 @@
+import EngineKit // AccountAddress
+import Prelude // UserDefaultsClient
+import Profile
+
+extension UserDefaultsClient {
+	public func addAccountsThatNeedRecovery(accounts new: OrderedSet<AccountAddress>) async throws {
+		var accounts = getAddressesOfAccountsThatNeedRecovery()
+		accounts.append(contentsOf: new)
+		try await save(codable: accounts, forKey: .accountsThatNeedRecovery)
+	}
+
+	public func removeFromListOfAccountsThatNeedRecovery(accounts toRemove: OrderedSet<AccountAddress>) async throws {
+		var accounts = getAddressesOfAccountsThatNeedRecovery()
+		accounts.subtract(toRemove)
+		try await save(codable: accounts, forKey: .accountsThatNeedRecovery)
+	}
+
+	public func getAddressesOfAccountsThatNeedRecovery() -> OrderedSet<AccountAddress> {
+		(try? loadCodable(key: .accountsThatNeedRecovery)) ?? OrderedSet<AccountAddress>()
+	}
+
+	public func removeAccountsThatNeedRecovery() async {
+		await setData(nil, .accountsThatNeedRecovery)
+	}
+}
+
+extension UserDefaultsClient {
+	public func addFactorSourceIDOfBackedUpMnemonic(_ factorSourceID: FactorSourceID.FromHash) async throws {
+		var ids = getFactorSourceIDOfBackedUpMnemonics()
+		ids.append(factorSourceID)
+		try await save(codable: ids, forKey: .mnemonicsUserClaimsToHaveBackedUp)
+	}
+
+	public func getFactorSourceIDOfBackedUpMnemonics() -> OrderedSet<FactorSourceID.FromHash> {
+		(try? loadCodable(key: .mnemonicsUserClaimsToHaveBackedUp)) ?? OrderedSet<FactorSourceID.FromHash>()
+	}
+
+	public func removeAllFactorSourceIDsOfBackedUpMnemonics() async {
+		await setData(nil, .mnemonicsUserClaimsToHaveBackedUp)
+	}
+}