diff --git a/lib/reducers/keyserver-reducer.js b/lib/reducers/keyserver-reducer.js
index 25c681bae..9cf7a867a 100644
--- a/lib/reducers/keyserver-reducer.js
+++ b/lib/reducers/keyserver-reducer.js
@@ -1,592 +1,637 @@
 // @flow
 
 import { unsupervisedBackgroundActionType } from './lifecycle-state-reducer.js';
 import { updateActivityActionTypes } from '../actions/activity-actions.js';
+import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   updateLastCommunicatedPlatformDetailsActionType,
   setDeviceTokenActionTypes,
 } from '../actions/device-actions.js';
 import {
   addKeyserverActionType,
   removeKeyserverActionType,
 } from '../actions/keyserver-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   keyserverAuthActionTypes,
   logOutActionTypes,
   deleteKeyserverAccountActionTypes,
   deleteAccountActionTypes,
   keyserverRegisterActionTypes,
   logInActionTypes,
   resetUserStateActionType,
 } from '../actions/user-actions.js';
 import {
   setNewSessionActionType,
   updateConnectionStatusActionType,
   setLateResponseActionType,
   updateKeyserverReachabilityActionType,
   setConnectionIssueActionType,
   setSessionRecoveryInProgressActionType,
 } from '../keyserver-conn/keyserver-conn-types.js';
 import {
   keyserverStoreOpsHandlers,
   type ReplaceKeyserverOperation,
   type RemoveKeyserversOperation,
   type KeyserverStoreOperation,
 } from '../ops/keyserver-store-ops.js';
 import { queueActivityUpdatesActionType } from '../types/activity-types.js';
-import type { KeyserverStore } from '../types/keyserver-types.js';
+import type {
+  KeyserverInfos,
+  KeyserverStore,
+} from '../types/keyserver-types.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { processUpdatesActionType } from '../types/update-types.js';
 import { getConfig } from '../utils/config.js';
+import { getMessageForException } from '../utils/errors.js';
+import { assertObjectsAreEqual } from '../utils/objects.js';
 import { setURLPrefix } from '../utils/url-utils.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
+function assertKeyserverStoresAreEqual(
+  processedKeyserverStore: KeyserverInfos,
+  expectedKeyserverStore: KeyserverInfos,
+  location: string,
+  onStateDifference?: (message: string) => mixed,
+) {
+  try {
+    assertObjectsAreEqual(
+      processedKeyserverStore,
+      expectedKeyserverStore,
+      `KeyserverInfos - ${location}`,
+    );
+  } catch (e) {
+    console.log(
+      'Error processing KeyserverStore ops',
+      processedKeyserverStore,
+      expectedKeyserverStore,
+    );
+    const message = `Error processing KeyserverStore ops ${
+      getMessageForException(e) ?? '{no exception message}'
+    }`;
+    onStateDifference?.(message);
+  }
+}
+
 const { processStoreOperations: processStoreOps } = keyserverStoreOpsHandlers;
 
 export default function reduceKeyserverStore(
   state: KeyserverStore,
   action: BaseAction,
+  onStateDifference?: (message: string) => mixed,
 ): {
   keyserverStore: KeyserverStore,
   keyserverStoreOperations: $ReadOnlyArray<KeyserverStoreOperation>,
 } {
   if (action.type === addKeyserverActionType) {
     const replaceOperation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: action.payload.keyserverAdminUserID,
         keyserverInfo: {
           ...action.payload.newKeyserverInfo,
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [replaceOperation]),
       keyserverStoreOperations: [replaceOperation],
     };
   } else if (action.type === removeKeyserverActionType) {
     const removeOperation: RemoveKeyserversOperation = {
       type: 'remove_keyservers',
       payload: {
         ids: [action.payload.keyserverAdminUserID],
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [removeOperation]),
       keyserverStoreOperations: [removeOperation],
     };
   } else if (action.type === resetUserStateActionType) {
     // this action is only dispatched on native
     const replaceOperations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in state.keyserverInfos) {
       const stateCookie = state.keyserverInfos[keyserverID]?.cookie;
       if (stateCookie && stateCookie.startsWith('anonymous=')) {
         continue;
       }
       replaceOperations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             cookie: null,
           },
         },
       });
     }
 
     return {
       keyserverStore: processStoreOps(state, replaceOperations),
       keyserverStoreOperations: replaceOperations,
     };
   } else if (action.type === setNewSessionActionType) {
     const { keyserverID, sessionChange } = action.payload;
     const gotUserCookie = sessionChange.cookie?.startsWith('user=');
     if (!state.keyserverInfos[keyserverID]) {
       if (gotUserCookie) {
         console.log(
           'received sessionChange with user cookie, ' +
             `but keyserver ${keyserverID} is not in KeyserverStore!`,
         );
       }
       return {
         keyserverStore: state,
         keyserverStoreOperations: [],
       };
     }
 
     let newKeyserverInfo = {
       ...state.keyserverInfos[keyserverID],
     };
     let keyserverUpdated = false;
 
     if (sessionChange.cookie !== undefined) {
       newKeyserverInfo = {
         ...newKeyserverInfo,
         cookie: sessionChange.cookie,
       };
       keyserverUpdated = true;
     }
     if (sessionChange.cookieInvalidated) {
       newKeyserverInfo = {
         ...newKeyserverInfo,
         connection: {
           ...newKeyserverInfo.connection,
           queuedActivityUpdates: [],
         },
       };
       keyserverUpdated = true;
     }
     if (
       state.keyserverInfos[keyserverID].connection.sessionRecoveryInProgress &&
       (gotUserCookie || sessionChange.cookieInvalidated)
     ) {
       newKeyserverInfo = {
         ...newKeyserverInfo,
         connection: {
           ...newKeyserverInfo.connection,
           sessionRecoveryInProgress: false,
         },
       };
       keyserverUpdated = true;
     }
 
     const operations: ReplaceKeyserverOperation[] = [];
     if (keyserverUpdated) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: newKeyserverInfo,
         },
       });
     }
 
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === keyserverAuthActionTypes.success
   ) {
     const { updatesCurrentAsOf } = action.payload;
 
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in updatesCurrentAsOf) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             updatesCurrentAsOf: updatesCurrentAsOf[keyserverID],
             lastCommunicatedPlatformDetails: getConfig().platformDetails,
             connection: {
               ...state.keyserverInfos[keyserverID].connection,
               connectionIssue: null,
             },
           },
         },
       });
     }
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (action.type === fullStateSyncActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf: action.payload.updatesCurrentAsOf,
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === incrementalStateSyncActionType) {
     const { keyserverID } = action.payload;
     let { deviceToken } = state.keyserverInfos[keyserverID];
     for (const update of action.payload.updatesResult.newUpdates) {
       if (
         update.type === updateTypes.BAD_DEVICE_TOKEN &&
         update.deviceToken === state.keyserverInfos[keyserverID].deviceToken
       ) {
         deviceToken = null;
         break;
       }
     }
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf: action.payload.updatesResult.currentAsOf,
           deviceToken,
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === processUpdatesActionType) {
     const { keyserverID } = action.payload;
     const updatesCurrentAsOf = Math.max(
       action.payload.updatesResult.currentAsOf,
       state.keyserverInfos[keyserverID].updatesCurrentAsOf,
     );
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           updatesCurrentAsOf,
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setURLPrefix) {
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: ashoatKeyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[ashoatKeyserverID],
           urlPrefix: action.payload,
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateLastCommunicatedPlatformDetailsActionType) {
     const { keyserverID, platformDetails } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           lastCommunicatedPlatformDetails: platformDetails,
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === keyserverRegisterActionTypes.success) {
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: ashoatKeyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[ashoatKeyserverID],
           lastCommunicatedPlatformDetails: getConfig().platformDetails,
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateConnectionStatusActionType) {
     const { keyserverID, status } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             status,
             lateResponses: [],
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === unsupervisedBackgroundActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             status: 'disconnected',
             lateResponses: [],
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === queueActivityUpdatesActionType) {
     const { activityUpdates, keyserverID } = action.payload;
     const oldConnection = state.keyserverInfos[keyserverID].connection;
     const connection = {
       ...oldConnection,
       queuedActivityUpdates: [
         ...oldConnection.queuedActivityUpdates.filter(existingUpdate => {
           for (const activityUpdate of activityUpdates) {
             if (
               ((existingUpdate.focus && activityUpdate.focus) ||
                 (existingUpdate.focus === false &&
                   activityUpdate.focus !== undefined)) &&
               existingUpdate.threadID === activityUpdate.threadID
             ) {
               return false;
             }
           }
           return true;
         }),
         ...activityUpdates,
       ],
     };
 
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection,
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateActivityActionTypes.success) {
     const { activityUpdates } = action.payload;
 
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in activityUpdates) {
       const oldConnection = state.keyserverInfos[keyserverID].connection;
       const queuedActivityUpdates = oldConnection.queuedActivityUpdates.filter(
         activityUpdate =>
           !activityUpdates[keyserverID].includes(activityUpdate),
       );
 
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             connection: { ...oldConnection, queuedActivityUpdates },
           },
         },
       });
     }
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success
   ) {
     // We want to remove all keyservers but Ashoat's keyserver
     const oldConnection = state.keyserverInfos[ashoatKeyserverID].connection;
     const operations: KeyserverStoreOperation[] = [
       { type: 'remove_all_keyservers' },
     ];
     operations.push({
       type: 'replace_keyserver',
       payload: {
         id: ashoatKeyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[ashoatKeyserverID],
           connection: {
             ...oldConnection,
             connectionIssue: null,
             queuedActivityUpdates: [],
             lateResponses: [],
           },
           cookie: null,
         },
       },
     });
 
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (action.type === deleteKeyserverAccountActionTypes.success) {
     const operations: KeyserverStoreOperation[] = [
       {
         type: 'remove_keyservers',
         payload: { ids: action.payload.keyserverIDs },
       },
     ];
     if (action.payload.keyserverIDs.includes(ashoatKeyserverID)) {
       const oldConnection = state.keyserverInfos[ashoatKeyserverID].connection;
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: ashoatKeyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[ashoatKeyserverID],
             connection: {
               ...oldConnection,
               connectionIssue: null,
               queuedActivityUpdates: [],
               lateResponses: [],
             },
             cookie: null,
           },
         },
       });
     }
 
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (action.type === setLateResponseActionType) {
     const { messageID, isLate, keyserverID } = action.payload;
     const lateResponsesSet = new Set<number>(
       state.keyserverInfos[keyserverID].connection.lateResponses,
     );
     if (isLate) {
       lateResponsesSet.add(messageID);
     } else {
       lateResponsesSet.delete(messageID);
     }
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             lateResponses: [...lateResponsesSet],
           },
         },
       },
     };
 
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === updateKeyserverReachabilityActionType) {
     const { keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             unreachable: action.payload.visible,
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setDeviceTokenActionTypes.success) {
     const { deviceTokens } = action.payload;
     const operations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in deviceTokens) {
       operations.push({
         type: 'replace_keyserver',
         payload: {
           id: keyserverID,
           keyserverInfo: {
             ...state.keyserverInfos[keyserverID],
             deviceToken: deviceTokens[keyserverID],
           },
         },
       });
     }
     return {
       keyserverStore: processStoreOps(state, operations),
       keyserverStoreOperations: operations,
     };
   } else if (action.type === setConnectionIssueActionType) {
     const { connectionIssue, keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             connectionIssue,
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
   } else if (action.type === setSessionRecoveryInProgressActionType) {
     const { sessionRecoveryInProgress, keyserverID } = action.payload;
     const operation: ReplaceKeyserverOperation = {
       type: 'replace_keyserver',
       payload: {
         id: keyserverID,
         keyserverInfo: {
           ...state.keyserverInfos[keyserverID],
           connection: {
             ...state.keyserverInfos[keyserverID].connection,
             sessionRecoveryInProgress,
           },
         },
       },
     };
     return {
       keyserverStore: processStoreOps(state, [operation]),
       keyserverStoreOperations: [operation],
     };
+  } else if (action.type === setClientDBStoreActionType) {
+    // Once the functionality is confirmed to work correctly,
+    // we will proceed with returning keyserverInfos from the payload.
+    assertKeyserverStoresAreEqual(
+      action.payload.keyserverInfos ?? {},
+      state.keyserverInfos,
+      action.type,
+      onStateDifference,
+    );
+    return {
+      keyserverStore: state,
+      keyserverStoreOperations: [],
+    };
   }
 
   return {
     keyserverStore: state,
     keyserverStoreOperations: [],
   };
 }
diff --git a/lib/reducers/master-reducer.js b/lib/reducers/master-reducer.js
index 8b04f06aa..c2548435a 100644
--- a/lib/reducers/master-reducer.js
+++ b/lib/reducers/master-reducer.js
@@ -1,216 +1,217 @@
 // @flow
 
 import reduceCalendarFilters from './calendar-filters-reducer.js';
 import { reduceCalendarQuery } from './calendar-query-reducer.js';
 import reduceCustomerServer from './custom-server-reducer.js';
 import reduceDataLoaded from './data-loaded-reducer.js';
 import { reduceDraftStore } from './draft-reducer.js';
 import reduceEnabledApps from './enabled-apps-reducer.js';
 import { reduceEntryInfos } from './entry-reducer.js';
 import { reduceIntegrityStore } from './integrity-reducer.js';
 import reduceInviteLinks from './invite-links-reducer.js';
 import reduceKeyserverStore from './keyserver-reducer.js';
 import reduceLifecycleState from './lifecycle-state-reducer.js';
 import { reduceLoadingStatuses } from './loading-reducer.js';
 import reduceNextLocalID from './local-id-reducer.js';
 import { reduceMessageStore } from './message-reducer.js';
 import reduceBaseNavInfo from './nav-reducer.js';
 import { reduceNotifPermissionAlertInfo } from './notif-permission-alert-info-reducer.js';
 import policiesReducer from './policies-reducer.js';
 import reduceReportStore from './report-store-reducer.js';
 import reduceServicesAccessToken from './services-access-token-reducer.js';
 import reduceGlobalThemeInfo from './theme-reducer.js';
 import { reduceThreadActivity } from './thread-activity-reducer.js';
 import { reduceThreadInfos } from './thread-reducer.js';
 import { reduceCurrentUserInfo, reduceUserInfos } from './user-reducer.js';
 import { addKeyserverActionType } from '../actions/keyserver-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   keyserverRegisterActionTypes,
   logInActionTypes,
 } from '../actions/user-actions.js';
 import {
   keyserverStoreOpsHandlers,
   type ReplaceKeyserverOperation,
 } from '../ops/keyserver-store-ops.js';
 import { isStaff } from '../shared/staff-utils.js';
 import type { BaseNavInfo } from '../types/nav-types.js';
 import type { BaseAppState, BaseAction } from '../types/redux-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type { StoreOperations } from '../types/store-ops-types.js';
 import { isDev } from '../utils/dev-utils.js';
 
 export default function baseReducer<N: BaseNavInfo, T: BaseAppState<N>>(
   state: T,
   action: BaseAction,
   onStateDifference: (message: string) => mixed,
 ): { state: T, storeOperations: StoreOperations } {
   const { threadStore, newThreadInconsistencies, threadStoreOperations } =
     reduceThreadInfos(state.threadStore, action);
   const { threadInfos } = threadStore;
 
   const [entryStore, newEntryInconsistencies] = reduceEntryInfos(
     state.entryStore,
     action,
     threadInfos,
   );
 
   const onStateDifferenceForStaff = (message: string) => {
     const isCurrentUserStaff = state.currentUserInfo?.id
       ? isStaff(state.currentUserInfo.id)
       : false;
     if (isCurrentUserStaff || isDev) {
       onStateDifference(message);
     }
   };
 
   const [userStore, newUserInconsistencies, userStoreOperations] =
     reduceUserInfos(state.userStore, action, onStateDifferenceForStaff);
 
   const newInconsistencies = [
     ...newEntryInconsistencies,
     ...newThreadInconsistencies,
     ...newUserInconsistencies,
   ];
   // Only allow checkpoints to increase if we are connected
   // or if the action is a STATE_SYNC
   const { messageStoreOperations, messageStore: reducedMessageStore } =
     reduceMessageStore(state.messageStore, action, threadInfos);
   let messageStore = reducedMessageStore;
 
   let { keyserverStore, keyserverStoreOperations } = reduceKeyserverStore(
     state.keyserverStore,
     action,
+    onStateDifferenceForStaff,
   );
 
   if (
     action.type !== incrementalStateSyncActionType &&
     action.type !== fullStateSyncActionType &&
     action.type !== keyserverRegisterActionTypes.success &&
     action.type !== logInActionTypes.success &&
     action.type !== siweAuthActionTypes.success &&
     action.type !== addKeyserverActionType
   ) {
     const replaceOperations: ReplaceKeyserverOperation[] = [];
     for (const keyserverID in keyserverStore.keyserverInfos) {
       if (
         keyserverStore.keyserverInfos[keyserverID].connection.status ===
         'connected'
       ) {
         continue;
       }
       if (
         messageStore.currentAsOf[keyserverID] !==
         state.messageStore.currentAsOf[keyserverID]
       ) {
         messageStore = {
           ...messageStore,
           currentAsOf: {
             ...messageStore.currentAsOf,
             [keyserverID]: state.messageStore.currentAsOf[keyserverID],
           },
         };
       }
       if (
         state.keyserverStore.keyserverInfos[keyserverID] &&
         keyserverStore.keyserverInfos[keyserverID].updatesCurrentAsOf !==
           state.keyserverStore.keyserverInfos[keyserverID].updatesCurrentAsOf
       ) {
         replaceOperations.push({
           type: 'replace_keyserver',
           payload: {
             id: keyserverID,
             keyserverInfo: {
               ...keyserverStore.keyserverInfos[keyserverID],
               updatesCurrentAsOf:
                 state.keyserverStore.keyserverInfos[keyserverID]
                   .updatesCurrentAsOf,
             },
           },
         });
       }
     }
 
     keyserverStore = keyserverStoreOpsHandlers.processStoreOperations(
       keyserverStore,
       replaceOperations,
     );
     keyserverStoreOperations = [
       ...keyserverStoreOperations,
       ...replaceOperations,
     ];
   }
 
   const { draftStore, draftStoreOperations } = reduceDraftStore(
     state.draftStore,
     action,
   );
 
   const { reportStore, reportStoreOperations } = reduceReportStore(
     state.reportStore,
     action,
     newInconsistencies,
   );
 
   return {
     state: {
       ...state,
       navInfo: reduceBaseNavInfo(state.navInfo, action),
       draftStore,
       entryStore,
       loadingStatuses: reduceLoadingStatuses(state.loadingStatuses, action),
       currentUserInfo: reduceCurrentUserInfo(state.currentUserInfo, action),
       threadStore,
       userStore,
       messageStore,
       calendarFilters: reduceCalendarFilters(
         state.calendarFilters,
         action,
         threadStore,
       ),
       notifPermissionAlertInfo: reduceNotifPermissionAlertInfo(
         state.notifPermissionAlertInfo,
         action,
       ),
       actualizedCalendarQuery: reduceCalendarQuery(
         state.actualizedCalendarQuery,
         action,
       ),
       lifecycleState: reduceLifecycleState(state.lifecycleState, action),
       enabledApps: reduceEnabledApps(state.enabledApps, action),
       reportStore,
       nextLocalID: reduceNextLocalID(state.nextLocalID, action),
       dataLoaded: reduceDataLoaded(state.dataLoaded, action),
       userPolicies: policiesReducer(state.userPolicies, action),
       commServicesAccessToken: reduceServicesAccessToken(
         state.commServicesAccessToken,
         action,
       ),
       inviteLinksStore: reduceInviteLinks(state.inviteLinksStore, action),
       keyserverStore,
       threadActivityStore: reduceThreadActivity(
         state.threadActivityStore,
         action,
       ),
       integrityStore: reduceIntegrityStore(
         state.integrityStore,
         action,
         threadStore.threadInfos,
         threadStoreOperations,
       ),
       globalThemeInfo: reduceGlobalThemeInfo(state.globalThemeInfo, action),
       customServer: reduceCustomerServer(state.customServer, action),
     },
     storeOperations: {
       draftStoreOperations,
       threadStoreOperations,
       messageStoreOperations,
       reportStoreOperations,
       userStoreOperations,
       keyserverStoreOperations,
     },
   };
 }
diff --git a/lib/reducers/message-reducer.test.js b/lib/reducers/message-reducer.test.js
index 670f24266..0170fcb45 100644
--- a/lib/reducers/message-reducer.test.js
+++ b/lib/reducers/message-reducer.test.js
@@ -1,317 +1,318 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { reduceMessageStore } from './message-reducer.js';
 import { createPendingThread } from '../shared/thread-utils.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import type { MessageStore } from '../types/message-types.js';
 import { threadTypes } from '../types/thread-types-enum.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const messageStoreBeforeMediaUpdate: MessageStore = {
   messages: {
     local1: {
       type: 14,
       threadID: '91140',
       creatorID: '91097',
       time: 1639522317443,
       media: [
         {
           id: 'localUpload2',
           uri: 'assets-library://asset/asset.HEIC?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=HEIC',
           type: 'photo',
           dimensions: { height: 3024, width: 4032 },
           thumbHash: 'some_thumb_hash',
           localMediaSelection: {
             step: 'photo_library',
             dimensions: { height: 3024, width: 4032 },
             uri: 'assets-library://asset/asset.HEIC?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=HEIC',
             filename: 'IMG_0006.HEIC',
             mediaNativeID: 'CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001',
             selectTime: 1639522317349,
             sendTime: 1639522317349,
             retries: 0,
           },
         },
       ],
       localID: 'local1',
     },
   },
   threads: {
     '91140': {
       messageIDs: ['local1'],
       startReached: true,
     },
   },
   local: {},
   currentAsOf: { [ashoatKeyserverID]: 1639522292174 },
 };
 
 describe('UPDATE_MULTIMEDIA_MESSAGE_MEDIA', () => {
   const updateMultiMediaMessageMediaAction = {
     type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
     payload: {
       messageID: 'local1',
       currentMediaID: 'localUpload2',
       mediaUpdate: {
         id: '91172',
         type: 'photo',
         uri: 'http://localhost/comm/upload/91172/dfa9b9fe7eb03fde',
         dimensions: { height: 1440, width: 1920 },
         localMediaSelection: undefined,
       },
     },
   };
   const { messageStore: updatedMessageStore } = reduceMessageStore(
     messageStoreBeforeMediaUpdate,
     updateMultiMediaMessageMediaAction,
     {},
   );
 
   test('replace local media with uploaded media', () => {
     expect(
       updatedMessageStore.messages[
         updateMultiMediaMessageMediaAction.payload.messageID
       ],
     ).toStrictEqual({
       type: 14,
       threadID: '91140',
       creatorID: '91097',
       time: 1639522317443,
       media: [
         {
           id: '91172',
           type: 'photo',
           uri: 'http://localhost/comm/upload/91172/dfa9b9fe7eb03fde',
           dimensions: { height: 1440, width: 1920 },
           thumbHash: 'some_thumb_hash',
         },
       ],
       localID: 'local1',
     });
   });
 
   test('localMediaSelection is unset when undefined in update', () => {
     const msg =
       updatedMessageStore.messages[
         updateMultiMediaMessageMediaAction.payload.messageID
       ];
 
     expect(msg.type).toEqual(messageTypes.IMAGES);
     invariant(msg.type === messageTypes.IMAGES, 'message is of type IMAGES');
     expect(msg.media[0]).not.toHaveProperty('localMediaSelection');
   });
 
   test('localMediaSelection is unchanged when missing in update', () => {
     const actionWithoutLocalMediaSelectionUpdate = {
       type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       payload: {
         messageID: 'local1',
         currentMediaID: 'localUpload2',
         mediaUpdate: {
           id: '91172',
           type: 'photo',
           uri: 'http://localhost/comm/upload/91172/dfa9b9fe7eb03fde',
           dimensions: { height: 1440, width: 1920 },
         },
       },
     };
     const { messageStore: storeWithoutLocalMediaSelectionUpdate } =
       reduceMessageStore(
         messageStoreBeforeMediaUpdate,
         actionWithoutLocalMediaSelectionUpdate,
         {},
       );
     const prevMsg =
       messageStoreBeforeMediaUpdate.messages[
         actionWithoutLocalMediaSelectionUpdate.payload.messageID
       ];
     const updatedMsg =
       storeWithoutLocalMediaSelectionUpdate.messages[
         actionWithoutLocalMediaSelectionUpdate.payload.messageID
       ];
 
     expect(updatedMsg.type).toEqual(messageTypes.IMAGES);
     expect(prevMsg.type).toEqual(messageTypes.IMAGES);
     invariant(
       updatedMsg.type === messageTypes.IMAGES &&
         prevMsg.type === messageTypes.IMAGES,
       'message is of type IMAGES',
     );
 
     expect(updatedMsg.media[0].localMediaSelection).toStrictEqual(
       prevMsg.media[0].localMediaSelection,
     );
   });
 
   test('localMediaSelection is updated when included in update', () => {
     const updateMultiMediaMessageMediaActionWithReplacement = {
       type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       payload: {
         messageID: 'local1',
         currentMediaID: 'localUpload2',
         mediaUpdate: {
           id: '91172',
           type: 'photo',
           uri: 'http://localhost/comm/upload/91172/dfa9b9fe7eb03fde',
           dimensions: { height: 1440, width: 1920 },
           localMediaSelection: {
             step: 'photo_library',
             dimensions: { height: 10, width: 10 },
             uri: 'assets-library://asset/new/path',
             filename: 'NEWNAME.PNG',
             mediaNativeID: 'CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001',
             selectTime: 1639522317349,
             sendTime: 1639522317349,
             retries: 1,
           },
         },
       },
     };
     const { messageStore: updatedMessageStoreWithReplacement } =
       reduceMessageStore(
         messageStoreBeforeMediaUpdate,
         updateMultiMediaMessageMediaActionWithReplacement,
         {},
       );
     const updatedMsg =
       updatedMessageStoreWithReplacement.messages[
         updateMultiMediaMessageMediaActionWithReplacement.payload.messageID
       ];
     expect(updatedMsg.type).toEqual(messageTypes.IMAGES);
     invariant(
       updatedMsg.type === messageTypes.IMAGES,
       'message is of type IMAGES',
     );
 
     expect(updatedMsg.media[0].localMediaSelection).toStrictEqual({
       step: 'photo_library',
       dimensions: { height: 10, width: 10 },
       uri: 'assets-library://asset/new/path',
       filename: 'NEWNAME.PNG',
       mediaNativeID: 'CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001',
       selectTime: 1639522317349,
       sendTime: 1639522317349,
       retries: 1,
     });
   });
 });
 
 describe('SET_MESSAGE_STORE_MESSAGES', () => {
   const clientDBMessages = [
     {
       id: '103502',
       local_id: null,
       thread: '88471',
       user: '83809',
       type: '14',
       future_type: null,
       content: '[103501]',
       time: '1658168455316',
       media_infos: [
         {
           id: '103501',
           uri: 'http://localhost/comm/upload/103501/425db25471f3acd5',
           type: 'photo',
           extras: '{"dimensions":{"width":1920,"height":1440},"loop":false}',
         },
       ],
     },
     {
       id: 'local10',
       local_id: 'local10',
       thread: '88471',
       user: '83809',
       type: '14',
       future_type: null,
       content: '[null]',
       time: '1658172650495',
       media_infos: [
         {
           id: 'localUpload0',
           uri: 'assets-library://asset/asset.heic?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=heic',
           type: 'photo',
           extras:
             '{"dimensions":{"height":3024,"width":4032},"loop":false,"local_media_selection":{"step":"photo_library","dimensions":{"height":3024,"width":4032},"uri":"assets-library://asset/asset.heic?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=heic","filename":"IMG_0006.HEIC","mediaNativeID":"CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001","selectTime":1658172650370,"sendTime":1658172650370,"retries":0}}',
         },
       ],
     },
     {
       id: 'local11',
       local_id: 'local11',
       thread: '88471',
       user: '83809',
       type: '14',
       future_type: null,
       content: '[null,null]',
       time: '1658172656976',
       media_infos: [
         {
           id: 'localUpload2',
           uri: 'assets-library://asset/asset.heic?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=heic',
           type: 'photo',
           extras:
             '{"dimensions":{"height":3024,"width":4032},"loop":false,"local_media_selection":{"step":"photo_library","dimensions":{"height":3024,"width":4032},"uri":"assets-library://asset/asset.heic?id=CC95F08C-88C3-4012-9D6D-64A413D254B3&ext=heic","filename":"IMG_0006.HEIC","mediaNativeID":"CC95F08C-88C3-4012-9D6D-64A413D254B3/L0/001","selectTime":1658172656826,"sendTime":1658172656826,"retries":0}}',
         },
         {
           id: 'localUpload4',
           uri: 'assets-library://asset/asset.jpg?id=ED7AC36B-A150-4C38-BB8C-B6D696F4F2ED&ext=jpg',
           type: 'photo',
           extras:
             '{"dimensions":{"height":2002,"width":3000},"loop":false,"local_media_selection":{"step":"photo_library","dimensions":{"height":2002,"width":3000},"uri":"assets-library://asset/asset.jpg?id=ED7AC36B-A150-4C38-BB8C-B6D696F4F2ED&ext=jpg","filename":"IMG_0005.JPG","mediaNativeID":"ED7AC36B-A150-4C38-BB8C-B6D696F4F2ED/L0/001","selectTime":1658172656826,"sendTime":1658172656826,"retries":0}}',
         },
       ],
     },
   ];
 
   const clientDBThreads = [
     {
       id: '88471',
       start_reached: '0',
     },
   ];
 
   const { messageStore: updatedMessageStore } = reduceMessageStore(
     {
       messages: {},
       threads: {},
       local: {},
       currentAsOf: { [ashoatKeyserverID]: 1234567890123 },
     },
     {
       type: 'SET_CLIENT_DB_STORE',
       payload: {
         currentUserID: '',
         drafts: [],
         threadStore: {
           threadInfos: {},
         },
         messageStoreThreads: clientDBThreads,
         messages: clientDBMessages,
         reports: [],
         users: {},
+        keyserverInfos: {},
       },
     },
     {
       [88471]: createPendingThread({
         viewerID: '',
         threadType: threadTypes.LOCAL,
         members: [{ id: '', username: '' }],
       }),
     },
   );
   test('removes local media when constructing messageStore.messages', () => {
     expect(updatedMessageStore.messages).toHaveProperty('103502');
     expect(updatedMessageStore.messages).not.toHaveProperty('local10');
     expect(updatedMessageStore.messages).not.toHaveProperty('local11');
   });
 
   test('removes local media when constructing messageStore.threads', () => {
     expect(updatedMessageStore).toBeDefined();
     expect(updatedMessageStore.threads).toBeDefined();
     expect(updatedMessageStore.threads['88471']).toBeDefined();
     expect(updatedMessageStore.threads['88471'].messageIDs).toBeDefined();
     expect(updatedMessageStore.threads['88471'].messageIDs).toEqual(['103502']);
   });
 });
diff --git a/lib/types/store-ops-types.js b/lib/types/store-ops-types.js
index b248a6713..1d2f47497 100644
--- a/lib/types/store-ops-types.js
+++ b/lib/types/store-ops-types.js
@@ -1,73 +1,75 @@
 // @flow
 
 import type {
   DraftStoreOperation,
   ClientDBDraftStoreOperation,
   ClientDBDraftInfo,
 } from './draft-types.js';
+import type { KeyserverInfos } from './keyserver-types.js';
 import type {
   ClientDBMessageInfo,
   ClientDBThreadMessageInfo,
 } from './message-types.js';
 import type { ClientReportCreationRequest } from './report-types.js';
 import type { ClientDBThreadInfo, ThreadStore } from './thread-types.js';
 import type { UserInfos } from './user-types.js';
 import type {
   ClientDBKeyserverInfo,
   ClientDBKeyserverStoreOperation,
   KeyserverStoreOperation,
 } from '../ops/keyserver-store-ops.js';
 import type {
   ClientDBMessageStoreOperation,
   MessageStoreOperation,
 } from '../ops/message-store-ops.js';
 import type {
   ReportStoreOperation,
   ClientDBReport,
   ClientDBReportStoreOperation,
 } from '../ops/report-store-ops.js';
 import type {
   ClientDBThreadStoreOperation,
   ThreadStoreOperation,
 } from '../ops/thread-store-ops.js';
 import type {
   UserStoreOperation,
   ClientDBUserInfo,
 } from '../ops/user-store-ops.js';
 
 export type StoreOperations = {
   +draftStoreOperations: $ReadOnlyArray<DraftStoreOperation>,
   +threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +reportStoreOperations: $ReadOnlyArray<ReportStoreOperation>,
   +userStoreOperations: $ReadOnlyArray<UserStoreOperation>,
   +keyserverStoreOperations: $ReadOnlyArray<KeyserverStoreOperation>,
 };
 
 export type ClientDBStoreOperations = {
   +draftStoreOperations?: $ReadOnlyArray<ClientDBDraftStoreOperation>,
   +threadStoreOperations?: $ReadOnlyArray<ClientDBThreadStoreOperation>,
   +messageStoreOperations?: $ReadOnlyArray<ClientDBMessageStoreOperation>,
   +reportStoreOperations?: $ReadOnlyArray<ClientDBReportStoreOperation>,
   +keyserverStoreOperations?: $ReadOnlyArray<ClientDBKeyserverStoreOperation>,
 };
 
 export type ClientDBStore = {
   +messages: $ReadOnlyArray<ClientDBMessageInfo>,
   +drafts: $ReadOnlyArray<ClientDBDraftInfo>,
   +threads: $ReadOnlyArray<ClientDBThreadInfo>,
   +messageStoreThreads: $ReadOnlyArray<ClientDBThreadMessageInfo>,
   +reports: $ReadOnlyArray<ClientDBReport>,
   +users: $ReadOnlyArray<ClientDBUserInfo>,
   +keyservers: $ReadOnlyArray<ClientDBKeyserverInfo>,
 };
 
 export type ClientStore = {
   +currentUserID: ?string,
   +drafts: $ReadOnlyArray<ClientDBDraftInfo>,
   +messages: ?$ReadOnlyArray<ClientDBMessageInfo>,
   +threadStore: ?ThreadStore,
   +messageStoreThreads: ?$ReadOnlyArray<ClientDBThreadMessageInfo>,
   +reports: ?$ReadOnlyArray<ClientReportCreationRequest>,
   +users: ?UserInfos,
+  +keyserverInfos: ?KeyserverInfos,
 };
diff --git a/native/data/sqlite-data-handler.js b/native/data/sqlite-data-handler.js
index d71258c08..9ea7f2ad8 100644
--- a/native/data/sqlite-data-handler.js
+++ b/native/data/sqlite-data-handler.js
@@ -1,235 +1,240 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
 import { useStaffContext } from 'lib/components/staff-provider.react.js';
 import { resolveKeyserverSessionInvalidation } from 'lib/keyserver-conn/recovery-utils.js';
+import { keyserverStoreOpsHandlers } from 'lib/ops/keyserver-store-ops.js';
 import { reportStoreOpsHandlers } from 'lib/ops/report-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { userStoreOpsHandlers } from 'lib/ops/user-store-ops.js';
 import {
   cookieSelector,
   urlPrefixSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { useInitialNotificationsEncryptedMessage } from 'lib/shared/crypto-utils.js';
 import {
   logInActionSources,
   type LogInActionSource,
 } from 'lib/types/account-types.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import { filesystemMediaCache } from '../media/media-cache.js';
 import { commCoreModule } from '../native-modules.js';
 import { setStoreLoadedActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import Alert from '../utils/alert.js';
 import { nativeNotificationsSessionCreator } from '../utils/crypto-utils.js';
 import { isTaskCancelledError } from '../utils/error-handling.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 async function clearSensitiveData() {
   await commCoreModule.clearSensitiveData();
   try {
     await filesystemMediaCache.clearCache();
   } catch {
     throw new Error('clear_media_cache_failed');
   }
 }
 
 function SQLiteDataHandler(): React.Node {
   const storeLoaded = useSelector(state => state.storeLoaded);
 
   const dispatch = useDispatch();
   const rehydrateConcluded = useSelector(
     state => !!(state._persist && state._persist.rehydrated),
   );
   const cookie = useSelector(cookieSelector(ashoatKeyserverID));
   const urlPrefix = useSelector(urlPrefixSelector(ashoatKeyserverID));
   invariant(urlPrefix, "missing urlPrefix for ashoat's keyserver");
   const staffCanSee = useStaffCanSee();
   const { staffUserHasBeenLoggedIn } = useStaffContext();
   const loggedIn = useSelector(isLoggedIn);
   const currentLoggedInUserID = useSelector(state =>
     state.currentUserInfo?.anonymous ? undefined : state.currentUserInfo?.id,
   );
   const mediaCacheContext = React.useContext(MediaCacheContext);
   const getInitialNotificationsEncryptedMessage =
     useInitialNotificationsEncryptedMessage(nativeNotificationsSessionCreator);
 
   const callFetchNewCookieFromNativeCredentials = React.useCallback(
     async (source: LogInActionSource) => {
       try {
         await resolveKeyserverSessionInvalidation(
           dispatch,
           cookie,
           urlPrefix,
           source,
           ashoatKeyserverID,
           getInitialNotificationsEncryptedMessage,
         );
         dispatch({ type: setStoreLoadedActionType });
       } catch (fetchCookieException) {
         if (staffCanSee) {
           Alert.alert(
             `Error fetching new cookie from native credentials: ${
               getMessageForException(fetchCookieException) ??
               '{no exception message}'
             }. Please kill the app.`,
           );
         } else {
           commCoreModule.terminate();
         }
       }
     },
     [
       cookie,
       dispatch,
       staffCanSee,
       urlPrefix,
       getInitialNotificationsEncryptedMessage,
     ],
   );
 
   const callClearSensitiveData = React.useCallback(
     async (triggeredBy: string) => {
       await clearSensitiveData();
       console.log(`SQLite database deletion was triggered by ${triggeredBy}`);
     },
     [],
   );
 
   const handleSensitiveData = React.useCallback(async () => {
     try {
       const databaseCurrentUserInfoID = await commCoreModule.getCurrentUserID();
       if (
         databaseCurrentUserInfoID &&
         databaseCurrentUserInfoID !== currentLoggedInUserID
       ) {
         await callClearSensitiveData('change in logged-in user credentials');
       }
       if (currentLoggedInUserID) {
         await commCoreModule.setCurrentUserID(currentLoggedInUserID);
       }
     } catch (e) {
       if (isTaskCancelledError(e)) {
         return;
       }
       if (__DEV__) {
         throw e;
       }
       console.log(e);
       if (e.message !== 'clear_media_cache_failed') {
         commCoreModule.terminate();
       }
     }
   }, [callClearSensitiveData, currentLoggedInUserID]);
 
   React.useEffect(() => {
     if (!rehydrateConcluded) {
       return;
     }
 
     const databaseNeedsDeletion = commCoreModule.checkIfDatabaseNeedsDeletion();
     if (databaseNeedsDeletion) {
       void (async () => {
         try {
           await callClearSensitiveData('detecting corrupted database');
         } catch (e) {
           if (__DEV__) {
             throw e;
           }
           console.log(e);
           if (e.message !== 'clear_media_cache_failed') {
             commCoreModule.terminate();
           }
         }
         await callFetchNewCookieFromNativeCredentials(
           logInActionSources.corruptedDatabaseDeletion,
         );
       })();
       return;
     }
 
     const sensitiveDataHandled = handleSensitiveData();
     if (storeLoaded) {
       return;
     }
     if (!loggedIn) {
       dispatch({ type: setStoreLoadedActionType });
       return;
     }
     void (async () => {
       await Promise.all([
         sensitiveDataHandled,
         mediaCacheContext?.evictCache(),
       ]);
       try {
         const {
           threads,
           messages,
           drafts,
           messageStoreThreads,
           reports,
           users,
+          keyservers,
         } = await commCoreModule.getClientDBStore();
         const threadInfosFromDB =
           threadStoreOpsHandlers.translateClientDBData(threads);
-        const reportsFromDb =
+        const reportsFromDB =
           reportStoreOpsHandlers.translateClientDBData(reports);
-        const usersFromDb = userStoreOpsHandlers.translateClientDBData(users);
+        const usersFromDB = userStoreOpsHandlers.translateClientDBData(users);
+        const keyserverInfosFromDB =
+          keyserverStoreOpsHandlers.translateClientDBData(keyservers);
 
         dispatch({
           type: setClientDBStoreActionType,
           payload: {
             drafts,
             messages,
             threadStore: { threadInfos: threadInfosFromDB },
             currentUserID: currentLoggedInUserID,
             messageStoreThreads,
-            reports: reportsFromDb,
-            users: usersFromDb,
+            reports: reportsFromDB,
+            users: usersFromDB,
+            keyserverInfos: keyserverInfosFromDB,
           },
         });
       } catch (setStoreException) {
         if (isTaskCancelledError(setStoreException)) {
           dispatch({ type: setStoreLoadedActionType });
           return;
         }
         if (staffCanSee) {
           Alert.alert(
             'Error setting threadStore or messageStore',
             getMessageForException(setStoreException) ??
               '{no exception message}',
           );
         }
         await callFetchNewCookieFromNativeCredentials(
           logInActionSources.sqliteLoadFailure,
         );
       }
     })();
   }, [
     currentLoggedInUserID,
     handleSensitiveData,
     loggedIn,
     cookie,
     dispatch,
     rehydrateConcluded,
     staffCanSee,
     storeLoaded,
     urlPrefix,
     staffUserHasBeenLoggedIn,
     callFetchNewCookieFromNativeCredentials,
     callClearSensitiveData,
     mediaCacheContext,
   ]);
 
   return null;
 }
 
 export { SQLiteDataHandler, clearSensitiveData };
diff --git a/web/database/utils/store.js b/web/database/utils/store.js
index 7450fb2ac..8e8213673 100644
--- a/web/database/utils/store.js
+++ b/web/database/utils/store.js
@@ -1,111 +1,120 @@
 // @flow
 
 import { keyserverStoreOpsHandlers } from 'lib/ops/keyserver-store-ops.js';
 import { reportStoreOpsHandlers } from 'lib/ops/report-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { canUseDatabaseOnWeb } from 'lib/shared/web-database.js';
 import type {
   ClientStore,
   StoreOperations,
 } from 'lib/types/store-ops-types.js';
 
 import { workerRequestMessageTypes } from '../../types/worker-types.js';
 import { getDatabaseModule } from '../database-module-provider.js';
 
 async function getClientDBStore(): Promise<ClientStore> {
   const databaseModule = await getDatabaseModule();
   let result: ClientStore = {
     currentUserID: null,
     drafts: [],
     messages: null,
     threadStore: null,
     messageStoreThreads: null,
     reports: null,
     users: null,
+    keyserverInfos: null,
   };
   const data = await databaseModule.schedule({
     type: workerRequestMessageTypes.GET_CLIENT_STORE,
   });
   if (data?.store?.drafts) {
     result = {
       ...result,
       drafts: data.store.drafts,
     };
   }
   if (data?.store?.reports) {
     result = {
       ...result,
       reports: reportStoreOpsHandlers.translateClientDBData(data.store.reports),
     };
   }
   if (data?.store?.threads && data.store.threads.length > 0) {
     result = {
       ...result,
       threadStore: {
         threadInfos: threadStoreOpsHandlers.translateClientDBData(
           data.store.threads,
         ),
       },
     };
   }
+  if (data?.store?.keyservers) {
+    result = {
+      ...result,
+      keyserverInfos: keyserverStoreOpsHandlers.translateClientDBData(
+        data.store.keyservers,
+      ),
+    };
+  }
   return result;
 }
 
 async function processDBStoreOperations(
   storeOperations: StoreOperations,
   userID: null | string,
 ): Promise<void> {
   const {
     draftStoreOperations,
     threadStoreOperations,
     reportStoreOperations,
     keyserverStoreOperations,
   } = storeOperations;
 
   const canUseDatabase = canUseDatabaseOnWeb(userID);
 
   const convertedThreadStoreOperations = canUseDatabase
     ? threadStoreOpsHandlers.convertOpsToClientDBOps(threadStoreOperations)
     : [];
   const convertedReportStoreOperations =
     reportStoreOpsHandlers.convertOpsToClientDBOps(reportStoreOperations);
   const convertedKeyserverStoreOperations =
     keyserverStoreOpsHandlers.convertOpsToClientDBOps(keyserverStoreOperations);
 
   if (
     convertedThreadStoreOperations.length === 0 &&
     convertedReportStoreOperations.length === 0 &&
     draftStoreOperations.length === 0 &&
     convertedKeyserverStoreOperations.length === 0
   ) {
     return;
   }
 
   const databaseModule = await getDatabaseModule();
   const isSupported = await databaseModule.isDatabaseSupported();
   if (!isSupported) {
     return;
   }
   try {
     await databaseModule.schedule({
       type: workerRequestMessageTypes.PROCESS_STORE_OPERATIONS,
       storeOperations: {
         draftStoreOperations,
         reportStoreOperations: convertedReportStoreOperations,
         threadStoreOperations: convertedThreadStoreOperations,
         keyserverStoreOperations: convertedKeyserverStoreOperations,
       },
     });
   } catch (e) {
     console.log(e);
     if (canUseDatabase) {
       window.alert(e.message);
       if (threadStoreOperations.length > 0) {
         await databaseModule.init({ clearDatabase: true });
         location.reload();
       }
     }
   }
 }
 
 export { getClientDBStore, processDBStoreOperations };