[ABW-2214] Shared persona data not persisted in profile

Package.swift

@@ -775,6 +775,7 @@ package.addModules([
 		name: "PersonasClientLive",
 		dependencies: [
 			"PersonasClient",
+			"AuthorizedDappsClient", // Need to update persisted shared persona data if a persona data entry is deleted, so we do not have broken references.
 			"ProfileStore",
 		],
 		tests: .yes()

Sources/Clients/AuthorizedDappsClient/AuthorizedDappsClient+Interface.swift

@@ -36,7 +36,7 @@ extension AuthorizedDappsClient {
 	public typealias DetailsForAuthorizedDapp = @Sendable (Profile.Network.AuthorizedDapp) async throws -> Profile.Network.AuthorizedDappDetailed
 	public typealias AddAuthorizedDapp = @Sendable (Profile.Network.AuthorizedDapp) async throws -> Void
 	public typealias UpdateOrAddAuthorizedDapp = @Sendable (Profile.Network.AuthorizedDapp) async throws -> Void
-	public typealias ForgetAuthorizedDapp = @Sendable (Profile.Network.AuthorizedDapp.ID, NetworkID) async throws -> Void
+	public typealias ForgetAuthorizedDapp = @Sendable (Profile.Network.AuthorizedDapp.ID, NetworkID?) async throws -> Void
 	public typealias UpdateAuthorizedDapp = @Sendable (Profile.Network.AuthorizedDapp) async throws -> Void
 	public typealias DeauthorizePersonaFromDapp = @Sendable (Profile.Network.Persona.ID, Profile.Network.AuthorizedDapp.ID, NetworkID) async throws -> Void
 }
@@ -57,4 +57,119 @@ extension AuthorizedDappsClient {
 	) async throws -> IdentifiedArrayOf<Profile.Network.AuthorizedDapp> {
 		try await getAuthorizedDapps().filter { $0.referencesToAuthorizedPersonas.ids.contains(id) }
 	}
+
+	public func removeBrokenReferencesToSharedPersonaData(
+		personaCurrent: Profile.Network.Persona,
+		personaUpdated: Profile.Network.Persona
+	) async throws {
+		guard personaCurrent.id == personaUpdated.id else {
+			struct PersonaIDMismatch: Swift.Error {}
+			throw PersonaIDMismatch()
+		}
+		let identityAddress = personaCurrent.address
+		let dApps = try await getAuthorizedDapps()
+
+		// We only care about the updated persona
+		let idsOfEntriesToKeep = Set(personaUpdated.personaData.entries.map(\.id))
+
+		for authorizedDapp in dApps {
+			var updatedAuthedDapp = authorizedDapp
+			for personaSimple in authorizedDapp.referencesToAuthorizedPersonas {
+				guard personaSimple.identityAddress == identityAddress else {
+					// irrelvant Persona
+					continue
+				}
+				// Relevant Persona => check if there are any old PersonaData entries that needs deleting
+				let idsOfEntriesToDelete = personaSimple.sharedPersonaData.entryIDs.subtracting(idsOfEntriesToKeep)
+
+				guard !idsOfEntriesToDelete.isEmpty else {
+					// No old entries needs to be deleted.
+					continue
+				}
+
+				loggerGlobal.notice("Pruning stale PersonaData entries with IDs: \(idsOfEntriesToDelete), for persona: \(personaUpdated.address) (\(personaUpdated.displayName.rawValue)), for Dapp: \(authorizedDapp)")
+				var authorizedPersonaSimple = personaSimple
+
+				authorizedPersonaSimple.sharedPersonaData.remove(ids: idsOfEntriesToDelete)
+
+				// Write back to `updatedAuthedDapp`
+				updatedAuthedDapp.referencesToAuthorizedPersonas[id: authorizedPersonaSimple.id] = authorizedPersonaSimple
+
+				// Soundness check
+				if
+					!Set(personaUpdated.personaData.entries.map(\.id))
+					.isSuperset(
+						of:
+						updatedAuthedDapp
+							.referencesToAuthorizedPersonas[id: authorizedPersonaSimple.id]!
+							.sharedPersonaData
+							.entryIDs
+					)
+				{
+					let errMsg = "Incorrect implementation, failed to prune stale PersonaData entries for authorizedDapp"
+					assertionFailure(errMsg)
+					loggerGlobal.error(.init(stringLiteral: errMsg))
+				}
+			}
+			if updatedAuthedDapp != authorizedDapp {
+				// Write back `updatedAuthedDapp` to Profile only if changes were needed
+				try await updateAuthorizedDapp(updatedAuthedDapp)
+			} else {
+				loggerGlobal.feature("nothing to do... skipped updating authorizedDapp")
+			}
+		}
+	}
+}
+
+extension Profile.Network.AuthorizedDapp.AuthorizedPersonaSimple.SharedPersonaData {
+	private mutating func remove(id: PersonaDataEntryID) {
+		func removeCollectionIfNeeded(
+			at keyPath: WritableKeyPath<Self, Profile.Network.AuthorizedDapp.AuthorizedPersonaSimple.SharedPersonaData.SharedCollection?>
+		) {
+			guard
+				var collection = self[keyPath: keyPath],
+				collection.ids.contains(id)
+			else { return }
+			collection.ids.remove(id)
+			switch collection.request.quantifier {
+			case .atLeast:
+				if collection.ids.count < collection.request.quantity {
+					// must delete whole collection since requested quantity is no longer fulfilled.
+					self[keyPath: keyPath] = nil
+				}
+			case .exactly:
+				// Must delete whole collection since requested quantity is no longer fulfilled,
+				// since we **just** deleted the id from `ids`.
+				self[keyPath: keyPath] = nil
+			}
+		}
+
+		func removeEntryIfNeeded(
+			at keyPath: WritableKeyPath<Self, PersonaDataEntryID?>
+		) {
+			guard self[keyPath: keyPath] == id else { return }
+			self[keyPath: keyPath] = nil
+		}
+
+		removeEntryIfNeeded(at: \.name)
+		removeEntryIfNeeded(at: \.dateOfBirth)
+		removeEntryIfNeeded(at: \.companyName)
+		removeCollectionIfNeeded(at: \.emailAddresses)
+		removeCollectionIfNeeded(at: \.phoneNumbers)
+		removeCollectionIfNeeded(at: \.urls)
+		removeCollectionIfNeeded(at: \.postalAddresses)
+		removeCollectionIfNeeded(at: \.creditCards)
+
+		// The only purpose of this switch is to make sure we get a compilation error when we add a new PersonaData.Entry kind, so
+		// we do not forget to handle it here.
+		switch PersonaData.Entry.Kind.fullName {
+		case .fullName, .dateOfBirth, .companyName, .emailAddress, .phoneNumber, .url, .postalAddress, .creditCard: break
+		}
+	}
+
+	mutating func remove(ids: Set<PersonaDataEntryID>) {
+		ids.forEach {
+			remove(id: $0)
+		}
+	}
 }

Sources/Clients/AuthorizedDappsClientLive/AuthorizedDappsClient+Live.swift

@@ -20,8 +20,10 @@ extension AuthorizedDappsClient: DependencyKey {
 					_ = try $0.addAuthorizedDapp(newDapp)
 				}
 			},
-			forgetAuthorizedDapp: { toForget, networkID in
-				try await getProfileStore().updating {
+			forgetAuthorizedDapp: { toForget, maybeNetworkID in
+				let currentNetworkID = await getProfileStore().profile.networkID
+				let networkID = maybeNetworkID ?? currentNetworkID
+				return try await getProfileStore().updating {
 					_ = try $0.forgetAuthorizedDapp(toForget, on: networkID)
 				}
 			},

Sources/Core/SharedModels/P2P/Dapp/Models/Interaction/Requests/ResetRequestItem.swift

@@ -1,6 +1,6 @@
 import Prelude
 
-// MARK: - P2P.Dapp.Request.OneTimeAccountsRequestItem
+// MARK: - P2P.Dapp.Request.ResetRequestItem
 extension P2P.Dapp.Request {
 	public struct ResetRequestItem: Sendable, Hashable, Decodable {
 		public let accounts: Bool

Sources/Features/AuthorizedDAppsFeature/AuthorizedDApps/AuthorizedDApps.swift

@@ -36,6 +36,7 @@ public struct AuthorizedDapps: Sendable, FeatureReducer {
 		case loadedDapps(TaskResult<Profile.Network.AuthorizedDapps>)
 		case loadedThumbnail(URL, dApp: Profile.Network.AuthorizedDapp.ID)
 		case presentDappDetails(DappDetails.State)
+		case failedToGetDetailsOfDapp(id: Profile.Network.AuthorizedDapp.ID)
 	}
 
 	public enum ChildAction: Sendable, Equatable {
@@ -56,17 +57,16 @@ public struct AuthorizedDapps: Sendable, FeatureReducer {
 	public func reduce(into state: inout State, viewAction: ViewAction) -> EffectTask<Action> {
 		switch viewAction {
 		case .appeared:
-			return .task {
-				await loadAuthorizedDapps()
-			}
+			return loadAuthorizedDapps()
 
 		case let .didSelectDapp(dAppID):
 			return .run { send in
 				let details = try await authorizedDappsClient.getDetailedDapp(dAppID)
 				let presentedDappState = DappDetails.State(dApp: details)
 				await send(.internal(.presentDappDetails(presentedDappState)))
-			} catch: { error, _ in
+			} catch: { error, send in
 				errorQueue.schedule(error)
+				await send(.internal(.failedToGetDetailsOfDapp(id: dAppID)))
 			}
 		}
 	}
@@ -86,6 +86,19 @@ public struct AuthorizedDapps: Sendable, FeatureReducer {
 					}
 				}
 			}
+
+		case let .failedToGetDetailsOfDapp(dappId):
+			#if DEBUG
+			return .run { _ in
+				loggerGlobal.notice("DEBUG ONLY deleting authorized dapp since we failed to load detailed info about it")
+				try? await authorizedDappsClient.forgetAuthorizedDapp(dappId, nil)
+
+			}.concatenate(with: loadAuthorizedDapps())
+			#else
+			// FIXME: Should we have to handle this, this is a discrepancy bug..
+			return .none
+			#endif
+
 		case let .loadedDapps(.failure(error)):
 			errorQueue.schedule(error)
 			return .none
@@ -103,18 +116,19 @@ public struct AuthorizedDapps: Sendable, FeatureReducer {
 		case .presentedDapp(.presented(.delegate(.dAppForgotten))):
 			return .run { send in
 				await send(.child(.presentedDapp(.dismiss)))
-				await send(loadAuthorizedDapps())
-			}
+			}.concatenate(with: loadAuthorizedDapps())
 
 		case .presentedDapp:
 			return .none
 		}
 	}
 
-	private func loadAuthorizedDapps() async -> Action {
-		let result = await TaskResult {
-			try await authorizedDappsClient.getAuthorizedDapps()
+	private func loadAuthorizedDapps() -> EffectTask<Action> {
+		.run { send in
+			let result = await TaskResult {
+				try await authorizedDappsClient.getAuthorizedDapps()
+			}
+			await send(.internal(.loadedDapps(result)))
 		}
-		return .internal(.loadedDapps(result))
 	}
 }