diff --git a/keyserver/src/responders/website-responders.js b/keyserver/src/responders/website-responders.js
index c20d10d07..26c56d89d 100644
--- a/keyserver/src/responders/website-responders.js
+++ b/keyserver/src/responders/website-responders.js
@@ -1,837 +1,837 @@
 // @flow
 
 import html from 'common-tags/lib/html/index.js';
 import { detect as detectBrowser } from 'detect-browser';
 import type { $Response, $Request } from 'express';
 import fs from 'fs';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import * as React from 'react';
 // eslint-disable-next-line import/extensions
 import ReactDOMServer from 'react-dom/server';
 import t from 'tcomb';
 import { promisify } from 'util';
 
 import { inviteLinkUrl } from 'lib/facts/links.js';
 import { baseLegalPolicies } from 'lib/facts/policies.js';
 import stores from 'lib/facts/stores.js';
 import { daysToEntriesFromEntryInfos } from 'lib/reducers/entry-reducer.js';
 import { freshMessageStore } from 'lib/reducers/message-reducer.js';
 import { mostRecentlyReadThread } from 'lib/selectors/thread-selectors.js';
 import { mostRecentMessageTimestamp } from 'lib/shared/message-utils.js';
 import {
   threadHasPermission,
   threadIsPending,
   parsePendingThreadID,
   createPendingThread,
 } from 'lib/shared/thread-utils.js';
 import { defaultWebEnabledApps } from 'lib/types/enabled-apps.js';
 import { entryStoreValidator } from 'lib/types/entry-types.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
 import { keyserverStoreValidator } from 'lib/types/keyserver-types.js';
 import { inviteLinksStoreValidator } from 'lib/types/link-types.js';
 import {
   defaultNumberPerThread,
   messageStoreValidator,
 } from 'lib/types/message-types.js';
 import { defaultEnabledReports } from 'lib/types/report-types.js';
 import { defaultConnectionInfo } from 'lib/types/socket-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { threadStoreValidator } from 'lib/types/thread-types.js';
 import {
   currentUserInfoValidator,
   userInfosValidator,
 } from 'lib/types/user-types.js';
 import { currentDateInTimeZone } from 'lib/utils/date-utils.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import { infoFromURL } from 'lib/utils/url-utils.js';
 import {
   tBool,
   tNumber,
   tShape,
   tString,
   ashoatKeyserverID,
 } from 'lib/utils/validation-utils.js';
 import getTitle from 'web/title/getTitle.js';
 import { navInfoValidator } from 'web/types/nav-types.js';
 import { navInfoFromURL } from 'web/url-utils.js';
 
 import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
 import { fetchPrimaryInviteLinks } from '../fetchers/link-fetchers.js';
 import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
 import { hasAnyNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
 import {
   fetchCurrentUserInfo,
   fetchKnownUserInfos,
   fetchUserInfos,
 } from '../fetchers/user-fetchers.js';
 import { getWebPushConfig } from '../push/providers.js';
 import { setNewSession } from '../session/cookies.js';
 import { Viewer } from '../session/viewer.js';
 import { streamJSON, waitForStream } from '../utils/json-stream.js';
 import {
   getAppURLFactsFromRequestURL,
   getCommAppURLFacts,
 } from '../utils/urls.js';
 import { validateOutput } from '../utils/validation-utils.js';
 
 const { renderToNodeStream } = ReactDOMServer;
 
 const access = promisify(fs.access);
 const readFile = promisify(fs.readFile);
 
 const googleFontsURL =
   'https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600&display=swap';
 const localFontsURL = 'fonts/local-fonts.css';
 async function getFontsURL() {
   try {
     await access(localFontsURL);
     return localFontsURL;
   } catch {
     return googleFontsURL;
   }
 }
 
 type AssetInfo = {
   +jsURL: string,
   +fontsURL: string,
   +cssInclude: string,
   +olmFilename: string,
   +commQueryExecutorFilename: string,
   +opaqueURL: string,
 };
 let assetInfo: ?AssetInfo = null;
 async function getAssetInfo() {
   if (assetInfo) {
     return assetInfo;
   }
   if (process.env.NODE_ENV === 'development') {
     const fontsURL = await getFontsURL();
     assetInfo = {
       jsURL: 'http://localhost:8080/dev.build.js',
       fontsURL,
       cssInclude: '',
       olmFilename: '',
       commQueryExecutorFilename: '',
       opaqueURL: 'http://localhost:8080/opaque-ke.wasm',
     };
     return assetInfo;
   }
   try {
     const manifestString = await readFile('../web/dist/manifest.json', 'utf8');
     const manifest = JSON.parse(manifestString);
     const webworkersManifestString = await readFile(
       '../web/dist/webworkers/manifest.json',
       'utf8',
     );
     const webworkersManifest = JSON.parse(webworkersManifestString);
     assetInfo = {
       jsURL: `compiled/${manifest['browser.js']}`,
       fontsURL: googleFontsURL,
       cssInclude: html`
         <link
           rel="stylesheet"
           type="text/css"
           href="compiled/${manifest['browser.css']}"
         />
       `,
       olmFilename: manifest['olm.wasm'],
       commQueryExecutorFilename: webworkersManifest['comm_query_executor.wasm'],
       opaqueURL: `compiled/${manifest['comm_opaque2_wasm_bg.wasm']}`,
     };
     return assetInfo;
   } catch {
     throw new Error(
       'Could not load manifest.json for web build. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 let webpackCompiledRootComponent: ?React.ComponentType<{}> = null;
 async function getWebpackCompiledRootComponentForSSR() {
   if (webpackCompiledRootComponent) {
     return webpackCompiledRootComponent;
   }
   try {
     // $FlowFixMe web/dist doesn't always exist
     const webpackBuild = await import('web/dist/app.build.cjs');
     webpackCompiledRootComponent = webpackBuild.app.default;
     return webpackCompiledRootComponent;
   } catch {
     throw new Error(
       'Could not load app.build.cjs. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 const initialReduxStateValidator = tShape({
   navInfo: navInfoValidator,
   deviceID: t.Nil,
   currentUserInfo: currentUserInfoValidator,
   draftStore: t.irreducible('default draftStore', _isEqual({ drafts: {} })),
   sessionID: t.maybe(t.String),
   entryStore: entryStoreValidator,
   threadStore: threadStoreValidator,
   userStore: tShape({
     userInfos: userInfosValidator,
     inconsistencyReports: t.irreducible(
       'default inconsistencyReports',
       _isEqual([]),
     ),
   }),
   messageStore: messageStoreValidator,
   loadingStatuses: t.irreducible('default loadingStatuses', _isEqual({})),
   calendarFilters: t.irreducible(
     'defaultCalendarFilters',
     _isEqual(defaultCalendarFilters),
   ),
   communityPickerStore: t.irreducible(
     'default communityPickerStore',
     _isEqual({ chat: null, calendar: null }),
   ),
   urlPrefix: t.String,
   windowDimensions: t.irreducible(
     'default windowDimensions',
     _isEqual({ width: 0, height: 0 }),
   ),
   notifPermissionAlertInfo: t.irreducible(
     'default notifPermissionAlertInfo',
     _isEqual(defaultNotifPermissionAlertInfo),
   ),
   connection: tShape({
     status: tString('connecting'),
     queuedActivityUpdates: t.irreducible(
       'default queuedActivityUpdates',
       _isEqual([]),
     ),
     actualizedCalendarQuery: tShape({
       startDate: t.String,
       endDate: t.String,
       filters: t.irreducible(
         'default filters',
         _isEqual(defaultCalendarFilters),
       ),
     }),
     lateResponses: t.irreducible('default lateResponses', _isEqual([])),
     showDisconnectedBar: tBool(false),
   }),
   watchedThreadIDs: t.irreducible('default watchedThreadIDs', _isEqual([])),
   lifecycleState: tString('active'),
   enabledApps: t.irreducible(
     'defaultWebEnabledApps',
     _isEqual(defaultWebEnabledApps),
   ),
   reportStore: t.irreducible(
     'default reportStore',
     _isEqual({
       enabledReports: defaultEnabledReports,
       queuedReports: [],
     }),
   ),
   nextLocalID: tNumber(0),
   deviceToken: t.Nil,
   dataLoaded: t.Boolean,
   windowActive: tBool(true),
   userPolicies: t.irreducible('default userPolicies', _isEqual({})),
   cryptoStore: t.irreducible(
     'default cryptoStore',
     _isEqual({
       primaryIdentityKeys: null,
       notificationIdentityKeys: null,
     }),
   ),
   pushApiPublicKey: t.maybe(t.String),
   _persist: t.Nil,
   commServicesAccessToken: t.Nil,
   inviteLinksStore: inviteLinksStoreValidator,
   lastCommunicatedPlatformDetails: t.irreducible(
     'default lastCommunicatedPlatformDetails',
     _isEqual({}),
   ),
   keyserverStore: keyserverStoreValidator,
 });
 
 async function websiteResponder(
   viewer: Viewer,
   req: $Request,
   res: $Response,
 ): Promise<void> {
   const appURLFacts = getAppURLFactsFromRequestURL(req.originalUrl);
   const { basePath, baseDomain } = appURLFacts;
   const baseURL = basePath.replace(/\/$/, '');
   const urlPrefix = baseDomain + baseURL;
 
   const loadingPromise = getWebpackCompiledRootComponentForSSR();
   const hasNotAcknowledgedPoliciesPromise = hasAnyNotAcknowledgedPolicies(
     viewer.id,
     baseLegalPolicies,
   );
 
   const initialNavInfoPromise = (async () => {
     try {
       const urlInfo = infoFromURL(req.url);
 
       let backupInfo = {
         now: currentDateInTimeZone(viewer.timeZone),
       };
       // Some user ids in selectedUserList might not exist in the userStore
       // (e.g. they were included in the results of the user search endpoint)
       // Because of that we keep their userInfos inside the navInfo.
       if (urlInfo.selectedUserList) {
         const fetchedUserInfos = await fetchUserInfos(urlInfo.selectedUserList);
         const userInfos = {};
         for (const userID in fetchedUserInfos) {
           const userInfo = fetchedUserInfos[userID];
           if (userInfo.username) {
             userInfos[userID] = userInfo;
           }
         }
         backupInfo = { userInfos, ...backupInfo };
       }
       return navInfoFromURL(urlInfo, backupInfo);
     } catch (e) {
       throw new ServerError(e.message);
     }
   })();
 
   const calendarQueryPromise = (async () => {
     const initialNavInfo = await initialNavInfoPromise;
     return {
       startDate: initialNavInfo.startDate,
       endDate: initialNavInfo.endDate,
       filters: defaultCalendarFilters,
     };
   })();
   const messageSelectionCriteria = { joinedThreads: true };
   const initialTime = Date.now();
 
   const assetInfoPromise = getAssetInfo();
   const threadInfoPromise = fetchThreadInfos(viewer);
   const messageInfoPromise = fetchMessageInfos(
     viewer,
     messageSelectionCriteria,
     defaultNumberPerThread,
   );
   const entryInfoPromise = (async () => {
     const calendarQuery = await calendarQueryPromise;
     return await fetchEntryInfos(viewer, [calendarQuery]);
   })();
   const currentUserInfoPromise = fetchCurrentUserInfo(viewer);
   const userInfoPromise = fetchKnownUserInfos(viewer);
 
   const sessionIDPromise = (async () => {
     const calendarQuery = await calendarQueryPromise;
     if (viewer.loggedIn) {
       await setNewSession(viewer, calendarQuery, initialTime);
     }
     return viewer.sessionID;
   })();
 
   const threadStorePromise = (async () => {
     const [{ threadInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
       threadInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     return { threadInfos: hasNotAcknowledgedPolicies ? {} : threadInfos };
   })();
   const messageStorePromise = (async () => {
     const [
       { threadInfos },
       { rawMessageInfos, truncationStatuses },
       hasNotAcknowledgedPolicies,
     ] = await Promise.all([
       threadInfoPromise,
       messageInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     if (hasNotAcknowledgedPolicies) {
       return {
         messages: {},
         threads: {},
         local: {},
-        currentAsOf: 0,
+        currentAsOf: { [ashoatKeyserverID]: 0 },
       };
     }
     const { messageStore: freshStore } = freshMessageStore(
       rawMessageInfos,
       truncationStatuses,
       mostRecentMessageTimestamp(rawMessageInfos, initialTime),
       threadInfos,
     );
     return freshStore;
   })();
   const entryStorePromise = (async () => {
     const [{ rawEntryInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
       entryInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     if (hasNotAcknowledgedPolicies) {
       return {
         entryInfos: {},
         daysToEntries: {},
         lastUserInteractionCalendar: 0,
       };
     }
     return {
       entryInfos: _keyBy('id')(rawEntryInfos),
       daysToEntries: daysToEntriesFromEntryInfos(rawEntryInfos),
       lastUserInteractionCalendar: initialTime,
     };
   })();
   const userStorePromise = (async () => {
     const [userInfos, hasNotAcknowledgedPolicies] = await Promise.all([
       userInfoPromise,
       hasNotAcknowledgedPoliciesPromise,
     ]);
     return {
       userInfos: hasNotAcknowledgedPolicies ? {} : userInfos,
       inconsistencyReports: [],
     };
   })();
 
   const navInfoPromise = (async () => {
     const [
       { threadInfos },
       messageStore,
       currentUserInfo,
       userStore,
       finalNavInfo,
     ] = await Promise.all([
       threadInfoPromise,
       messageStorePromise,
       currentUserInfoPromise,
       userStorePromise,
       initialNavInfoPromise,
     ]);
 
     const requestedActiveChatThreadID = finalNavInfo.activeChatThreadID;
     if (
       requestedActiveChatThreadID &&
       !threadIsPending(requestedActiveChatThreadID) &&
       !threadHasPermission(
         threadInfos[requestedActiveChatThreadID],
         threadPermissions.VISIBLE,
       )
     ) {
       finalNavInfo.activeChatThreadID = null;
     }
 
     if (!finalNavInfo.activeChatThreadID) {
       const mostRecentThread = mostRecentlyReadThread(
         messageStore,
         threadInfos,
       );
       if (mostRecentThread) {
         finalNavInfo.activeChatThreadID = mostRecentThread;
       }
     }
 
     if (
       finalNavInfo.activeChatThreadID &&
       threadIsPending(finalNavInfo.activeChatThreadID) &&
       finalNavInfo.pendingThread?.id !== finalNavInfo.activeChatThreadID
     ) {
       const pendingThreadData = parsePendingThreadID(
         finalNavInfo.activeChatThreadID,
       );
       if (
         pendingThreadData &&
         pendingThreadData.threadType !== threadTypes.SIDEBAR &&
         currentUserInfo.id
       ) {
         const { userInfos } = userStore;
         const members = [...pendingThreadData.memberIDs, currentUserInfo.id]
           .map(id => {
             const userInfo = userInfos[id];
             if (!userInfo || !userInfo.username) {
               return undefined;
             }
             const { username } = userInfo;
             return { id, username };
           })
           .filter(Boolean);
         const newPendingThread = createPendingThread({
           viewerID: currentUserInfo.id,
           threadType: pendingThreadData.threadType,
           members,
         });
         finalNavInfo.activeChatThreadID = newPendingThread.id;
         finalNavInfo.pendingThread = newPendingThread;
       }
     }
 
     return finalNavInfo;
   })();
   const currentAsOfPromise = (async () => {
     const hasNotAcknowledgedPolicies = await hasNotAcknowledgedPoliciesPromise;
     return hasNotAcknowledgedPolicies ? 0 : initialTime;
   })();
 
   const pushApiPublicKeyPromise = (async () => {
     const pushConfig = await getWebPushConfig();
     if (!pushConfig) {
       if (process.env.NODE_ENV !== 'development') {
         console.warn('keyserver/secrets/web_push_config.json should exist');
       }
       return null;
     }
     return pushConfig.publicKey;
   })();
 
   const inviteLinksStorePromise = (async () => {
     const primaryInviteLinks = await fetchPrimaryInviteLinks(viewer);
     const links = {};
     for (const link of primaryInviteLinks) {
       if (link.primary) {
         links[link.communityID] = {
           primaryLink: link,
         };
       }
     }
     return {
       links,
     };
   })();
 
   const keyserverStorePromise = (async () => {
     const { sessionID, updatesCurrentAsOf } = await promiseAll({
       sessionID: sessionIDPromise,
       updatesCurrentAsOf: currentAsOfPromise,
     });
 
     return {
       keyserverInfos: {
         [ashoatKeyserverID]: {
           cookie: undefined,
           sessionID,
           updatesCurrentAsOf,
         },
       },
     };
   })();
 
   const {
     jsURL,
     fontsURL,
     cssInclude,
     olmFilename,
     opaqueURL,
     commQueryExecutorFilename,
   } = await assetInfoPromise;
 
   // prettier-ignore
   res.write(html`
     <!DOCTYPE html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>${getTitle(0)}</title>
         <base href="${basePath}" />
         <link rel="stylesheet" type="text/css" href="${fontsURL}" />
         ${cssInclude}
         <link
           rel="apple-touch-icon"
           sizes="180x180"
           href="apple-touch-icon.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="32x32"
           href="favicon-32x32.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="16x16"
           href="favicon-16x16.png"
         />
         <link rel="manifest" href="site.webmanifest" />
         <meta name="apple-mobile-web-app-title" content="Comm" />
         <meta name="application-name" content="Comm" />
         <meta name="msapplication-TileColor" content="#b91d47" />
         <meta name="theme-color" content="#b91d47" />
       </head>
       <body>
         <div id="react-root">
   `);
 
   const Loading = await loadingPromise;
   const reactStream = renderToNodeStream(<Loading />);
   reactStream.pipe(res, { end: false });
 
   await waitForStream(reactStream);
   res.write(html`
     </div>
     <script>
       var preloadedState =
   `);
 
   const initialReduxState = await promiseAll({
     navInfo: navInfoPromise,
     deviceID: null,
     currentUserInfo: currentUserInfoPromise,
     draftStore: { drafts: {} },
     sessionID: sessionIDPromise,
     entryStore: entryStorePromise,
     threadStore: threadStorePromise,
     userStore: userStorePromise,
     messageStore: messageStorePromise,
     loadingStatuses: {},
     calendarFilters: defaultCalendarFilters,
     communityPickerStore: { chat: null, calendar: null },
     urlPrefix,
     windowDimensions: { width: 0, height: 0 },
     notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
     connection: (async () => ({
       ...defaultConnectionInfo(viewer.platform ?? 'web', viewer.timeZone),
       actualizedCalendarQuery: await calendarQueryPromise,
     }))(),
     watchedThreadIDs: [],
     lifecycleState: 'active',
     enabledApps: defaultWebEnabledApps,
     reportStore: {
       enabledReports: defaultEnabledReports,
       queuedReports: [],
     },
     nextLocalID: 0,
     deviceToken: null,
     dataLoaded: viewer.loggedIn,
     windowActive: true,
     userPolicies: {},
     cryptoStore: {
       primaryIdentityKeys: null,
       notificationIdentityKeys: null,
     },
     pushApiPublicKey: pushApiPublicKeyPromise,
     _persist: null,
     commServicesAccessToken: null,
     inviteLinksStore: inviteLinksStorePromise,
     lastCommunicatedPlatformDetails: {},
     keyserverStore: keyserverStorePromise,
   });
   const validatedInitialReduxState = validateOutput(
     viewer.platformDetails,
     initialReduxStateValidator,
     initialReduxState,
     true,
   );
   const jsonStream = streamJSON(res, validatedInitialReduxState);
 
   await waitForStream(jsonStream);
   res.end(html`
     ;
           var baseURL = "${baseURL}";
           var olmFilename = "${olmFilename}";
           var commQueryExecutorFilename = "${commQueryExecutorFilename}";
           var opaqueURL = "${opaqueURL}";
         </script>
         <script src="${jsURL}"></script>
       </body>
     </html>
   `);
 }
 
 const inviteSecretRegex = /^[a-z0-9]+$/i;
 
 // On native, if this responder is called, it means that the app isn't
 // installed.
 async function inviteResponder(req: $Request, res: $Response): Promise<void> {
   const { secret } = req.params;
   const userAgent = req.get('User-Agent');
   const detectionResult = detectBrowser(userAgent);
   if (detectionResult.os === 'Android OS') {
     const isSecretValid = inviteSecretRegex.test(secret);
     const referrer = isSecretValid
       ? `&referrer=${encodeURIComponent(`utm_source=invite/${secret}`)}`
       : '';
     const redirectUrl = `${stores.googlePlayUrl}${referrer}`;
     res.writeHead(301, {
       Location: redirectUrl,
     });
     res.end();
     return;
   } else if (detectionResult.os !== 'iOS') {
     const urlFacts = getCommAppURLFacts();
     const baseDomain = urlFacts?.baseDomain ?? '';
     const basePath = urlFacts?.basePath ?? '/';
     const redirectUrl = `${baseDomain}${basePath}handle/invite/${secret}`;
     res.writeHead(301, {
       Location: redirectUrl,
     });
     res.end();
     return;
   }
   const fontsURL = await getFontsURL();
   res.end(html`
     <!DOCTYPE html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>Comm</title>
         <link rel="stylesheet" type="text/css" href="/${fontsURL}" />
         <style>
           * {
             -webkit-font-smoothing: antialiased;
             -moz-osx-font-smoothing: grayscale;
             box-sizing: border-box;
             padding: 0;
             margin: 0;
           }
 
           html {
             height: 100%;
             font-size: 112.5%;
           }
 
           body {
             font-family: 'Inter', -apple-system, 'Segoe UI', 'Roboto', 'Oxygen',
               'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
               ui-sans-serif;
             background: #0a0a0a url('/images/invite_link_background.png')
               no-repeat;
             background-size: cover;
             color: #ffffff;
             display: flex;
             flex-direction: column;
             justify-content: space-around;
             align-items: center;
             height: 100%;
             padding: 1.6rem;
             font-size: 1.8rem;
             line-height: 2.4rem;
             font-weight: 500;
           }
 
           section {
             display: flex;
             flex-direction: column;
             align-items: center;
             justify-content: space-between;
             width: 100%;
           }
 
           .card {
             width: 100%;
             padding: 3.2rem 1.6rem;
             gap: 4rem;
             background-color: #1f1f1f;
             border-radius: 1.6rem;
           }
 
           .buttons {
             gap: 1.2rem;
           }
 
           h1 {
             font-size: 3.6rem;
             line-height: 1.5;
             font-weight: 500;
             font-family: 'IBM Plex Sans', sans-serif;
           }
 
           p {
             text-align: center;
           }
 
           .separator {
             border: 1px solid #404040;
             width: 100%;
           }
 
           .button {
             all: unset;
             box-sizing: border-box;
             display: flex;
             justify-content: center;
             align-items: center;
             width: 100%;
             padding: 1.7rem;
             border-radius: 0.4rem;
             border: 1px solid transparent;
             background-color: #6d49ab;
             font-size: 1.6rem;
             line-height: 1.5;
           }
 
           .button.secondary {
             background-color: #1f1f1f;
             border-color: #ffffff;
           }
 
           .link {
             all: unset;
             box-sizing: border-box;
             display: flex;
             align-items: center;
           }
 
           .link-text {
             text-decoration-line: underline;
           }
 
           .logo-container {
             background-color: #0a0a0a;
             width: 4.2rem;
             height: 4.2rem;
             display: flex;
             justify-content: center;
             align-items: center;
             border-radius: 50%;
           }
 
           .logo {
             height: 2.6rem;
           }
 
           .arrow {
             width: 1.8rem;
             height: 1.8rem;
           }
         </style>
       </head>
       <body>
         <div></div>
         <section class="card">
           <section>
             <div class="logo-container">
               <img
                 src="/images/loading_logo.svg"
                 alt="Comm logo"
                 class="logo"
               />
             </div>
             <h1>Comm</h1>
           </section>
           <p>
             To join this community, download the Comm app and reopen this invite
             link
           </p>
           <div class="separator"></div>
           <section class="buttons">
             <a class="button" href="${stores.appStoreUrl}">Download Comm</a>
             <a class="button secondary" href="${inviteLinkUrl(secret)}">
               Invite Link
             </a>
           </section>
         </section>
         <a class="link" href="https://comm.app/">
           <span class="link-text">Visit Comm’s website</span>
           <img
             src="/images/arrow_up_right.svg"
             alt="arrow up right"
             class="arrow"
           />
         </a>
       </body>
     </html>
   `);
 }
 
 export { websiteResponder, inviteResponder };
diff --git a/lib/reducers/master-reducer.js b/lib/reducers/master-reducer.js
index 674809d0e..73ab48edc 100644
--- a/lib/reducers/master-reducer.js
+++ b/lib/reducers/master-reducer.js
@@ -1,155 +1,162 @@
 // @flow
 
 import reduceCalendarFilters from './calendar-filters-reducer.js';
 import reduceConnectionInfo from './connection-reducer.js';
 import reduceDataLoaded from './data-loaded-reducer.js';
 import { reduceDeviceToken } from './device-token-reducer.js';
 import { reduceDraftStore } from './draft-reducer.js';
 import reduceEnabledApps from './enabled-apps-reducer.js';
 import { reduceEntryInfos } from './entry-reducer.js';
 import reduceInviteLinks from './invite-links-reducer.js';
 import reduceKeyserverStore from './keyserver-reducer.js';
 import reduceLastCommunicatedPlatformDetails from './last-communicated-platform-details-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 { reduceThreadInfos } from './thread-reducer.js';
 import reduceURLPrefix from './url-prefix-reducer.js';
 import { reduceCurrentUserInfo, reduceUserInfos } from './user-reducer.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   registerActionTypes,
   logInActionTypes,
 } from '../actions/user-actions.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 { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 export default function baseReducer<N: BaseNavInfo, T: BaseAppState<N>>(
   state: T,
   action: BaseAction,
 ): { state: T, storeOperations: StoreOperations } {
   const { threadStore, newThreadInconsistencies, threadStoreOperations } =
     reduceThreadInfos(state.threadStore, action);
   const { threadInfos } = threadStore;
 
   const [entryStore, newEntryInconsistencies] = reduceEntryInfos(
     state.entryStore,
     action,
     threadInfos,
   );
 
   const newInconsistencies = [
     ...newEntryInconsistencies,
     ...newThreadInconsistencies,
   ];
   // 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;
 
   const connection = reduceConnectionInfo(state.connection, action);
 
   let keyserverStore = reduceKeyserverStore(state.keyserverStore, action);
 
   if (
     connection.status !== 'connected' &&
     action.type !== incrementalStateSyncActionType &&
     action.type !== fullStateSyncActionType &&
     action.type !== registerActionTypes.success &&
     action.type !== logInActionTypes.success &&
     action.type !== siweAuthActionTypes.success
   ) {
-    if (messageStore.currentAsOf !== state.messageStore.currentAsOf) {
+    if (
+      messageStore.currentAsOf[ashoatKeyserverID] !==
+      state.messageStore.currentAsOf[ashoatKeyserverID]
+    ) {
       messageStore = {
         ...messageStore,
-        currentAsOf: state.messageStore.currentAsOf,
+        currentAsOf: {
+          ...messageStore.currentAsOf,
+          [ashoatKeyserverID]:
+            state.messageStore.currentAsOf[ashoatKeyserverID],
+        },
       };
     }
     if (
       keyserverStore.keyserverInfos[ashoatKeyserverID].updatesCurrentAsOf !==
       state.keyserverStore.keyserverInfos[ashoatKeyserverID].updatesCurrentAsOf
     ) {
       const keyserverInfos = { ...keyserverStore.keyserverInfos };
       keyserverInfos[ashoatKeyserverID] = {
         ...keyserverInfos[ashoatKeyserverID],
         updatesCurrentAsOf:
           state.keyserverStore.keyserverInfos[ashoatKeyserverID]
             .updatesCurrentAsOf,
       };
       keyserverStore = { ...keyserverStore, keyserverInfos };
     }
   }
 
   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: reduceUserInfos(state.userStore, action),
       messageStore,
       urlPrefix: reduceURLPrefix(state.urlPrefix, action),
       calendarFilters: reduceCalendarFilters(
         state.calendarFilters,
         action,
         threadStore,
       ),
       notifPermissionAlertInfo: reduceNotifPermissionAlertInfo(
         state.notifPermissionAlertInfo,
         action,
       ),
       connection,
       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),
       deviceToken: reduceDeviceToken(state.deviceToken, action),
       commServicesAccessToken: reduceServicesAccessToken(
         state.commServicesAccessToken,
         action,
       ),
       inviteLinksStore: reduceInviteLinks(state.inviteLinksStore, action),
       lastCommunicatedPlatformDetails: reduceLastCommunicatedPlatformDetails(
         state.lastCommunicatedPlatformDetails,
         action,
         state.urlPrefix,
       ),
       keyserverStore,
     },
     storeOperations: {
       draftStoreOperations,
       threadStoreOperations,
       messageStoreOperations,
       reportStoreOperations,
     },
   };
 }
diff --git a/lib/reducers/message-reducer.js b/lib/reducers/message-reducer.js
index 3b69b7d4b..f496bec50 100644
--- a/lib/reducers/message-reducer.js
+++ b/lib/reducers/message-reducer.js
@@ -1,1779 +1,1788 @@
 // @flow
 
 import invariant from 'invariant';
 import _difference from 'lodash/fp/difference.js';
 import _flow from 'lodash/fp/flow.js';
 import _isEqual from 'lodash/fp/isEqual.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _map from 'lodash/fp/map.js';
 import _mapKeys from 'lodash/fp/mapKeys.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omit from 'lodash/fp/omit.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import _pick from 'lodash/fp/pick.js';
 import _pickBy from 'lodash/fp/pickBy.js';
 import _uniq from 'lodash/fp/uniq.js';
 
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import {
   createEntryActionTypes,
   saveEntryActionTypes,
   deleteEntryActionTypes,
   restoreEntryActionTypes,
 } from '../actions/entry-actions.js';
 import {
   fetchMessagesBeforeCursorActionTypes,
   fetchMostRecentMessagesActionTypes,
   sendTextMessageActionTypes,
   sendMultimediaMessageActionTypes,
   sendReactionMessageActionTypes,
   sendEditMessageActionTypes,
   saveMessagesActionType,
   processMessagesActionType,
   messageStorePruneActionType,
   createLocalMessageActionType,
   fetchSingleMostRecentMessagesFromThreadsActionTypes,
 } from '../actions/message-actions.js';
 import { sendMessageReportActionTypes } from '../actions/message-report-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
   leaveThreadActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   joinThreadActionTypes,
   toggleMessagePinActionTypes,
 } from '../actions/thread-actions.js';
 import { updateMultimediaMessageMediaActionType } from '../actions/upload-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
 } from '../actions/user-actions.js';
 import {
   messageStoreOpsHandlers,
   type MessageStoreOperation,
   type ReplaceMessageOperation,
 } from '../ops/message-store-ops.js';
 import { pendingToRealizedThreadIDsSelector } from '../selectors/thread-selectors.js';
 import {
   messageID,
   combineTruncationStatuses,
   sortMessageInfoList,
   sortMessageIDs,
   mergeThreadMessageInfos,
 } from '../shared/message-utils.js';
 import {
   threadHasPermission,
   threadInChatList,
   threadIsPending,
 } from '../shared/thread-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import { unshimMessageInfos } from '../shared/unshim-utils.js';
 import type { Media, Image } from '../types/media-types.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type LocalMessageInfo,
   type MessageStore,
   type MessageTruncationStatus,
   type MessageTruncationStatuses,
   messageTruncationStatus,
   defaultNumberPerThread,
   type ThreadMessageInfo,
 } from '../types/message-types.js';
 import type { RawImagesMessageInfo } from '../types/messages/images.js';
 import type { RawMediaMessageInfo } from '../types/messages/media.js';
 import { type BaseAction } from '../types/redux-types.js';
 import { processServerRequestsActionType } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import { type RawThreadInfo } from '../types/thread-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { isDev } from '../utils/dev-utils.js';
 import { translateClientDBThreadMessageInfos } from '../utils/message-ops-utils.js';
 import { assertObjectsAreEqual } from '../utils/objects.js';
+import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const PROCESSED_MSG_STORE_INVARIANTS_DISABLED = !isDev;
 const _mapValuesWithKeys = _mapValues.convert({ cap: false });
 
 // Input must already be ordered!
 function mapThreadsToMessageIDsFromOrderedMessageInfos(
   orderedMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 ): { [threadID: string]: string[] } {
   const threadsToMessageIDs: { [threadID: string]: string[] } = {};
   for (const messageInfo of orderedMessageInfos) {
     const key = messageID(messageInfo);
     if (!threadsToMessageIDs[messageInfo.threadID]) {
       threadsToMessageIDs[messageInfo.threadID] = [key];
     } else {
       threadsToMessageIDs[messageInfo.threadID].push(key);
     }
   }
   return threadsToMessageIDs;
 }
 
 function isThreadWatched(
   threadID: string,
   threadInfo: ?RawThreadInfo,
   watchedIDs: $ReadOnlyArray<string>,
 ) {
   return (
     threadIsPending(threadID) ||
     (threadInfo &&
       threadHasPermission(threadInfo, threadPermissions.VISIBLE) &&
       (threadInChatList(threadInfo) || watchedIDs.includes(threadID)))
   );
 }
 
 function assertMessageStoreThreadsAreEqual(
   processedMessageStore: MessageStore,
   expectedMessageStore: MessageStore,
   location: string,
 ) {
   if (PROCESSED_MSG_STORE_INVARIANTS_DISABLED) {
     return;
   }
 
   assertObjectsAreEqual(
     processedMessageStore.threads,
     expectedMessageStore.threads,
     `MessageStore.threads - ${location}`,
   );
 }
 
 const newThread = () => ({
   messageIDs: [],
   startReached: false,
   lastNavigatedTo: 0,
   lastPruned: Date.now(),
 });
 
 type FreshMessageStoreResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 function freshMessageStore(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatus: { [threadID: string]: MessageTruncationStatus },
   currentAsOf: number,
   threadInfos: { +[threadID: string]: RawThreadInfo },
 ): FreshMessageStoreResult {
   const unshimmed = unshimMessageInfos(messageInfos);
   const orderedMessageInfos = sortMessageInfoList(unshimmed);
   const messages = _keyBy(messageID)(orderedMessageInfos);
 
   const messageStoreReplaceOperations = orderedMessageInfos.map(
     messageInfo => ({
       type: 'replace',
       payload: { id: messageID(messageInfo), messageInfo },
     }),
   );
 
   const threadsToMessageIDs =
     mapThreadsToMessageIDsFromOrderedMessageInfos(orderedMessageInfos);
   const threads = _mapValuesWithKeys(
     (messageIDs: string[], threadID: string) => ({
       ...newThread(),
       messageIDs,
       startReached:
         truncationStatus[threadID] === messageTruncationStatus.EXHAUSTIVE,
     }),
   )(threadsToMessageIDs);
   const watchedIDs = threadWatcher.getWatchedIDs();
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (
       threads[threadID] ||
       !isThreadWatched(threadID, threadInfo, watchedIDs)
     ) {
       continue;
     }
     threads[threadID] = newThread();
   }
 
   const messageStoreOperations = [
     { type: 'remove_all' },
     {
       type: 'remove_all_threads',
     },
     {
       type: 'replace_threads',
       payload: { threads },
     },
     ...messageStoreReplaceOperations,
   ];
 
   return {
     messageStoreOperations,
-    messageStore: { messages, threads, local: {}, currentAsOf },
+    messageStore: {
+      messages,
+      threads,
+      local: {},
+      currentAsOf: { [ashoatKeyserverID]: currentAsOf },
+    },
   };
 }
 
 type ReassignmentResult = {
   +messageStoreOperations: MessageStoreOperation[],
   +messageStore: MessageStore,
   +reassignedThreadIDs: string[],
 };
 
 function reassignMessagesToRealizedThreads(
   messageStore: MessageStore,
   threadInfos: { +[threadID: string]: RawThreadInfo },
 ): ReassignmentResult {
   const pendingToRealizedThreadIDs =
     pendingToRealizedThreadIDsSelector(threadInfos);
 
   const messageStoreOperations: MessageStoreOperation[] = [];
   const messages = {};
   for (const storeMessageID in messageStore.messages) {
     const message = messageStore.messages[storeMessageID];
     const newThreadID = pendingToRealizedThreadIDs.get(message.threadID);
 
     messages[storeMessageID] = newThreadID
       ? {
           ...message,
           threadID: newThreadID,
           time: threadInfos[newThreadID]?.creationTime ?? message.time,
         }
       : message;
 
     if (!newThreadID) {
       continue;
     }
 
     const updateMsgOperation: ReplaceMessageOperation = {
       type: 'replace',
       payload: { id: storeMessageID, messageInfo: messages[storeMessageID] },
     };
 
     messageStoreOperations.push(updateMsgOperation);
   }
 
   const threads = {};
   const reassignedThreadIDs = [];
   const updatedThreads = {};
   const threadsToRemove = [];
   for (const threadID in messageStore.threads) {
     const threadMessageInfo = messageStore.threads[threadID];
     const newThreadID = pendingToRealizedThreadIDs.get(threadID);
     if (!newThreadID) {
       threads[threadID] = threadMessageInfo;
       continue;
     }
     const realizedThread = messageStore.threads[newThreadID];
     if (!realizedThread) {
       reassignedThreadIDs.push(newThreadID);
       threads[newThreadID] = threadMessageInfo;
       updatedThreads[newThreadID] = threadMessageInfo;
       threadsToRemove.push(threadID);
       continue;
     }
     threads[newThreadID] = mergeThreadMessageInfos(
       threadMessageInfo,
       realizedThread,
       messages,
     );
     updatedThreads[newThreadID] = threads[newThreadID];
   }
   if (threadsToRemove.length) {
     messageStoreOperations.push({
       type: 'remove_threads',
       payload: {
         ids: threadsToRemove,
       },
     });
   }
   messageStoreOperations.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   return {
     messageStoreOperations,
     messageStore: {
       ...messageStore,
       threads,
       messages,
     },
     reassignedThreadIDs,
   };
 }
 
 type MergeNewMessagesResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 // oldMessageStore is from the old state
 // newMessageInfos, truncationStatus come from server
 function mergeNewMessages(
   oldMessageStore: MessageStore,
   newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   truncationStatus: { [threadID: string]: MessageTruncationStatus },
   threadInfos: { +[threadID: string]: RawThreadInfo },
   actionType: string,
 ): MergeNewMessagesResult {
   const {
     messageStoreOperations: updateWithLatestThreadInfosOps,
     messageStore: messageStoreUpdatedWithLatestThreadInfos,
     reassignedThreadIDs,
   } = updateMessageStoreWithLatestThreadInfos(oldMessageStore, threadInfos);
 
   const messageStoreAfterUpdateOps = processMessageStoreOperations(
     oldMessageStore,
     updateWithLatestThreadInfosOps,
   );
 
   assertMessageStoreThreadsAreEqual(
     messageStoreAfterUpdateOps,
     messageStoreUpdatedWithLatestThreadInfos,
     `${actionType} | reassignment and filtering`,
   );
 
   const updatedMessageStore = {
     ...messageStoreUpdatedWithLatestThreadInfos,
     messages: messageStoreAfterUpdateOps.messages,
   };
 
   const localIDsToServerIDs: Map<string, string> = new Map();
 
   const watchedThreadIDs = [
     ...threadWatcher.getWatchedIDs(),
     ...reassignedThreadIDs,
   ];
   const unshimmedNewMessages = unshimMessageInfos(newMessageInfos);
   const unshimmedNewMessagesOfWatchedThreads = unshimmedNewMessages.filter(
     msg =>
       isThreadWatched(
         msg.threadID,
         threadInfos[msg.threadID],
         watchedThreadIDs,
       ),
   );
   const orderedNewMessageInfos = _flow(
     _map((messageInfo: RawMessageInfo) => {
       const { id: inputID } = messageInfo;
       invariant(inputID, 'new messageInfos should have serverID');
       invariant(
         !threadIsPending(messageInfo.threadID),
         'new messageInfos should have realized thread id',
       );
       const currentMessageInfo = updatedMessageStore.messages[inputID];
       if (
         messageInfo.type === messageTypes.TEXT ||
         messageInfo.type === messageTypes.IMAGES ||
         messageInfo.type === messageTypes.MULTIMEDIA
       ) {
         const { localID: inputLocalID } = messageInfo;
         const currentLocalMessageInfo = inputLocalID
           ? updatedMessageStore.messages[inputLocalID]
           : null;
         if (currentMessageInfo && currentMessageInfo.localID) {
           // If the client already has a RawMessageInfo with this serverID, keep
           // any localID associated with the existing one. This is because we
           // use localIDs as React keys and changing React keys leads to loss of
           // component state. (The conditional below is for Flow)
           if (messageInfo.type === messageTypes.TEXT) {
             messageInfo = {
               ...messageInfo,
               localID: currentMessageInfo.localID,
             };
           } else if (messageInfo.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({
               ...messageInfo,
               localID: currentMessageInfo.localID,
             }: RawMediaMessageInfo);
           } else {
             messageInfo = ({
               ...messageInfo,
               localID: currentMessageInfo.localID,
             }: RawImagesMessageInfo);
           }
         } else if (currentLocalMessageInfo && currentLocalMessageInfo.localID) {
           // If the client has a RawMessageInfo with this localID, but not with
           // the serverID, that means the message creation succeeded but the
           // success action never got processed. We set a key in
           // localIDsToServerIDs here to fix the messageIDs for the rest of the
           // MessageStore too. (The conditional below is for Flow)
           invariant(inputLocalID, 'inputLocalID should be set');
           localIDsToServerIDs.set(inputLocalID, inputID);
           if (messageInfo.type === messageTypes.TEXT) {
             messageInfo = {
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             };
           } else if (messageInfo.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             }: RawMediaMessageInfo);
           } else {
             messageInfo = ({
               ...messageInfo,
               localID: currentLocalMessageInfo.localID,
             }: RawImagesMessageInfo);
           }
         } else {
           // If neither the serverID nor the localID from the delivered
           // RawMessageInfo exists in the client store, then this message is
           // brand new to us. Ignore any localID provided by the server.
           // (The conditional below is for Flow)
           const { localID, ...rest } = messageInfo;
           if (rest.type === messageTypes.TEXT) {
             messageInfo = { ...rest };
           } else if (rest.type === messageTypes.MULTIMEDIA) {
             messageInfo = ({ ...rest }: RawMediaMessageInfo);
           } else {
             messageInfo = ({ ...rest }: RawImagesMessageInfo);
           }
         }
       } else if (
         currentMessageInfo &&
         messageInfo.time > currentMessageInfo.time
       ) {
         // When thick threads will be introduced it will be possible for two
         // clients to create the same message (e.g. when they create the same
         // sidebar at the same time). We're going to use deterministic ids for
         // messages which should be unique within a thread and we have to find
         // a way for clients to agree which message to keep. We can't rely on
         // always choosing incoming messages nor messages from the store,
         // because a message that is in one user's store, will be send to
         // another user. One way to deal with it is to always choose a message
         // which is older, according to its timestamp. We can use this strategy
         // only for messages that can start a thread, because for other types
         // it might break the "contiguous" property of message ids (we can
         // consider selecting younger messages in that case, but for now we use
         // an invariant).
         invariant(
           messageInfo.type === messageTypes.CREATE_SIDEBAR ||
             messageInfo.type === messageTypes.CREATE_THREAD ||
             messageInfo.type === messageTypes.SIDEBAR_SOURCE,
           `Two different messages of type ${messageInfo.type} with the same ` +
             'id found',
         );
         return currentMessageInfo;
       }
       return _isEqual(messageInfo)(currentMessageInfo)
         ? currentMessageInfo
         : messageInfo;
     }),
     sortMessageInfoList,
   )(unshimmedNewMessagesOfWatchedThreads);
 
   const newMessageOps: MessageStoreOperation[] = [];
   const threadsToMessageIDs = mapThreadsToMessageIDsFromOrderedMessageInfos(
     orderedNewMessageInfos,
   );
   const oldMessageInfosToCombine = [];
   const threadsThatNeedMessageIDsResorted = [];
   const local = {};
   const updatedThreads = {};
   const threads = _flow(
     _mapValuesWithKeys((messageIDs: string[], threadID: string) => {
       const oldThread = updatedMessageStore.threads[threadID];
       const truncate = truncationStatus[threadID];
       if (!oldThread) {
         updatedThreads[threadID] = {
           ...newThread(),
           messageIDs,
           startReached: truncate === messageTruncationStatus.EXHAUSTIVE,
         };
         return updatedThreads[threadID];
       }
       let oldMessageIDsUnchanged = true;
       const oldMessageIDs = oldThread.messageIDs.map(oldID => {
         const newID = localIDsToServerIDs.get(oldID);
         if (newID !== null && newID !== undefined) {
           oldMessageIDsUnchanged = false;
           return newID;
         }
         return oldID;
       });
       if (truncate === messageTruncationStatus.TRUNCATED) {
         // If the result set in the payload isn't contiguous with what we have
         // now, that means we need to dump what we have in the state and replace
         // it with the result set. We do this to achieve our two goals for the
         // messageStore: currentness and contiguousness.
         newMessageOps.push({
           type: 'remove_messages_for_threads',
           payload: { threadIDs: [threadID] },
         });
         updatedThreads[threadID] = {
           messageIDs,
           startReached: false,
           lastNavigatedTo: oldThread.lastNavigatedTo,
           lastPruned: oldThread.lastPruned,
         };
         return updatedThreads[threadID];
       }
       const oldNotInNew = _difference(oldMessageIDs)(messageIDs);
       for (const id of oldNotInNew) {
         const oldMessageInfo = updatedMessageStore.messages[id];
         invariant(oldMessageInfo, `could not find ${id} in messageStore`);
         oldMessageInfosToCombine.push(oldMessageInfo);
         const localInfo = updatedMessageStore.local[id];
         if (localInfo) {
           local[id] = localInfo;
         }
       }
       const startReached =
         oldThread.startReached ||
         truncate === messageTruncationStatus.EXHAUSTIVE;
       if (_difference(messageIDs)(oldMessageIDs).length === 0) {
         if (startReached === oldThread.startReached && oldMessageIDsUnchanged) {
           return oldThread;
         }
         updatedThreads[threadID] = {
           messageIDs: oldMessageIDs,
           startReached,
           lastNavigatedTo: oldThread.lastNavigatedTo,
           lastPruned: oldThread.lastPruned,
         };
         return updatedThreads[threadID];
       }
       const mergedMessageIDs = [...messageIDs, ...oldNotInNew];
       threadsThatNeedMessageIDsResorted.push(threadID);
       return {
         messageIDs: mergedMessageIDs,
         startReached,
         lastNavigatedTo: oldThread.lastNavigatedTo,
         lastPruned: oldThread.lastPruned,
       };
     }),
     _pickBy(thread => !!thread),
   )(threadsToMessageIDs);
 
   for (const threadID in updatedMessageStore.threads) {
     if (threads[threadID]) {
       continue;
     }
     let thread = updatedMessageStore.threads[threadID];
     const truncate = truncationStatus[threadID];
     if (truncate === messageTruncationStatus.EXHAUSTIVE) {
       thread = {
         ...thread,
         startReached: true,
       };
     }
     threads[threadID] = thread;
     updatedThreads[threadID] = thread;
 
     for (const id of thread.messageIDs) {
       const messageInfo = updatedMessageStore.messages[id];
       if (messageInfo) {
         oldMessageInfosToCombine.push(messageInfo);
       }
       const localInfo = updatedMessageStore.local[id];
       if (localInfo) {
         local[id] = localInfo;
       }
     }
   }
 
   const messages = _flow(
     sortMessageInfoList,
     _keyBy(messageID),
   )([...orderedNewMessageInfos, ...oldMessageInfosToCombine]);
 
   const newMessages = _keyBy(messageID)(orderedNewMessageInfos);
   for (const id in newMessages) {
     newMessageOps.push({
       type: 'replace',
       payload: { id, messageInfo: newMessages[id] },
     });
   }
 
   if (localIDsToServerIDs.size > 0) {
     newMessageOps.push({
       type: 'remove',
       payload: { ids: [...localIDsToServerIDs.keys()] },
     });
   }
 
   for (const threadID of threadsThatNeedMessageIDsResorted) {
     threads[threadID].messageIDs = sortMessageIDs(messages)(
       threads[threadID].messageIDs,
     );
     updatedThreads[threadID] = threads[threadID];
   }
 
   const currentAsOf = Math.max(
     orderedNewMessageInfos.length > 0 ? orderedNewMessageInfos[0].time : 0,
-    updatedMessageStore.currentAsOf,
+    updatedMessageStore.currentAsOf[ashoatKeyserverID],
   );
 
   newMessageOps.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   const processedMessageStore = processMessageStoreOperations(
     updatedMessageStore,
     newMessageOps,
   );
 
   const messageStore = {
     messages: processedMessageStore.messages,
     threads,
     local,
-    currentAsOf,
+    currentAsOf: {
+      ...processedMessageStore.currentAsOf,
+      [ashoatKeyserverID]: currentAsOf,
+    },
   };
 
   assertMessageStoreThreadsAreEqual(
     processedMessageStore,
     messageStore,
     `${actionType} | processed`,
   );
 
   return {
     messageStoreOperations: [
       ...updateWithLatestThreadInfosOps,
       ...newMessageOps,
     ],
     messageStore,
   };
 }
 
 type UpdateMessageStoreWithLatestThreadInfosResult = {
   +messageStoreOperations: MessageStoreOperation[],
   +messageStore: MessageStore,
   +reassignedThreadIDs: string[],
 };
 function updateMessageStoreWithLatestThreadInfos(
   messageStore: MessageStore,
   threadInfos: { +[id: string]: RawThreadInfo },
 ): UpdateMessageStoreWithLatestThreadInfosResult {
   const messageStoreOperations: MessageStoreOperation[] = [];
   const {
     messageStore: reassignedMessageStore,
     messageStoreOperations: reassignMessagesOps,
     reassignedThreadIDs,
   } = reassignMessagesToRealizedThreads(messageStore, threadInfos);
   messageStoreOperations.push(...reassignMessagesOps);
   const watchedIDs = [...threadWatcher.getWatchedIDs(), ...reassignedThreadIDs];
   const watchedThreadInfos = _pickBy((threadInfo: RawThreadInfo) =>
     isThreadWatched(threadInfo.id, threadInfo, watchedIDs),
   )(threadInfos);
 
   const filteredThreads = _pick(Object.keys(watchedThreadInfos))(
     reassignedMessageStore.threads,
   );
 
   const messageIDsToRemove = [];
   const threadsToRemoveMessagesFrom = [];
   for (const threadID in reassignedMessageStore.threads) {
     if (watchedThreadInfos[threadID]) {
       continue;
     }
     threadsToRemoveMessagesFrom.push(threadID);
     for (const id of reassignedMessageStore.threads[threadID].messageIDs) {
       messageIDsToRemove.push(id);
     }
   }
 
   const updatedThreads = {};
   for (const threadID in threadInfos) {
     const threadInfo = threadInfos[threadID];
     if (
       isThreadWatched(threadID, threadInfo, watchedIDs) &&
       !filteredThreads[threadID]
     ) {
       filteredThreads[threadID] = newThread();
       updatedThreads[threadID] = filteredThreads[threadID];
     }
   }
 
   messageStoreOperations.push({
     type: 'remove_threads',
     payload: { ids: threadsToRemoveMessagesFrom },
   });
 
   messageStoreOperations.push({
     type: 'replace_threads',
     payload: {
       threads: updatedThreads,
     },
   });
 
   messageStoreOperations.push({
     type: 'remove_messages_for_threads',
     payload: { threadIDs: threadsToRemoveMessagesFrom },
   });
 
   return {
     messageStoreOperations,
     messageStore: {
       messages: _omit(messageIDsToRemove)(reassignedMessageStore.messages),
       threads: filteredThreads,
       local: _omit(messageIDsToRemove)(reassignedMessageStore.local),
       currentAsOf: reassignedMessageStore.currentAsOf,
     },
     reassignedThreadIDs,
   };
 }
 
 function ensureRealizedThreadIDIsUsedWhenPossible<T: RawMessageInfo>(
   payload: T,
   threadInfos: { +[id: string]: RawThreadInfo },
 ): T {
   const pendingToRealizedThreadIDs =
     pendingToRealizedThreadIDsSelector(threadInfos);
   const realizedThreadID = pendingToRealizedThreadIDs.get(payload.threadID);
   return realizedThreadID
     ? { ...payload, threadID: realizedThreadID }
     : payload;
 }
 
 const { processStoreOperations: processMessageStoreOperations } =
   messageStoreOpsHandlers;
 
 type ReduceMessageStoreResult = {
   +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
   +messageStore: MessageStore,
 };
 function reduceMessageStore(
   messageStore: MessageStore,
   action: BaseAction,
   newThreadInfos: { +[id: string]: RawThreadInfo },
 ): ReduceMessageStoreResult {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success
   ) {
     const messagesResult = action.payload.messagesResult;
     const { messageStoreOperations, messageStore: freshStore } =
       freshMessageStore(
         messagesResult.messageInfos,
         messagesResult.truncationStatus,
         messagesResult.currentAsOf,
         newThreadInfos,
       );
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       freshStore,
       `${action.type} | fresh store`,
     );
 
     return {
       messageStoreOperations,
       messageStore: { ...freshStore, messages: processedMessageStore.messages },
     };
   } else if (action.type === incrementalStateSyncActionType) {
     if (
       action.payload.messagesResult.rawMessageInfos.length === 0 &&
       action.payload.updatesResult.newUpdates.length === 0
     ) {
       return { messageStoreOperations: [], messageStore };
     }
 
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.messagesResult.rawMessageInfos,
       action.payload.updatesResult.newUpdates,
       action.payload.messagesResult.truncationStatuses,
     );
 
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (action.type === processUpdatesActionType) {
     if (action.payload.updatesResult.newUpdates.length === 0) {
       return { messageStoreOperations: [], messageStore };
     }
 
     const messagesResult = mergeUpdatesWithMessageInfos(
       [],
       action.payload.updatesResult.newUpdates,
     );
 
     const { messageStoreOperations, messageStore: newMessageStore } =
       mergeNewMessages(
         messageStore,
         messagesResult.rawMessageInfos,
         messagesResult.truncationStatuses,
         newThreadInfos,
         action.type,
       );
     return {
       messageStoreOperations,
       messageStore: {
         messages: newMessageStore.messages,
         threads: newMessageStore.threads,
         local: newMessageStore.local,
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (
     action.type === fullStateSyncActionType ||
     action.type === processMessagesActionType
   ) {
     const { messagesResult } = action.payload;
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === fetchSingleMostRecentMessagesFromThreadsActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       action.payload.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === fetchMessagesBeforeCursorActionTypes.success ||
     action.type === fetchMostRecentMessagesActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       { [action.payload.threadID]: action.payload.truncationStatus },
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === setNewSessionActionType
   ) {
     const { messageStoreOperations, messageStore: filteredMessageStore } =
       updateMessageStoreWithLatestThreadInfos(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       filteredMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...filteredMessageStore,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === newThreadActionTypes.success) {
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.newMessageInfos,
       action.payload.updatesResult.newUpdates,
     );
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (action.type === sendMessageReportActionTypes.success) {
     return mergeNewMessages(
       messageStore,
       [action.payload.messageInfo],
       {
         [action.payload.messageInfo.threadID]:
           messageTruncationStatus.UNCHANGED,
       },
       newThreadInfos,
       action.type,
     );
   } else if (action.type === registerActionTypes.success) {
     const truncationStatuses = {};
     for (const messageInfo of action.payload.rawMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.EXHAUSTIVE;
     }
     return mergeNewMessages(
       messageStore,
       action.payload.rawMessageInfos,
       truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === createEntryActionTypes.success ||
     action.type === saveEntryActionTypes.success ||
     action.type === restoreEntryActionTypes.success ||
     action.type === toggleMessagePinActionTypes.success
   ) {
     return mergeNewMessages(
       messageStore,
       action.payload.newMessageInfos,
       { [action.payload.threadID]: messageTruncationStatus.UNCHANGED },
       newThreadInfos,
       action.type,
     );
   } else if (action.type === deleteEntryActionTypes.success) {
     const payload = action.payload;
     if (payload) {
       return mergeNewMessages(
         messageStore,
         payload.newMessageInfos,
         { [payload.threadID]: messageTruncationStatus.UNCHANGED },
         newThreadInfos,
         action.type,
       );
     }
   } else if (action.type === joinThreadActionTypes.success) {
     const messagesResult = mergeUpdatesWithMessageInfos(
       action.payload.rawMessageInfos,
       action.payload.updatesResult.newUpdates,
     );
     return mergeNewMessages(
       messageStore,
       messagesResult.rawMessageInfos,
       messagesResult.truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (action.type === sendEditMessageActionTypes.success) {
     const { newMessageInfos } = action.payload;
     const truncationStatuses = {};
     for (const messageInfo of newMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.UNCHANGED;
     }
     return mergeNewMessages(
       messageStore,
       newMessageInfos,
       truncationStatuses,
       newThreadInfos,
       action.type,
     );
   } else if (
     action.type === sendTextMessageActionTypes.started ||
     action.type === sendMultimediaMessageActionTypes.started ||
     action.type === sendReactionMessageActionTypes.started
   ) {
     const payload = ensureRealizedThreadIDIsUsedWhenPossible(
       action.payload,
       newThreadInfos,
     );
     const { localID, threadID } = payload;
     invariant(localID, `localID should be set on ${action.type}`);
 
     const messageIDs = messageStore.threads[threadID]?.messageIDs ?? [];
     if (!messageStore.messages[localID]) {
       for (const existingMessageID of messageIDs) {
         const existingMessageInfo = messageStore.messages[existingMessageID];
         if (existingMessageInfo && existingMessageInfo.localID === localID) {
           return { messageStoreOperations: [], messageStore };
         }
       }
     }
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: { id: localID, messageInfo: payload },
       },
     ];
 
     const now = Date.now();
     let updatedThreads;
     let local = { ...messageStore.local };
     if (messageStore.messages[localID]) {
       const messages = { ...messageStore.messages, [localID]: payload };
       local = _pickBy(
         (localInfo: LocalMessageInfo, key: string) => key !== localID,
       )(messageStore.local);
       const thread = messageStore.threads[threadID];
       updatedThreads = {
         [threadID]: {
           messageIDs: sortMessageIDs(messages)(messageIDs),
           startReached: thread?.startReached ?? true,
           lastNavigatedTo: thread?.lastNavigatedTo ?? now,
           lastPruned: thread?.lastPruned ?? now,
         },
       };
     } else {
       updatedThreads = {
         [threadID]: messageStore.threads[threadID]
           ? {
               ...messageStore.threads[threadID],
               messageIDs: [localID, ...messageIDs],
             }
           : {
               messageIDs: [localID],
               startReached: true,
               lastNavigatedTo: now,
               lastPruned: now,
             },
       };
     }
 
     const threads = {
       ...messageStore.threads,
       ...updatedThreads,
     };
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: {
         threads: { ...updatedThreads },
       },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       messages: processedMessageStore.messages,
       threads,
       local,
       currentAsOf: messageStore.currentAsOf,
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (
     action.type === sendTextMessageActionTypes.failed ||
     action.type === sendMultimediaMessageActionTypes.failed
   ) {
     const { localID } = action.payload;
     return {
       messageStoreOperations: [],
       messageStore: {
         messages: messageStore.messages,
         threads: messageStore.threads,
         local: {
           ...messageStore.local,
           [localID]: { sendFailed: true },
         },
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (action.type === sendReactionMessageActionTypes.failed) {
     const { localID, threadID } = action.payload;
     const messageStoreOperations = [];
 
     messageStoreOperations.push({
       type: 'remove',
       payload: { ids: [localID] },
     });
 
     const newMessageIDs = messageStore.threads[threadID].messageIDs.filter(
       id => id !== localID,
     );
     const updatedThreads = {
       [threadID]: {
         ...messageStore.threads[threadID],
         messageIDs: newMessageIDs,
       },
     };
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: updatedThreads },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       ...processedMessageStore,
       threads: {
         ...messageStore.threads,
         ...updatedThreads,
       },
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (
     action.type === sendTextMessageActionTypes.success ||
     action.type === sendMultimediaMessageActionTypes.success ||
     action.type === sendReactionMessageActionTypes.success
   ) {
     const { payload } = action;
     invariant(
       !threadIsPending(payload.threadID),
       'Successful message action should have realized thread id',
     );
     const replaceMessageKey = (messageKey: string) =>
       messageKey === payload.localID ? payload.serverID : messageKey;
     let newMessages;
     const messageStoreOperations = [];
     if (messageStore.messages[payload.serverID]) {
       // If somehow the serverID got in there already, we'll just update the
       // serverID message and scrub the localID one
       newMessages = _omitBy(
         (messageInfo: RawMessageInfo) =>
           messageInfo.type === messageTypes.TEXT &&
           !messageInfo.id &&
           messageInfo.localID === payload.localID,
       )(messageStore.messages);
       messageStoreOperations.push({
         type: 'remove',
         payload: { ids: [payload.localID] },
       });
     } else if (messageStore.messages[payload.localID]) {
       // The normal case, the localID message gets replaced by the serverID one
       newMessages = _mapKeys(replaceMessageKey)(messageStore.messages);
       messageStoreOperations.push({
         type: 'rekey',
         payload: { from: payload.localID, to: payload.serverID },
       });
     } else {
       // Well this is weird, we probably got deauthorized between when the
       // action was dispatched and when we ran this reducer...
       return { messageStoreOperations, messageStore };
     }
 
     const newMessage = {
       ...newMessages[payload.serverID],
       id: payload.serverID,
       localID: payload.localID,
       time: payload.time,
     };
     newMessages[payload.serverID] = newMessage;
     messageStoreOperations.push({
       type: 'replace',
       payload: { id: payload.serverID, messageInfo: newMessage },
     });
     const threadID = payload.threadID;
     const newMessageIDs = _flow(
       _uniq,
       sortMessageIDs(newMessages),
     )(messageStore.threads[threadID].messageIDs.map(replaceMessageKey));
     const local = _pickBy(
       (localInfo: LocalMessageInfo, key: string) => key !== payload.localID,
     )(messageStore.local);
 
     const updatedThreads = {
       [threadID]: {
         ...messageStore.threads[threadID],
         messageIDs: newMessageIDs,
       },
     };
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: updatedThreads },
     });
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       ...messageStore,
       messages: processedMessageStore.messages,
       threads: {
         ...messageStore.threads,
         ...updatedThreads,
       },
       local,
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (action.type === saveMessagesActionType) {
     const truncationStatuses = {};
     for (const messageInfo of action.payload.rawMessageInfos) {
       truncationStatuses[messageInfo.threadID] =
         messageTruncationStatus.UNCHANGED;
     }
     const { messageStoreOperations, messageStore: newMessageStore } =
       mergeNewMessages(
         messageStore,
         action.payload.rawMessageInfos,
         truncationStatuses,
         newThreadInfos,
         action.type,
       );
     return {
       messageStoreOperations,
       messageStore: {
         messages: newMessageStore.messages,
         threads: newMessageStore.threads,
         local: newMessageStore.local,
         // We avoid bumping currentAsOf because notifs may include a contracted
         // RawMessageInfo, so we want to make sure we still fetch it
         currentAsOf: messageStore.currentAsOf,
       },
     };
   } else if (action.type === messageStorePruneActionType) {
     const now = Date.now();
     const messageIDsToPrune = [];
 
     const updatedThreads = {};
     for (const threadID of action.payload.threadIDs) {
       let thread = messageStore.threads[threadID];
       if (!thread) {
         continue;
       }
       thread = { ...thread, lastPruned: now };
 
       const newMessageIDs = [...thread.messageIDs];
       const removed = newMessageIDs.splice(defaultNumberPerThread);
       if (removed.length > 0) {
         thread = {
           ...thread,
           messageIDs: newMessageIDs,
           startReached: false,
         };
       }
       for (const id of removed) {
         messageIDsToPrune.push(id);
       }
 
       updatedThreads[threadID] = thread;
     }
 
     const messageStoreOperations = [
       {
         type: 'remove',
         payload: { ids: messageIDsToPrune },
       },
       {
         type: 'replace_threads',
         payload: {
           threads: updatedThreads,
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       messages: processedMessageStore.messages,
       threads: {
         ...messageStore.threads,
         ...updatedThreads,
       },
       local: _omit(messageIDsToPrune)(messageStore.local),
       currentAsOf: messageStore.currentAsOf,
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (action.type === updateMultimediaMessageMediaActionType) {
     const { messageID: id, currentMediaID, mediaUpdate } = action.payload;
     const message = messageStore.messages[id];
     invariant(message, `message with ID ${id} could not be found`);
     invariant(
       message.type === messageTypes.IMAGES ||
         message.type === messageTypes.MULTIMEDIA,
       `message with ID ${id} is not multimedia`,
     );
 
     let updatedMessage;
     let replaced = false;
     if (message.type === messageTypes.IMAGES) {
       const media: Image[] = [];
       for (const singleMedia of message.media) {
         if (singleMedia.id !== currentMediaID) {
           media.push(singleMedia);
         } else {
           let updatedMedia: Image = {
             id: mediaUpdate.id ?? singleMedia.id,
             type: 'photo',
             uri: mediaUpdate.uri ?? singleMedia.uri,
             dimensions: mediaUpdate.dimensions ?? singleMedia.dimensions,
             thumbHash: mediaUpdate.thumbHash ?? singleMedia.thumbHash,
           };
 
           if (
             'localMediaSelection' in singleMedia &&
             !('localMediaSelection' in mediaUpdate)
           ) {
             updatedMedia = {
               ...updatedMedia,
               localMediaSelection: singleMedia.localMediaSelection,
             };
           } else if (mediaUpdate.localMediaSelection) {
             updatedMedia = {
               ...updatedMedia,
               localMediaSelection: mediaUpdate.localMediaSelection,
             };
           }
 
           media.push(updatedMedia);
           replaced = true;
         }
       }
       updatedMessage = { ...message, media };
     } else {
       const media: Media[] = [];
       for (const singleMedia of message.media) {
         if (singleMedia.id !== currentMediaID) {
           media.push(singleMedia);
         } else if (
           singleMedia.type === 'photo' &&
           mediaUpdate.type === 'photo'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'video' &&
           mediaUpdate.type === 'video'
         ) {
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'encrypted_photo' &&
           mediaUpdate.type === 'encrypted_photo'
         ) {
           // TODO: Remove this $FlowFixMe after updating Flow to 0.202
           // There's no way in Flow to refine both of these types appropriately
           // so they can be spread together.
           // $FlowFixMe
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'encrypted_video' &&
           mediaUpdate.type === 'encrypted_video'
         ) {
           // TODO: Remove this $FlowFixMe after updating Flow to 0.202
           // There's no way in Flow to refine both of these types appropriately
           // so they can be spread together.
           // $FlowFixMe
           media.push({ ...singleMedia, ...mediaUpdate });
           replaced = true;
         } else if (
           singleMedia.type === 'photo' &&
           mediaUpdate.type === 'encrypted_photo'
         ) {
           // extract fields that are absent in encrypted_photo type
           const { uri, localMediaSelection, ...original } = singleMedia;
           const {
             holder: newHolder,
             blobURI: newBlobURI,
             encryptionKey,
             ...update
           } = mediaUpdate;
           const blobURI = newBlobURI ?? newHolder;
           invariant(
             blobURI && encryptionKey,
             'holder and encryptionKey are required for encrypted_photo message',
           );
           media.push({
             ...original,
             ...update,
             type: 'encrypted_photo',
             blobURI,
             encryptionKey,
           });
           replaced = true;
         } else if (
           singleMedia.type === 'video' &&
           mediaUpdate.type === 'encrypted_video'
         ) {
           const { uri, thumbnailURI, localMediaSelection, ...original } =
             singleMedia;
           const {
             holder: newHolder,
             blobURI: newBlobURI,
             encryptionKey,
             thumbnailHolder: newThumbnailHolder,
             thumbnailBlobURI: newThumbnailBlobURI,
             thumbnailEncryptionKey,
             ...update
           } = mediaUpdate;
           const blobURI = newBlobURI ?? newHolder;
           invariant(
             blobURI && encryptionKey,
             'holder and encryptionKey are required for encrypted_video message',
           );
           const thumbnailBlobURI = newThumbnailBlobURI ?? newThumbnailHolder;
           invariant(
             thumbnailBlobURI && thumbnailEncryptionKey,
             'thumbnailHolder and thumbnailEncryptionKey are required for ' +
               'encrypted_video message',
           );
           media.push({
             ...original,
             ...update,
             type: 'encrypted_video',
             blobURI,
             encryptionKey,
             thumbnailBlobURI,
             thumbnailEncryptionKey,
           });
           replaced = true;
         } else if (mediaUpdate.id) {
           const { id: newID } = mediaUpdate;
           // branching for Flow
           if (singleMedia.type === 'photo') {
             media.push({ ...singleMedia, id: newID });
           } else if (singleMedia.type === 'video') {
             media.push({ ...singleMedia, id: newID });
           } else if (singleMedia.type === 'encrypted_photo') {
             // TODO: Try removing this branching after Flow 0.202 update
             if (singleMedia.blobURI) {
               media.push({ ...singleMedia, id: newID });
             } else {
               invariant(
                 singleMedia.holder,
                 'Encrypted media must have holder or blobURI',
               );
               media.push({ ...singleMedia, id: newID });
             }
           } else if (singleMedia.type === 'encrypted_video') {
             // TODO: Try removing this branching after Flow 0.202 update
             if (singleMedia.blobURI) {
               media.push({ ...singleMedia, id: newID });
             } else {
               invariant(
                 singleMedia.holder,
                 'Encrypted media must have holder or blobURI',
               );
               media.push({ ...singleMedia, id: newID });
             }
           }
           replaced = true;
         }
       }
       updatedMessage = { ...message, media };
     }
 
     invariant(
       replaced,
       `message ${id} did not contain media with ID ${currentMediaID}`,
     );
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: {
           id,
           messageInfo: updatedMessage,
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStore,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === createLocalMessageActionType) {
     const messageInfo = ensureRealizedThreadIDIsUsedWhenPossible(
       action.payload,
       newThreadInfos,
     );
     const { localID, threadID } = messageInfo;
 
     const messageIDs =
       messageStore.threads[messageInfo.threadID]?.messageIDs ?? [];
     const now = Date.now();
     const threadState: ThreadMessageInfo = messageStore.threads[threadID]
       ? {
           ...messageStore.threads[threadID],
           messageIDs: [localID, ...messageIDs],
         }
       : {
           messageIDs: [localID],
           startReached: true,
           lastNavigatedTo: now,
           lastPruned: now,
         };
 
     const messageStoreOperations = [
       {
         type: 'replace',
         payload: { id: localID, messageInfo },
       },
       {
         type: 'replace_threads',
         payload: {
           threads: { [threadID]: threadState },
         },
       },
     ];
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     const newMessageStore = {
       ...messageStore,
       threads: {
         ...messageStore.threads,
         [threadID]: threadState,
       },
       messages: processedMessageStore.messages,
     };
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       newMessageStore,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: newMessageStore,
     };
   } else if (action.type === processServerRequestsActionType) {
     const {
       messageStoreOperations,
       messageStore: messageStoreAfterReassignment,
     } = reassignMessagesToRealizedThreads(messageStore, newThreadInfos);
 
     const processedMessageStore = processMessageStoreOperations(
       messageStore,
       messageStoreOperations,
     );
 
     assertMessageStoreThreadsAreEqual(
       processedMessageStore,
       messageStoreAfterReassignment,
       action.type,
     );
 
     return {
       messageStoreOperations,
       messageStore: {
         ...messageStoreAfterReassignment,
         messages: processedMessageStore.messages,
       },
     };
   } else if (action.type === setClientDBStoreActionType) {
     const payloadMessages = action.payload.messages;
     if (!payloadMessages) {
       return { messageStoreOperations: [], messageStore };
     }
     const actionPayloadMessageStoreThreads =
       translateClientDBThreadMessageInfos(
         action.payload.messageStoreThreads ?? [],
       );
 
     const newThreads = {};
     for (const threadID in actionPayloadMessageStoreThreads) {
       newThreads[threadID] = {
         ...actionPayloadMessageStoreThreads[threadID],
         messageIDs: messageStore.threads[threadID]?.messageIDs ?? [],
       };
     }
 
     assertMessageStoreThreadsAreEqual(
       {
         ...messageStore,
         threads: newThreads,
       },
       messageStore,
       `${action.type} | comparing SQLite with redux-persist`,
     );
 
     const { messageStoreOperations, messageStore: updatedMessageStore } =
       updateMessageStoreWithLatestThreadInfos(messageStore, newThreadInfos);
 
     let threads = { ...updatedMessageStore.threads };
     let local = { ...updatedMessageStore.local };
 
     // Store message IDs already contained within threads so that we
     // do not insert duplicates
     const existingMessageIDs = new Set();
     for (const threadID in threads) {
       threads[threadID].messageIDs.forEach(msgID => {
         existingMessageIDs.add(msgID);
       });
     }
     const threadsNeedMsgIDsResorting = new Set();
     const actionPayloadMessages =
       messageStoreOpsHandlers.translateClientDBData(payloadMessages);
 
     // When starting the app on native, we filter out any local-only multimedia
     // messages because the relevant context is no longer available
     const messageIDsToBeRemoved = [];
     const threadsToAdd = {};
     for (const id in actionPayloadMessages) {
       const message = actionPayloadMessages[id];
       const { threadID } = message;
       let existingThread = threads[threadID];
       if (!existingThread) {
         existingThread = newThread();
         threadsToAdd[threadID] = existingThread;
       }
       if (
         (message.type === messageTypes.IMAGES ||
           message.type === messageTypes.MULTIMEDIA) &&
         !message.id
       ) {
         messageIDsToBeRemoved.push(id);
         threads = {
           ...threads,
           [threadID]: {
             ...existingThread,
             messageIDs: existingThread.messageIDs.filter(
               curMessageID => curMessageID !== id,
             ),
           },
         };
         local = _pickBy(
           (localInfo: LocalMessageInfo, key: string) => key !== id,
         )(local);
       } else if (!existingMessageIDs.has(id)) {
         threads = {
           ...threads,
           [threadID]: {
             ...existingThread,
             messageIDs: [...existingThread.messageIDs, id],
           },
         };
         threadsNeedMsgIDsResorting.add(threadID);
       } else if (!threads[threadID]) {
         threads = { ...threads, [threadID]: existingThread };
       }
     }
 
     for (const threadID of threadsNeedMsgIDsResorting) {
       threads[threadID].messageIDs = sortMessageIDs(actionPayloadMessages)(
         threads[threadID].messageIDs,
       );
     }
 
     const newMessageStore = {
       ...updatedMessageStore,
       messages: actionPayloadMessages,
       threads: threads,
       local: local,
     };
 
     if (messageIDsToBeRemoved.length > 0) {
       messageStoreOperations.push({
         type: 'remove',
         payload: { ids: messageIDsToBeRemoved },
       });
     }
 
     const processedMessageStore = processMessageStoreOperations(
       newMessageStore,
       messageStoreOperations,
     );
 
     messageStoreOperations.push({
       type: 'replace_threads',
       payload: { threads: threadsToAdd },
     });
 
     return {
       messageStoreOperations,
       messageStore: processedMessageStore,
     };
   }
   return { messageStoreOperations: [], messageStore };
 }
 
 type MergedUpdatesWithMessages = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
 };
 function mergeUpdatesWithMessageInfos(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   truncationStatuses?: MessageTruncationStatuses,
 ): MergedUpdatesWithMessages {
   const messageIDs = new Set(messageInfos.map(messageInfo => messageInfo.id));
   const mergedMessageInfos = [...messageInfos];
   const mergedTruncationStatuses = { ...truncationStatuses };
 
   for (const updateInfo of newUpdates) {
     if (updateInfo.type !== updateTypes.JOIN_THREAD) {
       continue;
     }
     for (const messageInfo of updateInfo.rawMessageInfos) {
       if (messageIDs.has(messageInfo.id)) {
         continue;
       }
       mergedMessageInfos.push(messageInfo);
       messageIDs.add(messageInfo.id);
     }
 
     mergedTruncationStatuses[updateInfo.threadInfo.id] =
       combineTruncationStatuses(
         updateInfo.truncationStatus,
         mergedTruncationStatuses[updateInfo.threadInfo.id],
       );
   }
   return {
     rawMessageInfos: mergedMessageInfos,
     truncationStatuses: mergedTruncationStatuses,
   };
 }
 
 export { freshMessageStore, reduceMessageStore };
diff --git a/lib/reducers/message-reducer.test.js b/lib/reducers/message-reducer.test.js
index 3459bfc99..cea148977 100644
--- a/lib/reducers/message-reducer.test.js
+++ b/lib/reducers/message-reducer.test.js
@@ -1,319 +1,320 @@
 // @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,
       lastNavigatedTo: 1639522314170,
       lastPruned: 1639522292271,
     },
   },
   local: {},
-  currentAsOf: 1639522292174,
+  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 threads = {
     '88471': {
       messageIDs: ['local11', 'local10', '103502'],
       startReached: false,
       lastNavigatedTo: 1658172614602,
       lastPruned: 1658169913623,
     },
   };
 
   const { messageStore: updatedMessageStore } = reduceMessageStore(
     {
       messages: {},
       threads,
       local: {},
-      currentAsOf: 1234567890123,
+      currentAsOf: { [ashoatKeyserverID]: 1234567890123 },
     },
     {
       type: 'SET_CLIENT_DB_STORE',
       payload: {
         currentUserID: '',
         drafts: [],
         threadStore: {
           threadInfos: {},
         },
         messageStoreThreads: [],
         messages: clientDBMessages,
         reports: [],
       },
     },
     {
       [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/selectors/keyserver-selectors.js b/lib/selectors/keyserver-selectors.js
index 289db74fe..a660bf199 100644
--- a/lib/selectors/keyserver-selectors.js
+++ b/lib/selectors/keyserver-selectors.js
@@ -1,39 +1,43 @@
 // @flow
 
 import { createSelector } from 'reselect';
 
 import type { KeyserverInfo } from '../types/keyserver-types';
 import type { AppState } from '../types/redux-types.js';
 import { ashoatKeyserverID } from '../utils/validation-utils.js';
 
 const cookieSelector: (state: AppState) => ?string = (state: AppState) =>
   state.keyserverStore.keyserverInfos[ashoatKeyserverID]?.cookie;
 
 const cookiesSelector: (state: AppState) => {
   +[keyserverID: string]: string,
 } = createSelector(
   (state: AppState) => state.keyserverStore.keyserverInfos,
   (infos: { +[key: string]: KeyserverInfo }) => {
     const cookies = {};
     for (const keyserverID in infos) {
       cookies[keyserverID] = infos[keyserverID].cookie;
     }
     return cookies;
   },
 );
 
 const sessionIDSelector: (state: AppState) => ?string = (state: AppState) =>
   state.keyserverStore.keyserverInfos[ashoatKeyserverID]?.sessionID;
 
 const updatesCurrentAsOfSelector: (state: AppState) => number = (
   state: AppState,
 ) =>
   state.keyserverStore.keyserverInfos[ashoatKeyserverID]?.updatesCurrentAsOf ??
   0;
 
+const currentAsOfSelector: (state: AppState) => number = (state: AppState) =>
+  state.messageStore.currentAsOf[ashoatKeyserverID] ?? 0;
+
 export {
   cookieSelector,
   cookiesSelector,
   sessionIDSelector,
   updatesCurrentAsOfSelector,
+  currentAsOfSelector,
 };
diff --git a/lib/selectors/socket-selectors.js b/lib/selectors/socket-selectors.js
index 1ed5f4df4..93fee07a3 100644
--- a/lib/selectors/socket-selectors.js
+++ b/lib/selectors/socket-selectors.js
@@ -1,255 +1,258 @@
 // @flow
 
 import { createSelector } from 'reselect';
 import t from 'tcomb';
 
-import { updatesCurrentAsOfSelector } from './keyserver-selectors.js';
+import {
+  updatesCurrentAsOfSelector,
+  currentAsOfSelector,
+} from './keyserver-selectors.js';
 import { currentCalendarQuery } from './nav-selectors.js';
 import {
   serverEntryInfo,
   serverEntryInfosObject,
   filterRawEntryInfosByCalendarQuery,
 } from '../shared/entry-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type { SignedIdentityKeysBlob } from '../types/crypto-types.js';
 import {
   type RawEntryInfo,
   rawEntryInfoValidator,
   type CalendarQuery,
 } from '../types/entry-types.js';
 import type { AppState } from '../types/redux-types.js';
 import type { ClientReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   type ClientServerRequest,
   type ClientClientResponse,
 } from '../types/request-types.js';
 import type { SessionState } from '../types/session-types.js';
 import type { OneTimeKeyGenerator } from '../types/socket-types.js';
 import {
   type RawThreadInfo,
   rawThreadInfoValidator,
 } from '../types/thread-types.js';
 import {
   type CurrentUserInfo,
   currentUserInfoValidator,
   type UserInfos,
   userInfosValidator,
 } from '../types/user-types.js';
 import { getConfig } from '../utils/config.js';
 import { minimumOneTimeKeysRequired } from '../utils/crypto-utils.js';
 import { values, hash } from '../utils/objects.js';
 import {
   tID,
   convertClientIDsToServerIDs,
   ashoatKeyserverID,
 } from '../utils/validation-utils.js';
 
 const queuedReports: (
   state: AppState,
 ) => $ReadOnlyArray<ClientReportCreationRequest> = createSelector(
   (state: AppState) => state.reportStore.queuedReports,
   (
     mainQueuedReports: $ReadOnlyArray<ClientReportCreationRequest>,
   ): $ReadOnlyArray<ClientReportCreationRequest> => mainQueuedReports,
 );
 
 const getClientResponsesSelector: (
   state: AppState,
 ) => (
   calendarActive: boolean,
   oneTimeKeyGenerator: ?OneTimeKeyGenerator,
   getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
   getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
   (state: AppState) => state.threadStore.threadInfos,
   (state: AppState) => state.entryStore.entryInfos,
   (state: AppState) => state.userStore.userInfos,
   (state: AppState) => state.currentUserInfo,
   currentCalendarQuery,
   (
     threadInfos: { +[id: string]: RawThreadInfo },
     entryInfos: { +[id: string]: RawEntryInfo },
     userInfos: UserInfos,
     currentUserInfo: ?CurrentUserInfo,
     calendarQuery: (calendarActive: boolean) => CalendarQuery,
   ) => {
     return async (
       calendarActive: boolean,
       oneTimeKeyGenerator: ?OneTimeKeyGenerator,
       getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
       getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
       serverRequests: $ReadOnlyArray<ClientServerRequest>,
     ): Promise<$ReadOnlyArray<ClientClientResponse>> => {
       const clientResponses = [];
       const serverRequestedPlatformDetails = serverRequests.some(
         request => request.type === serverRequestTypes.PLATFORM_DETAILS,
       );
       for (const serverRequest of serverRequests) {
         if (
           serverRequest.type === serverRequestTypes.PLATFORM &&
           !serverRequestedPlatformDetails
         ) {
           clientResponses.push({
             type: serverRequestTypes.PLATFORM,
             platform: getConfig().platformDetails.platform,
           });
         } else if (serverRequest.type === serverRequestTypes.PLATFORM_DETAILS) {
           clientResponses.push({
             type: serverRequestTypes.PLATFORM_DETAILS,
             platformDetails: getConfig().platformDetails,
           });
         } else if (serverRequest.type === serverRequestTypes.CHECK_STATE) {
           const filteredEntryInfos = filterRawEntryInfosByCalendarQuery(
             serverEntryInfosObject(values(entryInfos)),
             calendarQuery(calendarActive),
           );
 
           const convertedEntryInfos = convertClientIDsToServerIDs(
             ashoatKeyserverID,
             t.dict(tID, rawEntryInfoValidator),
             filteredEntryInfos,
           );
 
           const convertedThreadInfos = convertClientIDsToServerIDs(
             ashoatKeyserverID,
             t.dict(tID, rawThreadInfoValidator),
             threadInfos,
           );
 
           const convertedUserInfos = convertClientIDsToServerIDs(
             ashoatKeyserverID,
             userInfosValidator,
             userInfos,
           );
 
           const convertedCurrentUserInfo = convertClientIDsToServerIDs(
             ashoatKeyserverID,
             t.maybe(currentUserInfoValidator),
             currentUserInfo,
           );
 
           const hashResults = {};
           for (const key in serverRequest.hashesToCheck) {
             const expectedHashValue = serverRequest.hashesToCheck[key];
             let hashValue;
             if (key === 'threadInfos') {
               hashValue = hash(convertedThreadInfos);
             } else if (key === 'entryInfos') {
               hashValue = hash(convertedEntryInfos);
             } else if (key === 'userInfos') {
               hashValue = hash(convertedUserInfos);
             } else if (key === 'currentUserInfo') {
               hashValue = hash(convertedCurrentUserInfo);
             } else if (key.startsWith('threadInfo|')) {
               const [, threadID] = key.split('|');
               hashValue = hash(convertedThreadInfos[threadID]);
             } else if (key.startsWith('entryInfo|')) {
               const [, entryID] = key.split('|');
               let rawEntryInfo = convertedEntryInfos[entryID];
               if (rawEntryInfo) {
                 rawEntryInfo = serverEntryInfo(rawEntryInfo);
               }
               hashValue = hash(rawEntryInfo);
             } else if (key.startsWith('userInfo|')) {
               const [, userID] = key.split('|');
               hashValue = hash(convertedUserInfos[userID]);
             } else {
               continue;
             }
             hashResults[key] = expectedHashValue === hashValue;
           }
 
           const { failUnmentioned } = serverRequest;
           if (failUnmentioned && failUnmentioned.threadInfos) {
             for (const threadID in convertedThreadInfos) {
               const key = `threadInfo|${threadID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
           if (failUnmentioned && failUnmentioned.entryInfos) {
             for (const entryID in convertedEntryInfos) {
               const key = `entryInfo|${entryID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
           if (failUnmentioned && failUnmentioned.userInfos) {
             for (const userID in convertedUserInfos) {
               const key = `userInfo|${userID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
 
           clientResponses.push({
             type: serverRequestTypes.CHECK_STATE,
             hashResults,
           });
         } else if (
           serverRequest.type === serverRequestTypes.MORE_ONE_TIME_KEYS &&
           oneTimeKeyGenerator
         ) {
           const keys: string[] = [];
           for (let i = 0; i < minimumOneTimeKeysRequired; ++i) {
             keys.push(oneTimeKeyGenerator(i));
           }
           clientResponses.push({
             type: serverRequestTypes.MORE_ONE_TIME_KEYS,
             keys,
           });
         } else if (
           serverRequest.type === serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB &&
           getSignedIdentityKeysBlob
         ) {
           const signedIdentityKeysBlob = await getSignedIdentityKeysBlob();
           clientResponses.push({
             type: serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB,
             signedIdentityKeysBlob,
           });
         } else if (
           serverRequest.type ===
             serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE &&
           getInitialNotificationsEncryptedMessage
         ) {
           const initialNotificationsEncryptedMessage =
             await getInitialNotificationsEncryptedMessage();
           clientResponses.push({
             type: serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE,
             initialNotificationsEncryptedMessage,
           });
         }
       }
       return clientResponses;
     };
   },
 );
 
 const sessionStateFuncSelector: (
   state: AppState,
 ) => (calendarActive: boolean) => SessionState = createSelector(
-  (state: AppState) => state.messageStore.currentAsOf,
+  currentAsOfSelector,
   updatesCurrentAsOfSelector,
   currentCalendarQuery,
   (
       messagesCurrentAsOf: number,
       updatesCurrentAsOf: number,
       calendarQuery: (calendarActive: boolean) => CalendarQuery,
     ) =>
     (calendarActive: boolean): SessionState => ({
       calendarQuery: calendarQuery(calendarActive),
       messagesCurrentAsOf,
       updatesCurrentAsOf,
       watchedIDs: threadWatcher.getWatchedIDs(),
     }),
 );
 
 export { queuedReports, getClientResponsesSelector, sessionStateFuncSelector };
diff --git a/lib/types/message-types.js b/lib/types/message-types.js
index 2cf9904f8..63ad3e11a 100644
--- a/lib/types/message-types.js
+++ b/lib/types/message-types.js
@@ -1,660 +1,660 @@
 // @flow
 
 import invariant from 'invariant';
 import t, {
   type TDict,
   type TEnums,
   type TInterface,
   type TUnion,
 } from 'tcomb';
 
 import { type ClientDBMediaInfo } from './media-types.js';
 import { type MessageType, messageTypes } from './message-types-enum.js';
 import {
   type AddMembersMessageData,
   type AddMembersMessageInfo,
   type RawAddMembersMessageInfo,
   rawAddMembersMessageInfoValidator,
 } from './messages/add-members.js';
 import {
   type ChangeRoleMessageData,
   type ChangeRoleMessageInfo,
   type RawChangeRoleMessageInfo,
   rawChangeRoleMessageInfoValidator,
 } from './messages/change-role.js';
 import {
   type ChangeSettingsMessageData,
   type ChangeSettingsMessageInfo,
   type RawChangeSettingsMessageInfo,
   rawChangeSettingsMessageInfoValidator,
 } from './messages/change-settings.js';
 import {
   type CreateEntryMessageData,
   type CreateEntryMessageInfo,
   type RawCreateEntryMessageInfo,
   rawCreateEntryMessageInfoValidator,
 } from './messages/create-entry.js';
 import {
   type CreateSidebarMessageData,
   type CreateSidebarMessageInfo,
   type RawCreateSidebarMessageInfo,
   rawCreateSidebarMessageInfoValidator,
 } from './messages/create-sidebar.js';
 import {
   type CreateSubthreadMessageData,
   type CreateSubthreadMessageInfo,
   type RawCreateSubthreadMessageInfo,
   rawCreateSubthreadMessageInfoValidator,
 } from './messages/create-subthread.js';
 import {
   type CreateThreadMessageData,
   type CreateThreadMessageInfo,
   type RawCreateThreadMessageInfo,
   rawCreateThreadMessageInfoValidator,
 } from './messages/create-thread.js';
 import {
   type DeleteEntryMessageData,
   type DeleteEntryMessageInfo,
   type RawDeleteEntryMessageInfo,
   rawDeleteEntryMessageInfoValidator,
 } from './messages/delete-entry.js';
 import {
   type EditEntryMessageData,
   type EditEntryMessageInfo,
   type RawEditEntryMessageInfo,
   rawEditEntryMessageInfoValidator,
 } from './messages/edit-entry.js';
 import {
   type EditMessageData,
   type EditMessageInfo,
   type RawEditMessageInfo,
   rawEditMessageInfoValidator,
 } from './messages/edit.js';
 import {
   type ImagesMessageData,
   type ImagesMessageInfo,
   type RawImagesMessageInfo,
   rawImagesMessageInfoValidator,
 } from './messages/images.js';
 import {
   type JoinThreadMessageData,
   type JoinThreadMessageInfo,
   type RawJoinThreadMessageInfo,
   rawJoinThreadMessageInfoValidator,
 } from './messages/join-thread.js';
 import {
   type LeaveThreadMessageData,
   type LeaveThreadMessageInfo,
   type RawLeaveThreadMessageInfo,
   rawLeaveThreadMessageInfoValidator,
 } from './messages/leave-thread.js';
 import {
   type MediaMessageData,
   type MediaMessageInfo,
   type MediaMessageServerDBContent,
   type RawMediaMessageInfo,
   rawMediaMessageInfoValidator,
 } from './messages/media.js';
 import {
   type RawReactionMessageInfo,
   rawReactionMessageInfoValidator,
   type ReactionMessageData,
   type ReactionMessageInfo,
 } from './messages/reaction.js';
 import {
   type RawRemoveMembersMessageInfo,
   rawRemoveMembersMessageInfoValidator,
   type RemoveMembersMessageData,
   type RemoveMembersMessageInfo,
 } from './messages/remove-members.js';
 import {
   type RawRestoreEntryMessageInfo,
   rawRestoreEntryMessageInfoValidator,
   type RestoreEntryMessageData,
   type RestoreEntryMessageInfo,
 } from './messages/restore-entry.js';
 import {
   type RawTextMessageInfo,
   rawTextMessageInfoValidator,
   type TextMessageData,
   type TextMessageInfo,
 } from './messages/text.js';
 import {
   type RawTogglePinMessageInfo,
   rawTogglePinMessageInfoValidator,
   type TogglePinMessageData,
   type TogglePinMessageInfo,
 } from './messages/toggle-pin.js';
 import {
   type RawUnsupportedMessageInfo,
   rawUnsupportedMessageInfoValidator,
   type UnsupportedMessageInfo,
 } from './messages/unsupported.js';
 import {
   type RawUpdateRelationshipMessageInfo,
   rawUpdateRelationshipMessageInfoValidator,
   type UpdateRelationshipMessageData,
   type UpdateRelationshipMessageInfo,
 } from './messages/update-relationship.js';
 import { type RelativeUserInfo, type UserInfos } from './user-types.js';
 import type { CallServerEndpointResultInfoInterface } from '../utils/call-server-endpoint.js';
 import { values } from '../utils/objects.js';
 import { tID, tNumber, tShape } from '../utils/validation-utils.js';
 
 const composableMessageTypes = new Set([
   messageTypes.TEXT,
   messageTypes.IMAGES,
   messageTypes.MULTIMEDIA,
 ]);
 export function isComposableMessageType(ourMessageType: MessageType): boolean {
   return composableMessageTypes.has(ourMessageType);
 }
 export function assertComposableMessageType(
   ourMessageType: MessageType,
 ): MessageType {
   invariant(
     isComposableMessageType(ourMessageType),
     'MessageType is not composed',
   );
   return ourMessageType;
 }
 export function assertComposableRawMessage(
   message: RawMessageInfo,
 ): RawComposableMessageInfo {
   invariant(
     message.type === messageTypes.TEXT ||
       message.type === messageTypes.IMAGES ||
       message.type === messageTypes.MULTIMEDIA,
     'Message is not composable',
   );
   return message;
 }
 export function messageDataLocalID(messageData: MessageData): ?string {
   if (
     messageData.type !== messageTypes.TEXT &&
     messageData.type !== messageTypes.IMAGES &&
     messageData.type !== messageTypes.MULTIMEDIA &&
     messageData.type !== messageTypes.REACTION
   ) {
     return null;
   }
   return messageData.localID;
 }
 
 export function isMessageSidebarSourceReactionOrEdit(
   message: RawMessageInfo | MessageInfo,
 ): boolean %checks {
   return (
     message.type === messageTypes.SIDEBAR_SOURCE ||
     message.type === messageTypes.REACTION ||
     message.type === messageTypes.EDIT_MESSAGE
   );
 }
 
 const mediaMessageTypes = new Set([
   messageTypes.IMAGES,
   messageTypes.MULTIMEDIA,
 ]);
 export function isMediaMessageType(ourMessageType: MessageType): boolean {
   return mediaMessageTypes.has(ourMessageType);
 }
 export function assertMediaMessageType(
   ourMessageType: MessageType,
 ): MessageType {
   invariant(isMediaMessageType(ourMessageType), 'MessageType is not media');
   return ourMessageType;
 }
 
 // *MessageData = passed to createMessages function to insert into database
 // Raw*MessageInfo = used by server, and contained in client's local store
 // *MessageInfo = used by client in UI code
 
 export type SidebarSourceMessageData = {
   +type: 17,
   +threadID: string,
   +creatorID: string,
   +time: number,
   +sourceMessage?: RawComposableMessageInfo | RawRobotextMessageInfo,
 };
 
 export type MessageData =
   | TextMessageData
   | CreateThreadMessageData
   | AddMembersMessageData
   | CreateSubthreadMessageData
   | ChangeSettingsMessageData
   | RemoveMembersMessageData
   | ChangeRoleMessageData
   | LeaveThreadMessageData
   | JoinThreadMessageData
   | CreateEntryMessageData
   | EditEntryMessageData
   | DeleteEntryMessageData
   | RestoreEntryMessageData
   | ImagesMessageData
   | MediaMessageData
   | UpdateRelationshipMessageData
   | SidebarSourceMessageData
   | CreateSidebarMessageData
   | ReactionMessageData
   | EditMessageData
   | TogglePinMessageData;
 
 export type MultimediaMessageData = ImagesMessageData | MediaMessageData;
 
 export type RawMultimediaMessageInfo =
   | RawImagesMessageInfo
   | RawMediaMessageInfo;
 export const rawMultimediaMessageInfoValidator: TUnion<RawMultimediaMessageInfo> =
   t.union([rawImagesMessageInfoValidator, rawMediaMessageInfoValidator]);
 
 export type RawComposableMessageInfo =
   | RawTextMessageInfo
   | RawMultimediaMessageInfo;
 const rawComposableMessageInfoValidator = t.union([
   rawTextMessageInfoValidator,
   rawMultimediaMessageInfoValidator,
 ]);
 
 export type RawRobotextMessageInfo =
   | RawCreateThreadMessageInfo
   | RawAddMembersMessageInfo
   | RawCreateSubthreadMessageInfo
   | RawChangeSettingsMessageInfo
   | RawRemoveMembersMessageInfo
   | RawChangeRoleMessageInfo
   | RawLeaveThreadMessageInfo
   | RawJoinThreadMessageInfo
   | RawCreateEntryMessageInfo
   | RawEditEntryMessageInfo
   | RawDeleteEntryMessageInfo
   | RawRestoreEntryMessageInfo
   | RawUpdateRelationshipMessageInfo
   | RawCreateSidebarMessageInfo
   | RawUnsupportedMessageInfo
   | RawTogglePinMessageInfo;
 const rawRobotextMessageInfoValidator = t.union([
   rawCreateThreadMessageInfoValidator,
   rawAddMembersMessageInfoValidator,
   rawCreateSubthreadMessageInfoValidator,
   rawChangeSettingsMessageInfoValidator,
   rawRemoveMembersMessageInfoValidator,
   rawChangeRoleMessageInfoValidator,
   rawLeaveThreadMessageInfoValidator,
   rawJoinThreadMessageInfoValidator,
   rawCreateEntryMessageInfoValidator,
   rawEditEntryMessageInfoValidator,
   rawDeleteEntryMessageInfoValidator,
   rawRestoreEntryMessageInfoValidator,
   rawUpdateRelationshipMessageInfoValidator,
   rawCreateSidebarMessageInfoValidator,
   rawUnsupportedMessageInfoValidator,
   rawTogglePinMessageInfoValidator,
 ]);
 
 export type RawSidebarSourceMessageInfo = {
   ...SidebarSourceMessageData,
   id: string,
 };
 export const rawSidebarSourceMessageInfoValidator: TInterface<RawSidebarSourceMessageInfo> =
   tShape<RawSidebarSourceMessageInfo>({
     type: tNumber(messageTypes.SIDEBAR_SOURCE),
     threadID: tID,
     creatorID: t.String,
     time: t.Number,
     sourceMessage: t.maybe(
       t.union([
         rawComposableMessageInfoValidator,
         rawRobotextMessageInfoValidator,
       ]),
     ),
     id: tID,
   });
 
 export type RawMessageInfo =
   | RawComposableMessageInfo
   | RawRobotextMessageInfo
   | RawSidebarSourceMessageInfo
   | RawReactionMessageInfo
   | RawEditMessageInfo;
 export const rawMessageInfoValidator: TUnion<RawMessageInfo> = t.union([
   rawComposableMessageInfoValidator,
   rawRobotextMessageInfoValidator,
   rawSidebarSourceMessageInfoValidator,
   rawReactionMessageInfoValidator,
   rawEditMessageInfoValidator,
 ]);
 
 export type LocallyComposedMessageInfo =
   | ({
       ...RawImagesMessageInfo,
       +localID: string,
     } & RawImagesMessageInfo)
   | ({
       ...RawMediaMessageInfo,
       +localID: string,
     } & RawMediaMessageInfo)
   | ({
       ...RawTextMessageInfo,
       +localID: string,
     } & RawTextMessageInfo)
   | ({
       ...RawReactionMessageInfo,
       +localID: string,
     } & RawReactionMessageInfo);
 
 export type MultimediaMessageInfo = ImagesMessageInfo | MediaMessageInfo;
 export type ComposableMessageInfo = TextMessageInfo | MultimediaMessageInfo;
 
 export type RobotextMessageInfo =
   | CreateThreadMessageInfo
   | AddMembersMessageInfo
   | CreateSubthreadMessageInfo
   | ChangeSettingsMessageInfo
   | RemoveMembersMessageInfo
   | ChangeRoleMessageInfo
   | LeaveThreadMessageInfo
   | JoinThreadMessageInfo
   | CreateEntryMessageInfo
   | EditEntryMessageInfo
   | DeleteEntryMessageInfo
   | RestoreEntryMessageInfo
   | UnsupportedMessageInfo
   | UpdateRelationshipMessageInfo
   | CreateSidebarMessageInfo
   | TogglePinMessageInfo;
 export type PreviewableMessageInfo =
   | RobotextMessageInfo
   | MultimediaMessageInfo
   | ReactionMessageInfo;
 
 export type SidebarSourceMessageInfo = {
   +type: 17,
   +id: string,
   +threadID: string,
   +creator: RelativeUserInfo,
   +time: number,
   +sourceMessage: ComposableMessageInfo | RobotextMessageInfo,
 };
 
 export type MessageInfo =
   | ComposableMessageInfo
   | RobotextMessageInfo
   | SidebarSourceMessageInfo
   | ReactionMessageInfo
   | EditMessageInfo;
 
 export type ThreadMessageInfo = {
   messageIDs: string[],
   startReached: boolean,
   lastNavigatedTo: number, // millisecond timestamp
   lastPruned: number, // millisecond timestamp
 };
 const threadMessageInfoValidator: TInterface<ThreadMessageInfo> =
   tShape<ThreadMessageInfo>({
     messageIDs: t.list(tID),
     startReached: t.Boolean,
     lastNavigatedTo: t.Number,
     lastPruned: t.Number,
   });
 
 // Tracks client-local information about a message that hasn't been assigned an
 // ID by the server yet. As soon as the client gets an ack from the server for
 // this message, it will clear the LocalMessageInfo.
 export type LocalMessageInfo = {
   +sendFailed?: boolean,
 };
 const localMessageInfoValidator: TInterface<LocalMessageInfo> =
   tShape<LocalMessageInfo>({
     sendFailed: t.maybe(t.Boolean),
   });
 
 export type MessageStoreThreads = {
   +[threadID: string]: ThreadMessageInfo,
 };
 const messageStoreThreadsValidator: TDict<MessageStoreThreads> = t.dict(
   tID,
   threadMessageInfoValidator,
 );
 
 export type MessageStore = {
   +messages: { +[id: string]: RawMessageInfo },
   +threads: MessageStoreThreads,
   +local: { +[id: string]: LocalMessageInfo },
-  +currentAsOf: number,
+  +currentAsOf: { +[keyserverID: string]: number },
 };
 export const messageStoreValidator: TInterface<MessageStore> =
   tShape<MessageStore>({
     messages: t.dict(tID, rawMessageInfoValidator),
     threads: messageStoreThreadsValidator,
     local: t.dict(t.String, localMessageInfoValidator),
-    currentAsOf: t.Number,
+    currentAsOf: t.dict(t.String, t.Number),
   });
 
 // We were initially using `number`s` for `thread`, `type`, `future_type`, etc.
 // However, we ended up changing `thread` to `string` to account for thread IDs
 // including information about the keyserver (eg 'GENESIS|123') in the future.
 //
 // At that point we discussed whether we should switch the remaining `number`
 // fields to `string`s for consistency and flexibility. We researched whether
 // there was any performance cost to using `string`s instead of `number`s and
 // found the differences to be negligible. We also concluded using `string`s
 // may be safer after considering `jsi::Number` and the various C++ number
 // representations on the CommCoreModule side.
 export type ClientDBMessageInfo = {
   +id: string,
   +local_id: ?string,
   +thread: string,
   +user: string,
   +type: string,
   +future_type: ?string,
   +content: ?string,
   +time: string,
   +media_infos: ?$ReadOnlyArray<ClientDBMediaInfo>,
 };
 
 export type ClientDBThreadMessageInfo = {
   +id: string,
   +start_reached: string,
   +last_navigated_to: string,
   +last_pruned: string,
 };
 
 export const messageTruncationStatus = Object.freeze({
   // EXHAUSTIVE means we've reached the start of the thread. Either the result
   // set includes the very first message for that thread, or there is nothing
   // behind the cursor you queried for. Given that the client only ever issues
   // ranged queries whose range, when unioned with what is in state, represent
   // the set of all messages for a given thread, we can guarantee that getting
   // EXHAUSTIVE means the start has been reached.
   EXHAUSTIVE: 'exhaustive',
   // TRUNCATED is rare, and means that the server can't guarantee that the
   // result set for a given thread is contiguous with what the client has in its
   // state. If the client can't verify the contiguousness itself, it needs to
   // replace its Redux store's contents with what it is in this payload.
   //  1) getMessageInfosSince: Result set for thread is equal to max, and the
   //     truncation status isn't EXHAUSTIVE (ie. doesn't include the very first
   //     message).
   //  2) getMessageInfos: MessageSelectionCriteria does not specify cursors, the
   //     result set for thread is equal to max, and the truncation status isn't
   //     EXHAUSTIVE. If cursors are specified, we never return truncated, since
   //     the cursor given us guarantees the contiguousness of the result set.
   // Note that in the reducer, we can guarantee contiguousness if there is any
   // intersection between messageIDs in the result set and the set currently in
   // the Redux store.
   TRUNCATED: 'truncated',
   // UNCHANGED means the result set is guaranteed to be contiguous with what the
   // client has in its state, but is not EXHAUSTIVE. Basically, it's anything
   // that isn't either EXHAUSTIVE or TRUNCATED.
   UNCHANGED: 'unchanged',
 });
 export type MessageTruncationStatus = $Values<typeof messageTruncationStatus>;
 export function assertMessageTruncationStatus(
   ourMessageTruncationStatus: string,
 ): MessageTruncationStatus {
   invariant(
     ourMessageTruncationStatus === 'truncated' ||
       ourMessageTruncationStatus === 'unchanged' ||
       ourMessageTruncationStatus === 'exhaustive',
     'string is not ourMessageTruncationStatus enum',
   );
   return ourMessageTruncationStatus;
 }
 export const messageTruncationStatusValidator: TEnums = t.enums.of(
   values(messageTruncationStatus),
 );
 export type MessageTruncationStatuses = {
   [threadID: string]: MessageTruncationStatus,
 };
 export const messageTruncationStatusesValidator: TDict<MessageTruncationStatuses> =
   t.dict(tID, messageTruncationStatusValidator);
 
 export type ThreadCursors = { +[threadID: string]: ?string };
 
 export type MessageSelectionCriteria = {
   +threadCursors?: ?ThreadCursors,
   +joinedThreads?: ?boolean,
   +newerThan?: ?number,
 };
 
 export type FetchMessageInfosRequest = {
   +cursors: ThreadCursors,
   +numberPerThread?: ?number,
 };
 export type FetchMessageInfosResponse = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: UserInfos,
 };
 export type FetchMessageInfosResult = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
 };
 export type FetchMessageInfosPayload = {
   +threadID: string,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatus: MessageTruncationStatus,
 };
 export type MessagesResponse = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +currentAsOf: number,
 };
 export const messagesResponseValidator: TInterface<MessagesResponse> =
   tShape<MessagesResponse>({
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     currentAsOf: t.Number,
   });
 export type SimpleMessagesPayload = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
 };
 export const defaultNumberPerThread = 20;
 export const defaultMaxMessageAge = 14 * 24 * 60 * 60 * 1000; // 2 weeks
 
 export type SendMessageResponse = {
   +newMessageInfo: RawMessageInfo,
 };
 export type SendMessageResult = {
   +id: string,
   +time: number,
   +interface: CallServerEndpointResultInfoInterface,
 };
 
 export type SendMessagePayload = {
   +localID: string,
   +serverID: string,
   +threadID: string,
   +time: number,
   +interface: CallServerEndpointResultInfoInterface,
 };
 
 export type SendTextMessageRequest = {
   +threadID: string,
   +localID?: string,
   +text: string,
   +sidebarCreation?: boolean,
 };
 export type SendMultimediaMessageRequest =
   // This option is only used for messageTypes.IMAGES
   | {
       +threadID: string,
       +localID: string,
       +sidebarCreation?: boolean,
       +mediaIDs: $ReadOnlyArray<string>,
     }
   | {
       +threadID: string,
       +localID: string,
       +sidebarCreation?: boolean,
       +mediaMessageContents: $ReadOnlyArray<MediaMessageServerDBContent>,
     };
 
 export type SendReactionMessageRequest = {
   +threadID: string,
   +localID?: string,
   +targetMessageID: string,
   +reaction: string,
   +action: 'add_reaction' | 'remove_reaction',
 };
 
 export type SendEditMessageRequest = {
   +targetMessageID: string,
   +text: string,
 };
 
 export type SendEditMessageResponse = {
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type EditMessagePayload = SendEditMessageResponse;
 export type SendEditMessageResult = SendEditMessageResponse;
 
 export type EditMessageContent = {
   +text: string,
 };
 
 // Used for the message info included in log-in type actions
 export type GenericMessagesResult = {
   +messageInfos: RawMessageInfo[],
   +truncationStatus: MessageTruncationStatuses,
   +watchedIDsAtRequestTime: $ReadOnlyArray<string>,
   +currentAsOf: number,
 };
 
 export type SaveMessagesPayload = {
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +updatesCurrentAsOf: number,
 };
 
 export type NewMessagesPayload = {
   +messagesResult: MessagesResponse,
 };
 export const newMessagesPayloadValidator: TInterface<NewMessagesPayload> =
   tShape<NewMessagesPayload>({
     messagesResult: messagesResponseValidator,
   });
 
 export type MessageStorePrunePayload = {
   +threadIDs: $ReadOnlyArray<string>,
 };
 
 export type FetchPinnedMessagesRequest = {
   +threadID: string,
 };
 
 export type FetchPinnedMessagesResult = {
   +pinnedMessages: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type SearchMessagesRequest = {
   +query: string,
   +threadID: string,
   +cursor?: string,
 };
 
 export type SearchMessagesResponse = {
   +messages: $ReadOnlyArray<RawMessageInfo>,
   +endReached: boolean,
 };
diff --git a/native/redux/persist.js b/native/redux/persist.js
index 227aa6370..2bee848af 100644
--- a/native/redux/persist.js
+++ b/native/redux/persist.js
@@ -1,788 +1,799 @@
 // @flow
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import invariant from 'invariant';
 import { Platform } from 'react-native';
 import Orientation from 'react-native-orientation-locker';
 import { createTransform } from 'redux-persist';
 import type { Transform } from 'redux-persist/es/types.js';
 
 import {
   convertEntryStoreToNewIDSchema,
   convertInviteLinksStoreToNewIDSchema,
   convertMessageStoreToNewIDSchema,
   convertRawMessageInfoToNewIDSchema,
   convertCalendarFilterToNewIDSchema,
   convertConnectionInfoToNewIDSchema,
 } from 'lib/_generated/migration-utils.js';
 import {
   type ClientDBMessageStoreOperation,
   messageStoreOpsHandlers,
 } from 'lib/ops/message-store-ops.js';
 import {
   type ReportStoreOperation,
   type ClientDBReportStoreOperation,
   convertReportsToReplaceReportOps,
   reportStoreOpsHandlers,
 } from 'lib/ops/report-store-ops.js';
 import type { ClientDBThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import { highestLocalIDSelector } from 'lib/selectors/local-id-selectors.js';
 import { createAsyncMigrate } from 'lib/shared/create-async-migrate.js';
 import { inconsistencyResponsesToReports } from 'lib/shared/report-utils.js';
 import {
   getContainingThreadID,
   getCommunity,
 } from 'lib/shared/thread-utils.js';
 import {
   DEPRECATED_unshimMessageStore,
   unshimFunc,
 } from 'lib/shared/unshim-utils.js';
 import { defaultEnabledApps } from 'lib/types/enabled-apps.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type LocalMessageInfo,
   type MessageStore,
 } from 'lib/types/message-types.js';
 import type {
   ReportStore,
   ClientReportCreationRequest,
 } from 'lib/types/report-types.js';
 import { defaultConnectionInfo } from 'lib/types/socket-types.js';
 import type { ClientDBThreadInfo } from 'lib/types/thread-types.js';
 import {
   translateClientDBMessageInfoToRawMessageInfo,
   translateRawMessageInfoToClientDBMessageInfo,
 } from 'lib/utils/message-ops-utils.js';
 import {
   generateIDSchemaMigrationOpsForDrafts,
   convertMessageStoreThreadsToNewIDSchema,
   convertThreadStoreThreadInfosToNewIDSchema,
 } from 'lib/utils/migration-utils.js';
 import { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import {
   convertClientDBThreadInfoToRawThreadInfo,
   convertRawThreadInfoToClientDBThreadInfo,
 } from 'lib/utils/thread-ops-utils.js';
 import { getUUID } from 'lib/utils/uuid.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateClientDBThreadStoreThreadInfos,
   createUpdateDBOpsForThreadStoreThreadInfos,
   createUpdateDBOpsForMessageStoreMessages,
   createUpdateDBOpsForMessageStoreThreads,
 } from './client-db-utils.js';
 import { migrateThreadStoreForEditThreadPermissions } from './edit-thread-permission-migration.js';
 import { persistMigrationForManagePinsThreadPermission } from './manage-pins-permission-migration.js';
 import type { AppState } from './state-types.js';
 import { unshimClientDB } from './unshim-utils.js';
 import { updateRolesAndPermissions } from './update-roles-and-permissions.js';
 import { commCoreModule } from '../native-modules.js';
 import { defaultDeviceCameraInfo } from '../types/camera.js';
 import { defaultGlobalThemeInfo } from '../types/themes.js';
 import { isTaskCancelledError } from '../utils/error-handling.js';
 
 const migrations = {
   [1]: (state: AppState) => ({
     ...state,
     notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
   }),
   [2]: (state: AppState) => ({
     ...state,
     messageSentFromRoute: [],
   }),
   [3]: state => ({
     currentUserInfo: state.currentUserInfo,
     entryStore: state.entryStore,
     threadInfos: state.threadInfos,
     userInfos: state.userInfos,
     messageStore: {
       ...state.messageStore,
       currentAsOf: state.currentAsOf,
     },
     updatesCurrentAsOf: state.currentAsOf,
     cookie: state.cookie,
     deviceToken: state.deviceToken,
     urlPrefix: state.urlPrefix,
     customServer: state.customServer,
     notifPermissionAlertInfo: state.notifPermissionAlertInfo,
     messageSentFromRoute: state.messageSentFromRoute,
     _persist: state._persist,
   }),
   [4]: (state: AppState) => ({
     ...state,
     pingTimestamps: undefined,
     activeServerRequests: undefined,
   }),
   [5]: (state: AppState) => ({
     ...state,
     calendarFilters: defaultCalendarFilters,
   }),
   [6]: state => ({
     ...state,
     threadInfos: undefined,
     threadStore: {
       threadInfos: state.threadInfos,
       inconsistencyResponses: [],
     },
   }),
   [7]: state => ({
     ...state,
     lastUserInteraction: undefined,
     sessionID: undefined,
     entryStore: {
       ...state.entryStore,
       inconsistencyResponses: [],
     },
   }),
   [8]: (state: AppState) => ({
     ...state,
     pingTimestamps: undefined,
     activeServerRequests: undefined,
     connection: defaultConnectionInfo(Platform.OS),
     watchedThreadIDs: [],
     entryStore: {
       ...state.entryStore,
       actualizedCalendarQuery: undefined,
     },
   }),
   [9]: (state: AppState) => ({
     ...state,
     connection: {
       ...state.connection,
       lateResponses: [],
     },
   }),
   [10]: (state: AppState) => ({
     ...state,
     nextLocalID: highestLocalIDSelector(state) + 1,
     connection: {
       ...state.connection,
       showDisconnectedBar: false,
     },
     messageStore: {
       ...state.messageStore,
       local: {},
     },
   }),
   [11]: (state: AppState) => ({
     ...state,
     messageStore: DEPRECATED_unshimMessageStore(state.messageStore, [
       messageTypes.IMAGES,
     ]),
   }),
   [12]: (state: AppState) => ({
     ...state,
     globalThemeInfo: defaultGlobalThemeInfo,
   }),
   [13]: (state: AppState) => ({
     ...state,
     deviceCameraInfo: defaultDeviceCameraInfo,
     deviceOrientation: Orientation.getInitialOrientation(),
   }),
   [14]: (state: AppState) => state,
   [15]: state => ({
     ...state,
     threadStore: {
       ...state.threadStore,
       inconsistencyReports: inconsistencyResponsesToReports(
         state.threadStore.inconsistencyResponses,
       ),
       inconsistencyResponses: undefined,
     },
     entryStore: {
       ...state.entryStore,
       inconsistencyReports: inconsistencyResponsesToReports(
         state.entryStore.inconsistencyResponses,
       ),
       inconsistencyResponses: undefined,
     },
     queuedReports: [],
   }),
   [16]: state => {
     const result = {
       ...state,
       messageSentFromRoute: undefined,
       dataLoaded: !!state.currentUserInfo && !state.currentUserInfo.anonymous,
     };
     if (state.navInfo) {
       result.navInfo = {
         ...state.navInfo,
         navigationState: undefined,
       };
     }
     return result;
   },
   [17]: state => ({
     ...state,
     userInfos: undefined,
     userStore: {
       userInfos: state.userInfos,
       inconsistencyResponses: [],
     },
   }),
   [18]: state => ({
     ...state,
     userStore: {
       userInfos: state.userStore.userInfos,
       inconsistencyReports: [],
     },
   }),
   [19]: state => {
     const threadInfos = {};
     for (const threadID in state.threadStore.threadInfos) {
       const threadInfo = state.threadStore.threadInfos[threadID];
       const { visibilityRules, ...rest } = threadInfo;
       threadInfos[threadID] = rest;
     }
     return {
       ...state,
       threadStore: {
         ...state.threadStore,
         threadInfos,
       },
     };
   },
   [20]: (state: AppState) => ({
     ...state,
     messageStore: DEPRECATED_unshimMessageStore(state.messageStore, [
       messageTypes.UPDATE_RELATIONSHIP,
     ]),
   }),
   [21]: (state: AppState) => ({
     ...state,
     messageStore: DEPRECATED_unshimMessageStore(state.messageStore, [
       messageTypes.CREATE_SIDEBAR,
       messageTypes.SIDEBAR_SOURCE,
     ]),
   }),
   [22]: state => {
     for (const key in state.drafts) {
       const value = state.drafts[key];
       try {
         commCoreModule.updateDraft(key, value);
       } catch (e) {
         if (!isTaskCancelledError(e)) {
           throw e;
         }
       }
     }
     return {
       ...state,
       drafts: undefined,
     };
   },
   [23]: state => ({
     ...state,
     globalThemeInfo: defaultGlobalThemeInfo,
   }),
   [24]: state => ({
     ...state,
     enabledApps: defaultEnabledApps,
   }),
   [25]: state => ({
     ...state,
     crashReportsEnabled: __DEV__,
   }),
   [26]: state => {
     const { currentUserInfo } = state;
     if (currentUserInfo.anonymous) {
       return state;
     }
     return {
       ...state,
       crashReportsEnabled: undefined,
       currentUserInfo: {
         id: currentUserInfo.id,
         username: currentUserInfo.username,
       },
       enabledReports: {
         crashReports: __DEV__,
         inconsistencyReports: __DEV__,
         mediaReports: __DEV__,
       },
     };
   },
   [27]: state => ({
     ...state,
     queuedReports: undefined,
     enabledReports: undefined,
     threadStore: {
       ...state.threadStore,
       inconsistencyReports: undefined,
     },
     entryStore: {
       ...state.entryStore,
       inconsistencyReports: undefined,
     },
     reportStore: {
       enabledReports: {
         crashReports: __DEV__,
         inconsistencyReports: __DEV__,
         mediaReports: __DEV__,
       },
       queuedReports: [
         ...state.entryStore.inconsistencyReports,
         ...state.threadStore.inconsistencyReports,
         ...state.queuedReports,
       ],
     },
   }),
   [28]: state => {
     const threadParentToChildren = {};
     for (const threadID in state.threadStore.threadInfos) {
       const threadInfo = state.threadStore.threadInfos[threadID];
       const parentThreadInfo = threadInfo.parentThreadID
         ? state.threadStore.threadInfos[threadInfo.parentThreadID]
         : null;
       const parentIndex = parentThreadInfo ? parentThreadInfo.id : '-1';
       if (!threadParentToChildren[parentIndex]) {
         threadParentToChildren[parentIndex] = [];
       }
       threadParentToChildren[parentIndex].push(threadID);
     }
 
     const rootIDs = threadParentToChildren['-1'];
     if (!rootIDs) {
       // This should never happen, but if it somehow does we'll let the state
       // check mechanism resolve it...
       return state;
     }
 
     const threadInfos = {};
     const stack = [...rootIDs];
     while (stack.length > 0) {
       const threadID = stack.shift();
       const threadInfo = state.threadStore.threadInfos[threadID];
       const parentThreadInfo = threadInfo.parentThreadID
         ? threadInfos[threadInfo.parentThreadID]
         : null;
       threadInfos[threadID] = {
         ...threadInfo,
         containingThreadID: getContainingThreadID(
           parentThreadInfo,
           threadInfo.type,
         ),
         community: getCommunity(parentThreadInfo),
       };
       const children = threadParentToChildren[threadID];
       if (children) {
         stack.push(...children);
       }
     }
     return { ...state, threadStore: { ...state.threadStore, threadInfos } };
   },
   [29]: (state: AppState) => {
     const updatedThreadInfos = migrateThreadStoreForEditThreadPermissions(
       state.threadStore.threadInfos,
     );
 
     return {
       ...state,
       threadStore: {
         ...state.threadStore,
         threadInfos: updatedThreadInfos,
       },
     };
   },
   [30]: (state: AppState) => {
     const threadInfos = state.threadStore.threadInfos;
     const operations = [
       {
         type: 'remove_all',
       },
       ...Object.keys(threadInfos).map((id: string) => ({
         type: 'replace',
         payload: { id, threadInfo: threadInfos[id] },
       })),
     ];
     try {
       commCoreModule.processThreadStoreOperationsSync(
         threadStoreOpsHandlers.convertOpsToClientDBOps(operations),
       );
     } catch (exception) {
       console.log(exception);
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
     return state;
   },
   [31]: (state: AppState) => {
     const messages = state.messageStore.messages;
     const operations: $ReadOnlyArray<ClientDBMessageStoreOperation> = [
       {
         type: 'remove_all',
       },
       ...Object.keys(messages).map((id: string) => ({
         type: 'replace',
         payload: translateRawMessageInfoToClientDBMessageInfo(messages[id]),
       })),
     ];
     try {
       commCoreModule.processMessageStoreOperationsSync(operations);
     } catch (exception) {
       console.log(exception);
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
     return state;
   },
   [32]: (state: AppState) => unshimClientDB(state, [messageTypes.MULTIMEDIA]),
   [33]: (state: AppState) => unshimClientDB(state, [messageTypes.REACTION]),
   [34]: state => {
     const { threadIDsToNotifIDs, ...stateSansThreadIDsToNotifIDs } = state;
     return stateSansThreadIDsToNotifIDs;
   },
   [35]: (state: AppState) => unshimClientDB(state, [messageTypes.MULTIMEDIA]),
   [36]: (state: AppState) => {
     // 1. Get threads and messages from SQLite `threads` and `messages` tables.
     const clientDBThreadInfos = commCoreModule.getAllThreadsSync();
     const clientDBMessageInfos = commCoreModule.getAllMessagesSync();
 
     // 2. Translate `ClientDBThreadInfo`s to `RawThreadInfo`s and
     //    `ClientDBMessageInfo`s to `RawMessageInfo`s.
     const rawThreadInfos = clientDBThreadInfos.map(
       convertClientDBThreadInfoToRawThreadInfo,
     );
     const rawMessageInfos = clientDBMessageInfos.map(
       translateClientDBMessageInfoToRawMessageInfo,
     );
 
     // 3. Unshim translated `RawMessageInfos` to get the TOGGLE_PIN messages
     const unshimmedRawMessageInfos = rawMessageInfos.map(messageInfo =>
       unshimFunc(messageInfo, new Set([messageTypes.TOGGLE_PIN])),
     );
 
     // 4. Filter out non-TOGGLE_PIN messages
     const filteredRawMessageInfos = unshimmedRawMessageInfos.filter(
       messageInfo => messageInfo.type === messageTypes.TOGGLE_PIN,
     );
 
     // 5. We want only the last TOGGLE_PIN message for each message ID,
     // so 'pin', 'unpin', 'pin' don't count as 3 pins, but only 1.
     const lastMessageIDToRawMessageInfoMap = new Map();
     for (const messageInfo of filteredRawMessageInfos) {
       const { targetMessageID } = messageInfo;
       lastMessageIDToRawMessageInfoMap.set(targetMessageID, messageInfo);
     }
     const lastMessageIDToRawMessageInfos = Array.from(
       lastMessageIDToRawMessageInfoMap.values(),
     );
 
     // 6. Create a Map of threadIDs to pinnedCount
     const threadIDsToPinnedCount = new Map();
     for (const messageInfo of lastMessageIDToRawMessageInfos) {
       const { threadID, type } = messageInfo;
       if (type === messageTypes.TOGGLE_PIN) {
         const pinnedCount = threadIDsToPinnedCount.get(threadID) || 0;
         threadIDsToPinnedCount.set(threadID, pinnedCount + 1);
       }
     }
 
     // 7. Include a pinnedCount for each rawThreadInfo
     const rawThreadInfosWithPinnedCount = rawThreadInfos.map(threadInfo => ({
       ...threadInfo,
       pinnedCount: threadIDsToPinnedCount.get(threadInfo.id) || 0,
     }));
 
     // 8. Convert rawThreadInfos to a map of threadID to threadInfo
     const threadIDToThreadInfo = rawThreadInfosWithPinnedCount.reduce(
       (acc, threadInfo) => {
         acc[threadInfo.id] = threadInfo;
         return acc;
       },
       {},
     );
 
     // 9. Add threadPermission to each threadInfo
     const rawThreadInfosWithThreadPermission =
       persistMigrationForManagePinsThreadPermission(threadIDToThreadInfo);
 
     // 10. Convert the new threadInfos back into an array
     const rawThreadInfosWithCountAndPermission = Object.keys(
       rawThreadInfosWithThreadPermission,
     ).map(id => rawThreadInfosWithThreadPermission[id]);
 
     // 11. Translate `RawThreadInfo`s to `ClientDBThreadInfo`s.
     const convertedClientDBThreadInfos =
       rawThreadInfosWithCountAndPermission.map(
         convertRawThreadInfoToClientDBThreadInfo,
       );
 
     // 12. Construct `ClientDBThreadStoreOperation`s to clear SQLite `threads`
     //    table and repopulate with `ClientDBThreadInfo`s.
     const operations: $ReadOnlyArray<ClientDBThreadStoreOperation> = [
       {
         type: 'remove_all',
       },
       ...convertedClientDBThreadInfos.map((thread: ClientDBThreadInfo) => ({
         type: 'replace',
         payload: thread,
       })),
     ];
 
     // 13. Try processing `ClientDBThreadStoreOperation`s and log out if
     //    `processThreadStoreOperationsSync(...)` throws an exception.
     try {
       commCoreModule.processThreadStoreOperationsSync(operations);
     } catch (exception) {
       console.log(exception);
       return { ...state, cookie: null };
     }
 
     return state;
   },
   [37]: state => {
     const operations = messageStoreOpsHandlers.convertOpsToClientDBOps([
       {
         type: 'remove_all_threads',
       },
       {
         type: 'replace_threads',
         payload: { threads: state.messageStore.threads },
       },
     ]);
 
     try {
       commCoreModule.processMessageStoreOperationsSync(operations);
     } catch (exception) {
       console.error(exception);
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
 
     return state;
   },
   [38]: state =>
     updateClientDBThreadStoreThreadInfos(state, updateRolesAndPermissions),
   [39]: (state: AppState) => unshimClientDB(state, [messageTypes.EDIT_MESSAGE]),
   [40]: state =>
     updateClientDBThreadStoreThreadInfos(state, updateRolesAndPermissions),
   [41]: (state: AppState) => {
     const queuedReports = state.reportStore.queuedReports.map(report => ({
       ...report,
       id: getUUID(),
     }));
     return {
       ...state,
       reportStore: { ...state.reportStore, queuedReports },
     };
   },
   [42]: (state: AppState) => {
     const reportStoreOperations: $ReadOnlyArray<ReportStoreOperation> = [
       { type: 'remove_all_reports' },
       ...convertReportsToReplaceReportOps(state.reportStore.queuedReports),
     ];
     const dbOperations: $ReadOnlyArray<ClientDBReportStoreOperation> =
       reportStoreOpsHandlers.convertOpsToClientDBOps(reportStoreOperations);
 
     try {
       commCoreModule.processReportStoreOperationsSync(dbOperations);
     } catch (exception) {
       if (isTaskCancelledError(exception)) {
         return state;
       }
       return { ...state, cookie: null };
     }
     return state;
   },
   [43]: async (state: AppState) => {
     const { messages, drafts, threads, messageStoreThreads } =
       await commCoreModule.getClientDBStore();
 
     const messageStoreThreadsOperations =
       createUpdateDBOpsForMessageStoreThreads(
         messageStoreThreads,
         convertMessageStoreThreadsToNewIDSchema,
       );
 
     const messageStoreMessagesOperations =
       createUpdateDBOpsForMessageStoreMessages(messages, messageInfos =>
         messageInfos.map(convertRawMessageInfoToNewIDSchema),
       );
 
     const threadOperations = createUpdateDBOpsForThreadStoreThreadInfos(
       threads,
       convertThreadStoreThreadInfosToNewIDSchema,
     );
 
     const draftOperations = generateIDSchemaMigrationOpsForDrafts(drafts);
 
     try {
       await Promise.all([
         commCoreModule.processMessageStoreOperations([
           ...messageStoreMessagesOperations,
           ...messageStoreThreadsOperations,
         ]),
         commCoreModule.processThreadStoreOperations(threadOperations),
         commCoreModule.processDraftStoreOperations(draftOperations),
       ]);
     } catch (exception) {
       console.log(exception);
       return { ...state, cookie: null };
     }
 
     return {
       ...state,
       entryStore: convertEntryStoreToNewIDSchema(state.entryStore),
       messageStore: convertMessageStoreToNewIDSchema(state.messageStore),
       calendarFilters: state.calendarFilters.map(
         convertCalendarFilterToNewIDSchema,
       ),
       connection: convertConnectionInfoToNewIDSchema(state.connection),
       watchedThreadIDs: state.watchedThreadIDs.map(
         id => `${ashoatKeyserverID}|${id}`,
       ),
       inviteLinksStore: convertInviteLinksStoreToNewIDSchema(
         state.inviteLinksStore,
       ),
     };
   },
   [44]: async state => {
     const { cookie, ...rest } = state;
 
     return {
       ...rest,
       keyserverStore: { keyserverInfos: { [ashoatKeyserverID]: { cookie } } },
     };
   },
   [45]: async state => {
     const { updatesCurrentAsOf, keyserverStore, ...rest } = state;
 
     return {
       ...rest,
       keyserverStore: {
         ...keyserverStore,
         keyserverInfos: {
           ...keyserverStore.keyserverInfos,
           [ashoatKeyserverID]: {
             ...keyserverStore.keyserverInfos[ashoatKeyserverID],
             updatesCurrentAsOf,
           },
         },
       },
     };
   },
+  [46]: async state => {
+    const { currentAsOf } = state.messageStore;
+
+    return {
+      ...state,
+      messageStore: {
+        ...state.messageStore,
+        currentAsOf: { [ashoatKeyserverID]: currentAsOf },
+      },
+    };
+  },
 };
 
 // After migration 31, we'll no longer want to persist `messageStore.messages`
 // via redux-persist. However, we DO want to continue persisting everything in
 // `messageStore` EXCEPT for `messages`. The `blacklist` property in
 // `persistConfig` allows us to specify top-level keys that shouldn't be
 // persisted. However, we aren't able to specify nested keys in `blacklist`.
 // As a result, if we want to prevent nested keys from being persisted we'll
 // need to use `createTransform(...)` to specify an `inbound` function that
 // allows us to modify the `state` object before it's passed through
 // `JSON.stringify(...)` and written to disk. We specify the keys for which
 // this transformation should be executed in the `whitelist` property of the
 // `config` object that's passed to `createTransform(...)`.
 // eslint-disable-next-line no-unused-vars
 type PersistedThreadMessageInfo = {
   +startReached: boolean,
   +lastNavigatedTo: number,
   +lastPruned: number,
 };
 type PersistedMessageStore = {
   +local: { +[id: string]: LocalMessageInfo },
-  +currentAsOf: number,
+  +currentAsOf: { +[keyserverID: string]: number },
   +threads: { +[threadID: string]: PersistedThreadMessageInfo },
 };
 
 const messageStoreMessagesBlocklistTransform: Transform = createTransform(
   (state: MessageStore): PersistedMessageStore => {
     const { messages, threads, ...messageStoreSansMessages } = state;
     // We also do not want to persist `messageStore.threads[ID].messageIDs`
     // because they can be deterministically computed based on messages we have
     // from SQLite
     const threadsToPersist = {};
     for (const threadID in threads) {
       const { messageIDs, ...threadsData } = threads[threadID];
       threadsToPersist[threadID] = threadsData;
     }
     return { ...messageStoreSansMessages, threads: threadsToPersist };
   },
   (state: MessageStore): MessageStore => {
     const { threads: persistedThreads, ...messageStore } = state;
     const threads = {};
     for (const threadID in persistedThreads) {
       threads[threadID] = { ...persistedThreads[threadID], messageIDs: [] };
     }
     // We typically expect `messageStore.messages` to be `undefined` because
     // messages are persisted in the SQLite `messages` table rather than via
     // `redux-persist`. In this case we want to set `messageStore.messages`
     // to {} so we don't run into issues with `messageStore.messages` being
     // `undefined` (https://phab.comm.dev/D5545).
     //
     // However, in the case that a user is upgrading from a client where
     // `persistConfig.version` < 31, we expect `messageStore.messages` to
     // contain messages stored via `redux-persist` that we need in order
     // to correctly populate the SQLite `messages` table in migration 31
     // (https://phab.comm.dev/D2600).
     //
     // However, because `messageStoreMessagesBlocklistTransform` modifies
     // `messageStore` before migrations are run, we need to make sure we aren't
     // inadvertently clearing `messageStore.messages` (by setting to {}) before
     // messages are stored in SQLite (https://linear.app/comm/issue/ENG-2377).
     return { ...messageStore, threads, messages: messageStore.messages ?? {} };
   },
   { whitelist: ['messageStore'] },
 );
 
 type PersistedReportStore = $Diff<
   ReportStore,
   { +queuedReports: $ReadOnlyArray<ClientReportCreationRequest> },
 >;
 const reportStoreTransform: Transform = createTransform(
   (state: ReportStore): PersistedReportStore => {
     return { enabledReports: state.enabledReports };
   },
   (state: PersistedReportStore): ReportStore => {
     return { ...state, queuedReports: [] };
   },
   { whitelist: ['reportStore'] },
 );
 
 const persistConfig = {
   key: 'root',
   storage: AsyncStorage,
   blacklist: [
     'loadingStatuses',
     'lifecycleState',
     'dimensions',
     'draftStore',
     'connectivity',
     'deviceOrientation',
     'frozen',
     'threadStore',
     'storeLoaded',
   ],
   debug: __DEV__,
-  version: 45,
+  version: 46,
   transforms: [messageStoreMessagesBlocklistTransform, reportStoreTransform],
   migrate: (createAsyncMigrate(migrations, { debug: __DEV__ }): any),
   timeout: ((__DEV__ ? 0 : undefined): number | void),
 };
 
 const codeVersion: number = commCoreModule.getCodeVersion();
 
 // This local exists to avoid a circular dependency where redux-setup needs to
 // import all the navigation and screen stuff, but some of those screens want to
 // access the persistor to purge its state.
 let storedPersistor = null;
 function setPersistor(persistor: *) {
   storedPersistor = persistor;
 }
 function getPersistor(): empty {
   invariant(storedPersistor, 'should be set');
   return storedPersistor;
 }
 
 export { persistConfig, codeVersion, setPersistor, getPersistor };
diff --git a/native/redux/redux-setup.js b/native/redux/redux-setup.js
index 6372048e5..bde2f9ab1 100644
--- a/native/redux/redux-setup.js
+++ b/native/redux/redux-setup.js
@@ -1,487 +1,487 @@
 // @flow
 
 import { AppState as NativeAppState, Platform, Alert } from 'react-native';
 import Orientation from 'react-native-orientation-locker';
 import { createStore, applyMiddleware, type Store, compose } from 'redux';
 import { persistStore, persistReducer } from 'redux-persist';
 import thunk from 'redux-thunk';
 
 import { setClientDBStoreActionType } from 'lib/actions/client-db-store-actions.js';
 import { siweAuthActionTypes } from 'lib/actions/siwe-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
 } from 'lib/actions/user-actions.js';
 import type { ThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import { threadStoreOpsHandlers } from 'lib/ops/thread-store-ops.js';
 import baseReducer from 'lib/reducers/master-reducer.js';
 import {
   invalidSessionDowngrade,
   invalidSessionRecovery,
 } from 'lib/shared/session-utils.js';
 import { isStaff } from 'lib/shared/staff-utils.js';
 import { defaultEnabledApps } from 'lib/types/enabled-apps.js';
 import { defaultCalendarFilters } from 'lib/types/filter-types.js';
 import type { Dispatch, BaseAction } from 'lib/types/redux-types.js';
 import { rehydrateActionType } from 'lib/types/redux-types.js';
 import type { SetSessionPayload } from 'lib/types/session-types.js';
 import { defaultConnectionInfo } from 'lib/types/socket-types.js';
 import { reduxLoggerMiddleware } from 'lib/utils/action-logger.js';
 import { setNewSessionActionType } from 'lib/utils/action-utils.js';
 import { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
 import { ashoatKeyserverID } from 'lib/utils/validation-utils.js';
 
 import {
   updateDimensionsActiveType,
   updateConnectivityActiveType,
   updateThemeInfoActionType,
   updateDeviceCameraInfoActionType,
   updateDeviceOrientationActionType,
   updateThreadLastNavigatedActionType,
   backgroundActionTypes,
   setReduxStateActionType,
   setStoreLoadedActionType,
   type Action,
 } from './action-types.js';
 import { remoteReduxDevServerConfig } from './dev-tools.js';
 import { defaultDimensionsInfo } from './dimensions-updater.react.js';
 import { persistConfig, setPersistor } from './persist.js';
 import { processDBStoreOperations } from './redux-utils.js';
 import type { AppState } from './state-types.js';
 import reduceGlobalThemeInfo from './theme-reducer.js';
 import { defaultNavInfo } from '../navigation/default-state.js';
 import { getGlobalNavContext } from '../navigation/icky-global.js';
 import { activeMessageListSelector } from '../navigation/nav-selectors.js';
 import reactotron from '../reactotron.js';
 import { defaultDeviceCameraInfo } from '../types/camera.js';
 import { defaultConnectivityInfo } from '../types/connectivity.js';
 import { defaultGlobalThemeInfo } from '../types/themes.js';
 import { isStaffRelease } from '../utils/staff-utils.js';
 import {
   defaultURLPrefix,
   natNodeServer,
   setCustomServer,
   getDevServerHostname,
 } from '../utils/url-utils.js';
 
 const defaultState = ({
   navInfo: defaultNavInfo,
   currentUserInfo: null,
   draftStore: { drafts: {} },
   entryStore: {
     entryInfos: {},
     daysToEntries: {},
     lastUserInteractionCalendar: 0,
   },
   threadStore: {
     threadInfos: {},
   },
   userStore: {
     userInfos: {},
     inconsistencyReports: [],
   },
   messageStore: {
     messages: {},
     threads: {},
     local: {},
-    currentAsOf: 0,
+    currentAsOf: { [ashoatKeyserverID]: 0 },
   },
   storeLoaded: false,
   loadingStatuses: {},
   calendarFilters: defaultCalendarFilters,
   deviceToken: null,
   dataLoaded: false,
   urlPrefix: defaultURLPrefix,
   customServer: natNodeServer,
   notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
   connection: defaultConnectionInfo(Platform.OS),
   watchedThreadIDs: [],
   lifecycleState: 'active',
   enabledApps: defaultEnabledApps,
   reportStore: {
     enabledReports: {
       crashReports: __DEV__,
       inconsistencyReports: __DEV__,
       mediaReports: __DEV__,
     },
     queuedReports: [],
   },
   nextLocalID: 0,
   _persist: null,
   dimensions: defaultDimensionsInfo,
   connectivity: defaultConnectivityInfo,
   globalThemeInfo: defaultGlobalThemeInfo,
   deviceCameraInfo: defaultDeviceCameraInfo,
   deviceOrientation: Orientation.getInitialOrientation(),
   frozen: false,
   userPolicies: {},
   commServicesAccessToken: null,
   inviteLinksStore: {
     links: {},
   },
   lastCommunicatedPlatformDetails: {},
   keyserverStore: {
     keyserverInfos: {
       [ashoatKeyserverID]: { updatesCurrentAsOf: 0 },
     },
   },
 }: AppState);
 
 function reducer(state: AppState = defaultState, action: Action) {
   if (action.type === setReduxStateActionType) {
     return action.payload.state;
   }
 
   // We want to alert staff/developers if there's a difference between the keys
   // we expect to see REHYDRATED and the keys that are actually REHYDRATED.
   // Context: https://linear.app/comm/issue/ENG-2127/
   if (
     action.type === rehydrateActionType &&
     (__DEV__ ||
       isStaffRelease ||
       (state.currentUserInfo &&
         state.currentUserInfo.id &&
         isStaff(state.currentUserInfo.id)))
   ) {
     // 1. Construct set of keys expected to be REHYDRATED
     const defaultKeys = Object.keys(defaultState);
     const expectedKeys = defaultKeys.filter(
       each => !persistConfig.blacklist.includes(each),
     );
     const expectedKeysSet = new Set(expectedKeys);
 
     // 2. Construct set of keys actually REHYDRATED
     const rehydratedKeys = Object.keys(action.payload ?? {});
     const rehydratedKeysSet = new Set(rehydratedKeys);
 
     // 3. Determine the difference between the two sets
     const expectedKeysNotRehydrated = expectedKeys.filter(
       each => !rehydratedKeysSet.has(each),
     );
     const rehydratedKeysNotExpected = rehydratedKeys.filter(
       each => !expectedKeysSet.has(each),
     );
 
     // 4. Display alerts with the differences between the two sets
     if (expectedKeysNotRehydrated.length > 0) {
       Alert.alert(
         `EXPECTED KEYS NOT REHYDRATED: ${JSON.stringify(
           expectedKeysNotRehydrated,
         )}`,
       );
     }
     if (rehydratedKeysNotExpected.length > 0) {
       Alert.alert(
         `REHYDRATED KEYS NOT EXPECTED: ${JSON.stringify(
           rehydratedKeysNotExpected,
         )}`,
       );
     }
   }
 
   if (
     (action.type === setNewSessionActionType &&
       invalidSessionDowngrade(
         state,
         action.payload.sessionChange.currentUserInfo,
         action.payload.preRequestUserState,
       )) ||
     (action.type === logOutActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
       )) ||
     (action.type === deleteAccountActionTypes.success &&
       invalidSessionDowngrade(
         state,
         action.payload.currentUserInfo,
         action.payload.preRequestUserState,
       ))
   ) {
     return state;
   }
   if (
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.currentUserInfo &&
       invalidSessionRecovery(
         state,
         action.payload.sessionChange.currentUserInfo,
         action.payload.logInActionSource,
       )) ||
     ((action.type === logInActionTypes.success ||
       action.type === siweAuthActionTypes.success) &&
       invalidSessionRecovery(
         state,
         action.payload.currentUserInfo,
         action.payload.logInActionSource,
       ))
   ) {
     return state;
   }
 
   state = {
     ...state,
     globalThemeInfo: reduceGlobalThemeInfo(state.globalThemeInfo, action),
   };
 
   if (action.type === setCustomServer) {
     return {
       ...state,
       customServer: action.payload,
     };
   } else if (action.type === updateDimensionsActiveType) {
     return {
       ...state,
       dimensions: {
         ...state.dimensions,
         ...action.payload,
       },
     };
   } else if (action.type === updateConnectivityActiveType) {
     return {
       ...state,
       connectivity: action.payload,
     };
   } else if (action.type === updateThemeInfoActionType) {
     // Handled above by reduceGlobalThemeInfo
     return state;
   } else if (action.type === updateDeviceCameraInfoActionType) {
     return {
       ...state,
       deviceCameraInfo: {
         ...state.deviceCameraInfo,
         ...action.payload,
       },
     };
   } else if (action.type === updateDeviceOrientationActionType) {
     return {
       ...state,
       deviceOrientation: action.payload,
     };
   } else if (action.type === updateThreadLastNavigatedActionType) {
     const { threadID, time } = action.payload;
     if (state.messageStore.threads[threadID]) {
       const updatedThreads = {
         [threadID]: {
           ...state.messageStore.threads[threadID],
           lastNavigatedTo: time,
         },
       };
 
       state = {
         ...state,
         messageStore: {
           ...state.messageStore,
           threads: {
             ...state.messageStore.threads,
             ...updatedThreads,
           },
         },
       };
 
       processDBStoreOperations({
         draftStoreOperations: [],
         messageStoreOperations: [
           {
             type: 'replace_threads',
             payload: {
               threads: updatedThreads,
             },
           },
         ],
         threadStoreOperations: [],
         reportStoreOperations: [],
       });
     }
     return state;
   }
 
   if (action.type === setNewSessionActionType) {
     sessionInvalidationAlert(action.payload);
   }
   if (action.type === setStoreLoadedActionType) {
     return {
       ...state,
       storeLoaded: true,
     };
   }
   if (action.type === setClientDBStoreActionType) {
     state = {
       ...state,
       storeLoaded: true,
     };
     const currentLoggedInUserID = state.currentUserInfo?.anonymous
       ? undefined
       : state.currentUserInfo?.id;
     const actionCurrentLoggedInUserID = action.payload.currentUserID;
     if (
       !currentLoggedInUserID ||
       !actionCurrentLoggedInUserID ||
       actionCurrentLoggedInUserID !== currentLoggedInUserID
     ) {
       // If user is logged out now, was logged out at the time action was
       // dispatched or their ID changed between action dispatch and a
       // call to reducer we ignore the SQLite data since it is not valid
       return state;
     }
   }
 
   const baseReducerResult = baseReducer(state, (action: BaseAction));
   state = baseReducerResult.state;
 
   const { storeOperations } = baseReducerResult;
   const {
     draftStoreOperations,
     threadStoreOperations,
     messageStoreOperations,
     reportStoreOperations,
   } = storeOperations;
 
   const fixUnreadActiveThreadResult = fixUnreadActiveThread(state, action);
   state = fixUnreadActiveThreadResult.state;
 
   const threadStoreOperationsWithUnreadFix = [
     ...threadStoreOperations,
     ...fixUnreadActiveThreadResult.threadStoreOperations,
   ];
 
   processDBStoreOperations({
     draftStoreOperations,
     messageStoreOperations,
     threadStoreOperations: threadStoreOperationsWithUnreadFix,
     reportStoreOperations,
   });
 
   return state;
 }
 
 function sessionInvalidationAlert(payload: SetSessionPayload) {
   if (
     !payload.sessionChange.cookieInvalidated ||
     !payload.preRequestUserState ||
     !payload.preRequestUserState.currentUserInfo ||
     payload.preRequestUserState.currentUserInfo.anonymous
   ) {
     return;
   }
   if (payload.error === 'client_version_unsupported') {
     const app = Platform.select({
       ios: 'App Store',
       android: 'Play Store',
     });
     Alert.alert(
       'App out of date',
       'Your app version is pretty old, and the server doesn’t know how to ' +
         `speak to it anymore. Please use the ${app} app to update!`,
       [{ text: 'OK' }],
       { cancelable: true },
     );
   } else {
     Alert.alert(
       'Session invalidated',
       'We’re sorry, but your session was invalidated by the server. ' +
         'Please log in again.',
       [{ text: 'OK' }],
       { cancelable: true },
     );
   }
 }
 
 // Makes sure a currently focused thread is never unread. Note that we consider
 // a backgrounded NativeAppState to actually be active if it last changed to
 // inactive more than 10 seconds ago. This is because there is a delay when
 // NativeAppState is updating in response to a foreground, and actions don't get
 // processed more than 10 seconds after a backgrounding anyways. However we
 // don't consider this for action types that can be expected to happen while the
 // app is backgrounded.
 type FixUnreadActiveThreadResult = {
   +state: AppState,
   +threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 };
 function fixUnreadActiveThread(
   state: AppState,
   action: *,
 ): FixUnreadActiveThreadResult {
   const navContext = getGlobalNavContext();
   const activeThread = activeMessageListSelector(navContext);
   if (
     !activeThread ||
     !state.threadStore.threadInfos[activeThread]?.currentUser.unread ||
     (NativeAppState.currentState !== 'active' &&
       (appLastBecameInactive + 10000 >= Date.now() ||
         backgroundActionTypes.has(action.type)))
   ) {
     return { state, threadStoreOperations: [] };
   }
 
   const updatedActiveThreadInfo = {
     ...state.threadStore.threadInfos[activeThread],
     currentUser: {
       ...state.threadStore.threadInfos[activeThread].currentUser,
       unread: false,
     },
   };
 
   const threadStoreOperations = [
     {
       type: 'replace',
       payload: {
         id: activeThread,
         threadInfo: updatedActiveThreadInfo,
       },
     },
   ];
 
   const updatedThreadStore = threadStoreOpsHandlers.processStoreOperations(
     state.threadStore,
     threadStoreOperations,
   );
 
   return {
     state: { ...state, threadStore: updatedThreadStore },
     threadStoreOperations,
   };
 }
 
 let appLastBecameInactive = 0;
 function appBecameInactive() {
   appLastBecameInactive = Date.now();
 }
 
 const middleware = applyMiddleware(thunk, reduxLoggerMiddleware);
 
 let composeFunc = compose;
 if (__DEV__ && global.HermesInternal) {
   const { composeWithDevTools } = require('remote-redux-devtools/src/index.js');
   composeFunc = composeWithDevTools({
     name: 'Redux',
     hostname: getDevServerHostname(),
     ...remoteReduxDevServerConfig,
   });
 } else if (global.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) {
   composeFunc = global.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
     name: 'Redux',
   });
 }
 
 let enhancers;
 if (reactotron) {
   enhancers = composeFunc(middleware, reactotron.createEnhancer());
 } else {
   enhancers = composeFunc(middleware);
 }
 
 const store: Store<AppState, *> = createStore(
   persistReducer(persistConfig, reducer),
   defaultState,
   enhancers,
 );
 const persistor = persistStore(store);
 setPersistor(persistor);
 
 const unsafeDispatch: any = store.dispatch;
 const dispatch: Dispatch = unsafeDispatch;
 
 export { store, dispatch, appBecameInactive };
diff --git a/native/selectors/account-selectors.js b/native/selectors/account-selectors.js
index f6fb1e9ba..a9b478e54 100644
--- a/native/selectors/account-selectors.js
+++ b/native/selectors/account-selectors.js
@@ -1,61 +1,62 @@
 // @flow
 
 import { createSelector } from 'reselect';
 
 import { logInExtraInfoSelector } from 'lib/selectors/account-selectors.js';
+import { currentAsOfSelector } from 'lib/selectors/keyserver-selectors.js';
 import type { LogInExtraInfo } from 'lib/types/account-types.js';
 import type { SignedIdentityKeysBlob } from 'lib/types/crypto-types.js';
 import type { UserPolicies } from 'lib/types/policy-types.js';
 import { values } from 'lib/utils/objects.js';
 
 import { commCoreModule } from '../native-modules.js';
 import { calendarActiveSelector } from '../navigation/nav-selectors.js';
 import type { AppState } from '../redux/state-types.js';
 import type { ConnectivityInfo } from '../types/connectivity.js';
 import type { NavPlusRedux } from '../types/selector-types.js';
 
 const nativeLogInExtraInfoSelector: (
   input: NavPlusRedux,
 ) => () => Promise<LogInExtraInfo> = createSelector(
   (input: NavPlusRedux) => logInExtraInfoSelector(input.redux),
   (input: NavPlusRedux) => calendarActiveSelector(input.navContext),
   (
     logInExtraInfoFunc: (calendarActive: boolean) => LogInExtraInfo,
     calendarActive: boolean,
   ) => {
     const loginExtraFuncWithIdentityKey = async () => {
       await commCoreModule.initializeCryptoAccount();
       const { blobPayload, signature } =
         await commCoreModule.getUserPublicKey();
       const signedIdentityKeysBlob: SignedIdentityKeysBlob = {
         payload: blobPayload,
         signature,
       };
       return {
         ...logInExtraInfoFunc(calendarActive),
         signedIdentityKeysBlob,
       };
     };
     return loginExtraFuncWithIdentityKey;
   },
 );
 
 const noDataAfterPolicyAcknowledgmentSelector: (state: AppState) => boolean =
   createSelector(
     (state: AppState) => state.connectivity,
-    (state: AppState) => state.messageStore.currentAsOf,
+    currentAsOfSelector,
     (state: AppState) => state.userPolicies,
     (
       connectivity: ConnectivityInfo,
       currentAsOf: number,
       userPolicies: UserPolicies,
     ) =>
       connectivity.connected &&
       currentAsOf === 0 &&
       values(userPolicies).every(policy => policy.isAcknowledged),
   );
 
 export {
   nativeLogInExtraInfoSelector,
   noDataAfterPolicyAcknowledgmentSelector,
 };