diff --git a/lib/shared/dm-ops/create-thread-spec.js b/lib/shared/dm-ops/create-thread-spec.js
index 88bc37354..9a745b3b6 100644
--- a/lib/shared/dm-ops/create-thread-spec.js
+++ b/lib/shared/dm-ops/create-thread-spec.js
@@ -1,218 +1,217 @@
 // @flow
 
 import uuid from 'uuid';
 
 import type { DMOperationSpec } from './dm-op-spec.js';
 import { specialRoles } from '../../permissions/special-roles.js';
 import {
   getAllThreadPermissions,
   makePermissionsBlob,
   getThickThreadRolePermissionsBlob,
 } from '../../permissions/thread-permissions.js';
 import type {
   CreateThickRawThreadInfoInput,
   DMCreateThreadOperation,
 } from '../../types/dm-ops.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import { messageTruncationStatus } from '../../types/message-types.js';
 import {
   type ThickRawThreadInfo,
   type RoleInfo,
   minimallyEncodeMemberInfo,
   minimallyEncodeRoleInfo,
   minimallyEncodeThreadCurrentUserInfo,
 } from '../../types/minimally-encoded-thread-permissions-types.js';
 import { joinThreadSubscription } from '../../types/subscription-types.js';
 import type { ThreadPermissionsInfo } from '../../types/thread-permission-types.js';
 import type { ThickThreadType } from '../../types/thread-types-enum.js';
 import type { ThickMemberInfo } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import { generatePendingThreadColor } from '../color-utils.js';
 import { rawMessageInfoFromMessageData } from '../message-utils.js';
+import { createThreadTimestamps } from '../thread-utils.js';
 
 function createRoleAndPermissionForThickThreads(
   threadType: ThickThreadType,
   threadID: string,
   roleID: string,
 ): { +role: RoleInfo, +membershipPermissions: ThreadPermissionsInfo } {
   const rolePermissions = getThickThreadRolePermissionsBlob(threadType);
   const membershipPermissions = getAllThreadPermissions(
     makePermissionsBlob(rolePermissions, null, threadID, threadType),
     threadID,
   );
   const role: RoleInfo = {
     ...minimallyEncodeRoleInfo({
       id: roleID,
       name: 'Members',
       permissions: rolePermissions,
       isDefault: true,
     }),
     specialRole: specialRoles.DEFAULT_ROLE,
   };
   return {
     membershipPermissions,
     role,
   };
 }
 
 type MutableThickRawThreadInfo = { ...ThickRawThreadInfo };
 function createThickRawThreadInfo(
   input: CreateThickRawThreadInfoInput,
   viewerID: string,
 ): MutableThickRawThreadInfo {
   const {
     threadID,
     threadType,
     creationTime,
     parentThreadID,
     allMemberIDsWithSubscriptions,
     roleID,
     unread,
     name,
     avatar,
     description,
     color,
     containingThreadID,
     sourceMessageID,
     repliesCount,
     pinnedCount,
   } = input;
 
-  const threadColor =
-    color ??
-    generatePendingThreadColor(
-      allMemberIDsWithSubscriptions.map(({ id }) => id),
-    );
+  const memberIDs = allMemberIDsWithSubscriptions.map(({ id }) => id);
+  const threadColor = color ?? generatePendingThreadColor(memberIDs);
 
   const { membershipPermissions, role } =
     createRoleAndPermissionForThickThreads(threadType, threadID, roleID);
 
   const newThread: MutableThickRawThreadInfo = {
     thick: true,
     minimallyEncoded: true,
     id: threadID,
     type: threadType,
     color: threadColor,
     creationTime,
     parentThreadID,
     members: allMemberIDsWithSubscriptions.map(
       ({ id: memberID, subscription }) =>
         minimallyEncodeMemberInfo<ThickMemberInfo>({
           id: memberID,
           role: role.id,
           permissions: membershipPermissions,
           isSender: memberID === viewerID,
           subscription,
         }),
     ),
     roles: {
       [role.id]: role,
     },
     currentUser: minimallyEncodeThreadCurrentUserInfo({
       role: role.id,
       permissions: membershipPermissions,
       subscription: joinThreadSubscription,
       unread,
     }),
     repliesCount: repliesCount ?? 0,
     name,
     avatar,
     description,
     containingThreadID,
+    timestamps: createThreadTimestamps(creationTime, memberIDs),
   };
   if (sourceMessageID) {
     newThread.sourceMessageID = sourceMessageID;
   }
   if (pinnedCount) {
     newThread.pinnedCount = pinnedCount;
   }
   return newThread;
 }
 
 function createMessageDataFromDMOperation(
   dmOperation: DMCreateThreadOperation,
 ) {
   const { threadID, creatorID, time, threadType, memberIDs } = dmOperation;
   const allMemberIDs = [creatorID, ...memberIDs];
   const color = generatePendingThreadColor(allMemberIDs);
   return {
     type: messageTypes.CREATE_THREAD,
     threadID,
     creatorID,
     time,
     initialThreadState: {
       type: threadType,
       color,
       memberIDs: allMemberIDs,
     },
   };
 }
 
 const createThreadSpec: DMOperationSpec<DMCreateThreadOperation> =
   Object.freeze({
     notificationsCreationData: async (dmOperation: DMCreateThreadOperation) => {
       const messageData = createMessageDataFromDMOperation(dmOperation);
       return { messageDatas: [messageData] };
     },
     processDMOperation: async (
       dmOperation: DMCreateThreadOperation,
       viewerID: string,
     ) => {
       const {
         threadID,
         creatorID,
         time,
         threadType,
         memberIDs,
         roleID,
         newMessageID,
       } = dmOperation;
       const allMemberIDs = [creatorID, ...memberIDs];
       const allMemberIDsWithSubscriptions = allMemberIDs.map(id => ({
         id,
         subscription: joinThreadSubscription,
       }));
 
       const rawThreadInfo = createThickRawThreadInfo(
         {
           threadID,
           threadType,
           creationTime: time,
           allMemberIDsWithSubscriptions,
           roleID,
           unread: creatorID !== viewerID,
         },
         viewerID,
       );
 
       const messageData = createMessageDataFromDMOperation(dmOperation);
       const rawMessageInfos = [
         rawMessageInfoFromMessageData(messageData, newMessageID),
       ];
 
       const threadJoinUpdateInfo = {
         type: updateTypes.JOIN_THREAD,
         id: uuid.v4(),
         time,
         threadInfo: rawThreadInfo,
         rawMessageInfos,
         truncationStatus: messageTruncationStatus.EXHAUSTIVE,
         rawEntryInfos: [],
       };
 
       return {
         rawMessageInfos: [], // included in updateInfos below
         updateInfos: [threadJoinUpdateInfo],
       };
     },
     canBeProcessed() {
       return { isProcessingPossible: true };
     },
     supportsAutoRetry: true,
   });
 
 export {
   createThickRawThreadInfo,
   createThreadSpec,
   createRoleAndPermissionForThickThreads,
 };
diff --git a/lib/shared/thread-utils.js b/lib/shared/thread-utils.js
index 4f3638e2a..989574c0a 100644
--- a/lib/shared/thread-utils.js
+++ b/lib/shared/thread-utils.js
@@ -1,1767 +1,1791 @@
 // @flow
 
 import invariant from 'invariant';
 import _find from 'lodash/fp/find.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omit from 'lodash/fp/omit.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import * as React from 'react';
 
 import { getUserAvatarForThread } from './avatar-utils.js';
 import { generatePendingThreadColor } from './color-utils.js';
 import { extractUserMentionsFromText } from './mention-utils.js';
 import { relationshipBlockedInEitherDirection } from './relationship-utils.js';
 import ashoat from '../facts/ashoat.js';
 import genesis from '../facts/genesis.js';
 import { useLoggedInUserInfo } from '../hooks/account-hooks.js';
 import { extractKeyserverIDFromIDOptional } from '../keyserver-conn/keyserver-call-utils.js';
 import {
   hasPermission,
   permissionsToBitmaskHex,
   threadPermissionsFromBitmaskHex,
 } from '../permissions/minimally-encoded-thread-permissions.js';
 import { specialRoles } from '../permissions/special-roles.js';
 import type { SpecialRole } from '../permissions/special-roles.js';
 import {
   permissionLookup,
   getAllThreadPermissions,
   makePermissionsBlob,
 } from '../permissions/thread-permissions.js';
 import type { ChatThreadItem } from '../selectors/chat-selectors.js';
 import {
   threadInfoSelector,
   pendingToRealizedThreadIDsSelector,
   threadInfosSelectorForThreadType,
   onScreenThreadInfos,
 } from '../selectors/thread-selectors.js';
 import {
   getRelativeMemberInfos,
   usersWithPersonalThreadSelector,
 } from '../selectors/user-selectors.js';
 import type {
   RelativeMemberInfo,
   RawThreadInfo,
   MemberInfoWithPermissions,
   RoleInfo,
   ThreadInfo,
   MinimallyEncodedThickMemberInfo,
   ThinRawThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import {
   decodeMinimallyEncodedRoleInfo,
   minimallyEncodeMemberInfo,
   minimallyEncodeRawThreadInfoWithMemberPermissions,
   minimallyEncodeRoleInfo,
   minimallyEncodeThreadCurrentUserInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import { userRelationshipStatus } from '../types/relationship-types.js';
 import { defaultThreadSubscription } from '../types/subscription-types.js';
 import {
   threadPermissionPropagationPrefixes,
   threadPermissions,
   type ThreadPermission,
   type ThreadPermissionsInfo,
   type ThreadRolePermissionsBlob,
   type UserSurfacedPermission,
   threadPermissionFilterPrefixes,
   threadPermissionsDisabledByBlock,
   type ThreadPermissionNotAffectedByBlock,
 } from '../types/thread-permission-types.js';
 import {
   type ThreadType,
   threadTypes,
   threadTypeIsCommunityRoot,
   assertThreadType,
   threadTypeIsThick,
   assertThinThreadType,
   assertThickThreadType,
   threadTypeIsSidebar,
 } from '../types/thread-types-enum.js';
 import type {
   LegacyRawThreadInfo,
   ClientLegacyRoleInfo,
   ServerThreadInfo,
   ThickMemberInfo,
   UserProfileThreadInfo,
   MixedRawThreadInfos,
   LegacyThinRawThreadInfo,
+  ThreadTimestamps,
 } from '../types/thread-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { type ClientUpdateInfo } from '../types/update-types.js';
 import type {
   GlobalAccountUserInfo,
   UserInfos,
   AccountUserInfo,
   LoggedInUserInfo,
   UserInfo,
 } from '../types/user-types.js';
 import {
   ET,
   type ThreadEntity,
   type UserEntity,
 } from '../utils/entity-text.js';
 import {
   stripMemberPermissionsFromRawThreadInfo,
   type ThinRawThreadInfoWithPermissions,
 } from '../utils/member-info-utils.js';
 import { entries, values } from '../utils/objects.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { userSurfacedPermissionsFromRolePermissions } from '../utils/role-utils.js';
 import { usingOlmViaTunnelbrokerForDMs } from '../utils/services-utils.js';
 import { firstLine } from '../utils/string-utils.js';
 import { pendingThreadIDRegex } from '../utils/validation-utils.js';
 
 function threadHasPermission(
   threadInfo: ?(ThreadInfo | LegacyRawThreadInfo | RawThreadInfo),
   permission: ThreadPermissionNotAffectedByBlock,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   invariant(
     !permissionsDisabledByBlock.has(permission) || threadInfo?.uiName,
     `${permission} can be disabled by a block, but threadHasPermission can't ` +
       'check for a block on RawThreadInfo. Please pass in ThreadInfo instead!',
   );
   if (threadInfo.minimallyEncoded) {
     return hasPermission(threadInfo.currentUser.permissions, permission);
   }
   return permissionLookup(threadInfo.currentUser.permissions, permission);
 }
 
 type CommunityRootMembersToRoleType = {
   +[threadID: ?string]: {
     +[memberID: string]: ?RoleInfo,
   },
 };
 function useCommunityRootMembersToRole(
   threadInfos: $ReadOnlyArray<RawThreadInfo | ThreadInfo>,
 ): CommunityRootMembersToRoleType {
   const communityRootMembersToRole = React.useMemo(() => {
     const communityThreadInfos = threadInfos.filter(threadInfo =>
       threadTypeIsCommunityRoot(threadInfo.type),
     );
 
     if (communityThreadInfos.length === 0) {
       return {};
     }
 
     const communityRoots = _keyBy('id')(communityThreadInfos);
     return _mapValues((threadInfo: ThreadInfo) => {
       const keyedMembers = _keyBy('id')(threadInfo.members);
       const keyedMembersToRole = _mapValues(
         (member: MemberInfoWithPermissions | RelativeMemberInfo) => {
           return member.role ? threadInfo.roles[member.role] : null;
         },
       )(keyedMembers);
       return keyedMembersToRole;
     })(communityRoots);
   }, [threadInfos]);
 
   return communityRootMembersToRole;
 }
 
 function useThreadsWithPermission(
   threadInfos: $ReadOnlyArray<ThreadInfo>,
   permission: ThreadPermission,
 ): $ReadOnlyArray<ThreadInfo> {
   const loggedInUserInfo = useLoggedInUserInfo();
   const userInfos = useSelector(state => state.userStore.userInfos);
   const allThreadInfos = useSelector(state => state.threadStore.threadInfos);
   const allThreadInfosArray = React.useMemo(
     () => values(allThreadInfos),
     [allThreadInfos],
   );
 
   const communityRootMembersToRole =
     useCommunityRootMembersToRole(allThreadInfosArray);
 
   return React.useMemo(() => {
     return threadInfos.filter((threadInfo: ThreadInfo) => {
       const membersToRole = communityRootMembersToRole[threadInfo.id];
       const memberHasAdminRole = threadMembersWithoutAddedAdmin(
         threadInfo,
       ).some(member => roleIsAdminRole(membersToRole?.[member.id]));
 
       if (memberHasAdminRole || !loggedInUserInfo) {
         return hasPermission(threadInfo.currentUser.permissions, permission);
       }
 
       const threadFrozen = threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
         threadInfo,
         loggedInUserInfo.id,
         userInfos,
         false,
       );
 
       const permissions = threadFrozen
         ? filterOutDisabledPermissions(threadInfo.currentUser.permissions)
         : threadInfo.currentUser.permissions;
 
       return hasPermission(permissions, permission);
     });
   }, [
     threadInfos,
     communityRootMembersToRole,
     loggedInUserInfo,
     userInfos,
     permission,
   ]);
 }
 
 function useThreadHasPermission(
   threadInfo: ?ThreadInfo,
   permission: ThreadPermission,
 ): boolean {
   const threads = useThreadsWithPermission(
     threadInfo ? [threadInfo] : [],
     permission,
   );
   return threads.length === 1;
 }
 
 function viewerIsMember(
   threadInfo: ?(ThreadInfo | LegacyRawThreadInfo | RawThreadInfo),
 ): boolean {
   return !!(
     threadInfo &&
     threadInfo.currentUser.role !== null &&
     threadInfo.currentUser.role !== undefined
   );
 }
 
 function isMemberActive(
   memberInfo: MemberInfoWithPermissions | MinimallyEncodedThickMemberInfo,
 ): boolean {
   const role = memberInfo.role;
   return role !== null && role !== undefined;
 }
 
 function threadIsInHome(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && threadInfo.currentUser.subscription.home);
 }
 
 // Can have messages
 function threadInChatList(
   threadInfo: ?(LegacyRawThreadInfo | RawThreadInfo | ThreadInfo),
 ): boolean {
   return (
     viewerIsMember(threadInfo) &&
     threadHasPermission(threadInfo, threadPermissions.VISIBLE)
   );
 }
 
 function useIsThreadInChatList(threadInfo: ?ThreadInfo): boolean {
   const threadIsVisible = useThreadHasPermission(
     threadInfo,
     threadPermissions.VISIBLE,
   );
   return viewerIsMember(threadInfo) && threadIsVisible;
 }
 
 function useThreadsInChatList(
   threadInfos: $ReadOnlyArray<ThreadInfo>,
 ): $ReadOnlyArray<ThreadInfo> {
   const visibleThreads = useThreadsWithPermission(
     threadInfos,
     threadPermissions.VISIBLE,
   );
   return React.useMemo(
     () => visibleThreads.filter(viewerIsMember),
     [visibleThreads],
   );
 }
 
 function threadIsTopLevel(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return threadInChatList(threadInfo) && threadIsChannel(threadInfo);
 }
 
 function threadIsChannel(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && !threadTypeIsSidebar(threadInfo.type));
 }
 
 function threadIsSidebar(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && threadTypeIsSidebar(threadInfo.type));
 }
 
 function threadInBackgroundChatList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && !threadIsInHome(threadInfo);
 }
 
 function threadInHomeChatList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && threadIsInHome(threadInfo);
 }
 
 // Can have Calendar entries,
 // does appear as a top-level entity in the thread list
 function threadInFilterList(
   threadInfo: ?(LegacyRawThreadInfo | RawThreadInfo | ThreadInfo),
 ): boolean {
   return (
     threadInChatList(threadInfo) &&
     !!threadInfo &&
     !threadTypeIsSidebar(threadInfo.type)
   );
 }
 
 function userIsMember(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
   userID: string,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   if (threadInfo.id === genesis().id) {
     return true;
   }
   return threadInfo.members.some(member => member.id === userID && member.role);
 }
 
 function threadActualMembers(
   memberInfos: $ReadOnlyArray<MemberInfoWithPermissions | RelativeMemberInfo>,
 ): $ReadOnlyArray<string> {
   return memberInfos
     .filter(memberInfo => memberInfo.role)
     .map(memberInfo => memberInfo.id);
 }
 
 type MemberIDAndRole = {
   +id: string,
   +role: ?string,
   ...
 };
 function threadOtherMembers<T: MemberIDAndRole>(
   memberInfos: $ReadOnlyArray<T>,
   viewerID: ?string,
 ): $ReadOnlyArray<T> {
   return memberInfos.filter(
     memberInfo => memberInfo.role && memberInfo.id !== viewerID,
   );
 }
 
 function threadMembersWithoutAddedAdmin<
   T: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
 >(threadInfo: T): $PropertyType<T, 'members'> {
   if (threadInfo.community !== genesis().id) {
     return threadInfo.members;
   }
   const adminID = extractKeyserverIDFromIDOptional(threadInfo.id);
 
   return threadInfo.members.filter(
     member => member.id !== adminID || member.role,
   );
 }
 
 function threadIsGroupChat(threadInfo: ThreadInfo): boolean {
   return threadInfo.members.length > 2;
 }
 
 function threadOrParentThreadIsGroupChat(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
 ) {
   return threadMembersWithoutAddedAdmin(threadInfo).length > 2;
 }
 
 function threadIsPending(threadID: ?string): boolean {
   return !!threadID?.startsWith('pending');
 }
 
 function threadIsPendingSidebar(threadID: ?string): boolean {
   return !!threadID?.startsWith('pending/sidebar/');
 }
 
 function getSingleOtherUser(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
   viewerID: ?string,
 ): ?string {
   if (!viewerID) {
     return undefined;
   }
   const otherMembers = threadOtherMembers(threadInfo.members, viewerID);
   if (otherMembers.length !== 1) {
     return undefined;
   }
   return otherMembers[0].id;
 }
 
 function getPendingThreadID(
   threadType: ThreadType,
   memberIDs: $ReadOnlyArray<string>,
   sourceMessageID: ?string,
 ): string {
   let pendingThreadKey;
   if (sourceMessageID && threadTypeIsThick(threadType)) {
     pendingThreadKey = `thick_sidebar/${sourceMessageID}`;
   } else if (sourceMessageID) {
     pendingThreadKey = `sidebar/${sourceMessageID}`;
   } else {
     pendingThreadKey = [...memberIDs].sort().join('+');
   }
 
   const pendingThreadTypeString = sourceMessageID ? '' : `type${threadType}/`;
   return `pending/${pendingThreadTypeString}${pendingThreadKey}`;
 }
 
 type PendingThreadIDContents = {
   +threadType: ThreadType,
   +memberIDs: $ReadOnlyArray<string>,
   +sourceMessageID: ?string,
 };
 
 function parsePendingThreadID(
   pendingThreadID: string,
 ): ?PendingThreadIDContents {
   const pendingRegex = new RegExp(`^${pendingThreadIDRegex}$`);
   const pendingThreadIDMatches = pendingRegex.exec(pendingThreadID);
   if (!pendingThreadIDMatches) {
     return null;
   }
 
   const [threadTypeString, threadKey] = pendingThreadIDMatches[1].split('/');
   let threadType;
   if (threadTypeString === 'thick_sidebar') {
     threadType = threadTypes.THICK_SIDEBAR;
   } else if (threadTypeString === 'sidebar') {
     threadType = threadTypes.SIDEBAR;
   } else {
     threadType = assertThreadType(Number(threadTypeString.replace('type', '')));
   }
 
   const threadTypeStringIsSidebar =
     threadTypeString === 'sidebar' || threadTypeString === 'thick_sidebar';
   const memberIDs = threadTypeStringIsSidebar ? [] : threadKey.split('+');
   const sourceMessageID = threadTypeStringIsSidebar ? threadKey : null;
   return {
     threadType,
     memberIDs,
     sourceMessageID,
   };
 }
 
 type UserIDAndUsername = {
   +id: string,
   +username: ?string,
   ...
 };
 type CreatePendingThreadArgs = {
   +viewerID: string,
   +threadType: ThreadType,
   +members: $ReadOnlyArray<UserIDAndUsername>,
   +parentThreadInfo?: ?ThreadInfo,
   +threadColor?: ?string,
   +name?: ?string,
   +sourceMessageID?: string,
 };
 
 function createPendingThread({
   viewerID,
   threadType,
   members,
   parentThreadInfo,
   threadColor,
   name,
   sourceMessageID,
 }: CreatePendingThreadArgs): ThreadInfo {
   const now = Date.now();
   if (!members.some(member => member.id === viewerID)) {
     throw new Error(
       'createPendingThread should be called with the viewer as a member',
     );
   }
 
   const memberIDs = members.map(member => member.id);
   const threadID = getPendingThreadID(threadType, memberIDs, sourceMessageID);
 
   const permissions: ThreadRolePermissionsBlob = {
     [threadPermissions.KNOW_OF]: true,
     [threadPermissions.VISIBLE]: true,
     [threadPermissions.VOICED]: true,
   };
 
   const membershipPermissions = getAllThreadPermissions(
     makePermissionsBlob(permissions, null, threadID, threadType),
     threadID,
   );
   const role: RoleInfo = {
     ...minimallyEncodeRoleInfo({
       id: `${threadID}/role`,
       name: 'Members',
       permissions,
       isDefault: true,
     }),
     specialRole: specialRoles.DEFAULT_ROLE,
   };
 
   let rawThreadInfo: RawThreadInfo;
   if (threadTypeIsThick(threadType)) {
     const thickThreadType = assertThickThreadType(threadType);
     rawThreadInfo = {
       minimallyEncoded: true,
       thick: true,
       id: threadID,
       type: thickThreadType,
       name: name ?? null,
       description: null,
       color: threadColor ?? generatePendingThreadColor(memberIDs),
       creationTime: now,
       parentThreadID: parentThreadInfo?.id ?? null,
       containingThreadID: getContainingThreadID(
         parentThreadInfo,
         thickThreadType,
       ),
       members: members.map(member =>
         minimallyEncodeMemberInfo<ThickMemberInfo>({
           id: member.id,
           role: role.id,
           permissions: membershipPermissions,
           isSender: false,
           subscription: defaultThreadSubscription,
         }),
       ),
       roles: {
         [role.id]: role,
       },
       currentUser: minimallyEncodeThreadCurrentUserInfo({
         role: role.id,
         permissions: membershipPermissions,
         subscription: defaultThreadSubscription,
         unread: false,
       }),
       repliesCount: 0,
       sourceMessageID,
       pinnedCount: 0,
+      timestamps: createThreadTimestamps(now, memberIDs),
     };
   } else {
     const thinThreadType = assertThinThreadType(threadType);
     rawThreadInfo = {
       minimallyEncoded: true,
       id: threadID,
       type: thinThreadType,
       name: name ?? null,
       description: null,
       color: threadColor ?? generatePendingThreadColor(memberIDs),
       creationTime: now,
       parentThreadID: parentThreadInfo?.id ?? null,
       containingThreadID: getContainingThreadID(
         parentThreadInfo,
         thinThreadType,
       ),
       community: getCommunity(parentThreadInfo),
       members: members.map(member => ({
         id: member.id,
         role: role.id,
         minimallyEncoded: true,
         isSender: false,
       })),
       roles: {
         [role.id]: role,
       },
       currentUser: minimallyEncodeThreadCurrentUserInfo({
         role: role.id,
         permissions: membershipPermissions,
         subscription: defaultThreadSubscription,
         unread: false,
       }),
       repliesCount: 0,
       sourceMessageID,
       pinnedCount: 0,
     };
   }
 
   const userInfos: { [string]: UserInfo } = {};
   for (const member of members) {
     const { id, username } = member;
     userInfos[id] = { id, username };
   }
 
   return threadInfoFromRawThreadInfo(rawThreadInfo, viewerID, userInfos);
 }
 
 type PendingPersonalThread = {
   +threadInfo: ThreadInfo,
   +pendingPersonalThreadUserInfo: UserInfo,
 };
 
 function createPendingPersonalThread(
   loggedInUserInfo: LoggedInUserInfo,
   userID: string,
   username: ?string,
 ): PendingPersonalThread {
   const pendingPersonalThreadUserInfo = {
     id: userID,
     username: username,
   };
 
   const threadInfo = createPendingThread({
     viewerID: loggedInUserInfo.id,
     threadType: threadTypes.GENESIS_PERSONAL,
     members: [loggedInUserInfo, pendingPersonalThreadUserInfo],
   });
 
   return { threadInfo, pendingPersonalThreadUserInfo };
 }
 
 function createPendingThreadItem(
   loggedInUserInfo: LoggedInUserInfo,
   user: UserIDAndUsername,
 ): ChatThreadItem {
   const { threadInfo, pendingPersonalThreadUserInfo } =
     createPendingPersonalThread(loggedInUserInfo, user.id, user.username);
 
   return {
     type: 'chatThreadItem',
     threadInfo,
     mostRecentMessageInfo: null,
     mostRecentNonLocalMessage: null,
     lastUpdatedTime: threadInfo.creationTime,
     lastUpdatedTimeIncludingSidebars: threadInfo.creationTime,
     sidebars: [],
     pendingPersonalThreadUserInfo,
   };
 }
 
 // Returns map from lowercase username to AccountUserInfo
 function memberLowercaseUsernameMap(
   members: $ReadOnlyArray<RelativeMemberInfo>,
 ): Map<string, AccountUserInfo> {
   const memberMap = new Map<string, AccountUserInfo>();
   for (const member of members) {
     const { id, role, username } = member;
     if (!role || !username) {
       continue;
     }
     memberMap.set(username.toLowerCase(), { id, username });
   }
   return memberMap;
 }
 
 // Returns map from user ID to AccountUserInfo
 function extractMentionedMembers(
   text: string,
   threadInfo: ThreadInfo,
 ): Map<string, AccountUserInfo> {
   const memberMap = memberLowercaseUsernameMap(threadInfo.members);
   const mentions = extractUserMentionsFromText(text);
 
   const mentionedMembers = new Map<string, AccountUserInfo>();
   for (const mention of mentions) {
     const userInfo = memberMap.get(mention.toLowerCase());
     if (userInfo) {
       mentionedMembers.set(userInfo.id, userInfo);
     }
   }
   return mentionedMembers;
 }
 
 // When a member of the parent is mentioned in a sidebar,
 // they will be automatically added to that sidebar
 function extractNewMentionedParentMembers(
   messageText: string,
   threadInfo: ThreadInfo,
   parentThreadInfo: ThreadInfo,
 ): AccountUserInfo[] {
   const mentionedMembersOfParent = extractMentionedMembers(
     messageText,
     parentThreadInfo,
   );
   for (const member of threadInfo.members) {
     if (member.role) {
       mentionedMembersOfParent.delete(member.id);
     }
   }
   return [...mentionedMembersOfParent.values()];
 }
 
 function pendingThreadType(
   numberOfOtherMembers: number,
 ): 4 | 6 | 7 | 13 | 14 | 15 {
   if (usingOlmViaTunnelbrokerForDMs) {
     if (numberOfOtherMembers === 0) {
       return threadTypes.PRIVATE;
     } else if (numberOfOtherMembers === 1) {
       return threadTypes.PERSONAL;
     } else {
       return threadTypes.LOCAL;
     }
   } else {
     if (numberOfOtherMembers === 0) {
       return threadTypes.GENESIS_PRIVATE;
     } else if (numberOfOtherMembers === 1) {
       return threadTypes.GENESIS_PERSONAL;
     } else {
       return threadTypes.COMMUNITY_SECRET_SUBTHREAD;
     }
   }
 }
 
 function threadTypeCanBePending(threadType: ThreadType): boolean {
   return (
     threadType === threadTypes.GENESIS_PERSONAL ||
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.SIDEBAR ||
     threadType === threadTypes.GENESIS_PRIVATE ||
     threadType === threadTypes.PERSONAL ||
     threadType === threadTypes.LOCAL ||
     threadType === threadTypes.THICK_SIDEBAR ||
     threadType === threadTypes.PRIVATE
   );
 }
 
 type RawThreadInfoOptions = {
   +filterThreadEditAvatarPermission?: boolean,
   +excludePinInfo?: boolean,
   +filterManageInviteLinksPermission?: boolean,
   +filterVoicedInAnnouncementChannelsPermission?: boolean,
   +minimallyEncodePermissions?: boolean,
   +includeSpecialRoleFieldInRoles?: boolean,
   +allowAddingUsersToCommunityRoot?: boolean,
   +filterManageFarcasterChannelTagsPermission?: boolean,
   +stripMemberPermissions?: boolean,
 };
 
 function rawThreadInfoFromServerThreadInfo(
   serverThreadInfo: ServerThreadInfo,
   viewerID: string,
   options?: RawThreadInfoOptions,
 ): ?LegacyThinRawThreadInfo | ?ThinRawThreadInfo {
   const filterThreadEditAvatarPermission =
     options?.filterThreadEditAvatarPermission;
   const excludePinInfo = options?.excludePinInfo;
   const filterManageInviteLinksPermission =
     options?.filterManageInviteLinksPermission;
   const filterVoicedInAnnouncementChannelsPermission =
     options?.filterVoicedInAnnouncementChannelsPermission;
   const shouldMinimallyEncodePermissions = options?.minimallyEncodePermissions;
   const shouldIncludeSpecialRoleFieldInRoles =
     options?.includeSpecialRoleFieldInRoles;
   const allowAddingUsersToCommunityRoot =
     options?.allowAddingUsersToCommunityRoot;
   const filterManageFarcasterChannelTagsPermission =
     options?.filterManageFarcasterChannelTagsPermission;
   const stripMemberPermissions = options?.stripMemberPermissions;
 
   const filterThreadPermissions = (
     innerThreadPermissions: ThreadPermissionsInfo,
   ) => {
     if (
       allowAddingUsersToCommunityRoot &&
       (serverThreadInfo.type === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
         serverThreadInfo.type === threadTypes.COMMUNITY_ROOT)
     ) {
       innerThreadPermissions = {
         ...innerThreadPermissions,
         [threadPermissions.ADD_MEMBERS]: {
           value: true,
           source: serverThreadInfo.id,
         },
       };
     }
     return _omitBy(
       (v, k) =>
         (filterThreadEditAvatarPermission &&
           [
             threadPermissions.EDIT_THREAD_AVATAR,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissions.EDIT_THREAD_AVATAR,
           ].includes(k)) ||
         (excludePinInfo &&
           [
             threadPermissions.MANAGE_PINS,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissions.MANAGE_PINS,
           ].includes(k)) ||
         (filterManageInviteLinksPermission &&
           [threadPermissions.MANAGE_INVITE_LINKS].includes(k)) ||
         (filterVoicedInAnnouncementChannelsPermission &&
           [
             threadPermissions.VOICED_IN_ANNOUNCEMENT_CHANNELS,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissionFilterPrefixes.TOP_LEVEL +
               threadPermissions.VOICED_IN_ANNOUNCEMENT_CHANNELS,
           ].includes(k)) ||
         (filterManageFarcasterChannelTagsPermission &&
           [threadPermissions.MANAGE_FARCASTER_CHANNEL_TAGS].includes(k)),
     )(innerThreadPermissions);
   };
 
   const members = [];
   let currentUser;
   for (const serverMember of serverThreadInfo.members) {
     if (
       serverThreadInfo.id === genesis().id &&
       serverMember.id !== viewerID &&
       serverMember.id !== ashoat.id
     ) {
       continue;
     }
 
     const memberPermissions = filterThreadPermissions(serverMember.permissions);
 
     members.push({
       id: serverMember.id,
       role: serverMember.role,
       permissions: memberPermissions,
       isSender: serverMember.isSender,
     });
     if (serverMember.id === viewerID) {
       currentUser = {
         role: serverMember.role,
         permissions: memberPermissions,
         subscription: serverMember.subscription,
         unread: serverMember.unread,
       };
     }
   }
 
   let currentUserPermissions;
   if (currentUser) {
     currentUserPermissions = currentUser.permissions;
   } else {
     currentUserPermissions = filterThreadPermissions(
       getAllThreadPermissions(null, serverThreadInfo.id),
     );
     currentUser = {
       role: null,
       permissions: currentUserPermissions,
       subscription: defaultThreadSubscription,
       unread: null,
     };
   }
   if (!permissionLookup(currentUserPermissions, threadPermissions.KNOW_OF)) {
     return null;
   }
 
   const rolesWithFilteredThreadPermissions = _mapValues(role => ({
     ...role,
     permissions: filterThreadPermissions(role.permissions),
   }))(serverThreadInfo.roles);
 
   const rolesWithoutSpecialRoleField = _mapValues(role => {
     const { specialRole, ...roleSansSpecialRole } = role;
     return roleSansSpecialRole;
   })(rolesWithFilteredThreadPermissions);
 
   let rawThreadInfo: any = {
     id: serverThreadInfo.id,
     type: serverThreadInfo.type,
     name: serverThreadInfo.name,
     description: serverThreadInfo.description,
     color: serverThreadInfo.color,
     creationTime: serverThreadInfo.creationTime,
     parentThreadID: serverThreadInfo.parentThreadID,
     members,
     roles: rolesWithoutSpecialRoleField,
     currentUser,
     repliesCount: serverThreadInfo.repliesCount,
     containingThreadID: serverThreadInfo.containingThreadID,
     community: serverThreadInfo.community,
   };
   const sourceMessageID = serverThreadInfo.sourceMessageID;
   if (sourceMessageID) {
     rawThreadInfo = { ...rawThreadInfo, sourceMessageID };
   }
   if (serverThreadInfo.avatar) {
     rawThreadInfo = { ...rawThreadInfo, avatar: serverThreadInfo.avatar };
   }
   if (!excludePinInfo) {
     rawThreadInfo = {
       ...rawThreadInfo,
       pinnedCount: serverThreadInfo.pinnedCount,
     };
   }
 
   if (!shouldMinimallyEncodePermissions) {
     return rawThreadInfo;
   }
 
   const minimallyEncodedRawThreadInfoWithMemberPermissions =
     minimallyEncodeRawThreadInfoWithMemberPermissions(rawThreadInfo);
   invariant(
     !minimallyEncodedRawThreadInfoWithMemberPermissions.thick,
     'ServerThreadInfo should be thin thread',
   );
 
   if (!shouldIncludeSpecialRoleFieldInRoles) {
     const minimallyEncodedRolesWithoutSpecialRoleField = Object.fromEntries(
       entries(minimallyEncodedRawThreadInfoWithMemberPermissions.roles).map(
         ([key, role]) => [
           key,
           {
             ..._omit('specialRole')(role),
             isDefault: roleIsDefaultRole(role),
           },
         ],
       ),
     );
     return {
       ...minimallyEncodedRawThreadInfoWithMemberPermissions,
       roles: minimallyEncodedRolesWithoutSpecialRoleField,
     };
   }
 
   if (!stripMemberPermissions) {
     return minimallyEncodedRawThreadInfoWithMemberPermissions;
   }
 
   // The return value of `deprecatedMinimallyEncodeRawThreadInfo` is typed
   // as `RawThreadInfo`, but still includes thread member permissions.
   // This was to prevent introducing "Legacy" types that would need to be
   // maintained going forward. This `any`-cast allows us to more precisely
   // type the obj being passed to `stripMemberPermissionsFromRawThreadInfo`.
   const rawThreadInfoWithMemberPermissions: ThinRawThreadInfoWithPermissions =
     (minimallyEncodedRawThreadInfoWithMemberPermissions: any);
 
   return stripMemberPermissionsFromRawThreadInfo(
     rawThreadInfoWithMemberPermissions,
   );
 }
 
 function threadUIName(threadInfo: ThreadInfo): string | ThreadEntity {
   if (threadInfo.name) {
     return firstLine(threadInfo.name);
   }
 
   const threadMembers: $ReadOnlyArray<RelativeMemberInfo> =
     threadInfo.members.filter(memberInfo => memberInfo.role);
   const memberEntities: $ReadOnlyArray<UserEntity> = threadMembers.map(member =>
     ET.user({ userInfo: member }),
   );
 
   return {
     type: 'thread',
     id: threadInfo.id,
     name: threadInfo.name,
     display: 'uiName',
     uiName: memberEntities,
     ifJustViewer:
       threadInfo.type === threadTypes.GENESIS_PRIVATE
         ? 'viewer_username'
         : 'just_you_string',
   };
 }
 
 function threadInfoFromRawThreadInfo(
   rawThreadInfo: RawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): ThreadInfo {
   let threadInfo: ThreadInfo = {
     minimallyEncoded: true,
     id: rawThreadInfo.id,
     type: rawThreadInfo.type,
     name: rawThreadInfo.name,
     uiName: '',
     description: rawThreadInfo.description,
     color: rawThreadInfo.color,
     creationTime: rawThreadInfo.creationTime,
     parentThreadID: rawThreadInfo.parentThreadID,
     containingThreadID: rawThreadInfo.containingThreadID,
     community: rawThreadInfo.community,
     members: getRelativeMemberInfos(rawThreadInfo, viewerID, userInfos),
     roles: rawThreadInfo.roles,
     currentUser: rawThreadInfo.currentUser,
     repliesCount: rawThreadInfo.repliesCount,
   };
 
   threadInfo = {
     ...threadInfo,
     uiName: threadUIName(threadInfo),
   };
   const { sourceMessageID, avatar, pinnedCount } = rawThreadInfo;
   if (sourceMessageID) {
     threadInfo = { ...threadInfo, sourceMessageID };
   }
 
   if (avatar) {
     threadInfo = { ...threadInfo, avatar };
   } else if (
     rawThreadInfo.type === threadTypes.GENESIS_PERSONAL ||
     rawThreadInfo.type === threadTypes.GENESIS_PRIVATE
   ) {
     threadInfo = {
       ...threadInfo,
       avatar: getUserAvatarForThread(rawThreadInfo, viewerID, userInfos),
     };
   }
 
   if (pinnedCount) {
     threadInfo = { ...threadInfo, pinnedCount };
   }
   return threadInfo;
 }
 
 function filterOutDisabledPermissions(permissionsBitmask: string): string {
   const decodedPermissions: ThreadPermissionsInfo =
     threadPermissionsFromBitmaskHex(permissionsBitmask);
   const updatedPermissions = { ...decodedPermissions, ...disabledPermissions };
   const encodedUpdatedPermissions: string =
     permissionsToBitmaskHex(updatedPermissions);
   return encodedUpdatedPermissions;
 }
 
 function baseThreadIsWithBlockedUserOnly(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock: boolean,
 ) {
   const otherUserID = getSingleOtherUser(threadInfo, viewerID);
   if (!otherUserID) {
     return false;
   }
   const otherUserRelationshipStatus =
     userInfos[otherUserID]?.relationshipStatus;
 
   if (checkOnlyViewerBlock) {
     return (
       otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_BY_VIEWER
     );
   }
 
   return (
     !!otherUserRelationshipStatus &&
     relationshipBlockedInEitherDirection(otherUserRelationshipStatus)
   );
 }
 
 function threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
   threadInfo: ThreadInfo | RawThreadInfo | LegacyRawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock: boolean,
 ): boolean {
   if (threadOrParentThreadIsGroupChat(threadInfo)) {
     return false;
   }
   return baseThreadIsWithBlockedUserOnly(
     threadInfo,
     viewerID,
     userInfos,
     checkOnlyViewerBlock,
   );
 }
 
 function useThreadFrozenDueToViewerBlock(
   threadInfo: ThreadInfo,
   communityThreadInfo: ?ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   const communityThreadInfoArray = React.useMemo(
     () => (communityThreadInfo ? [communityThreadInfo] : []),
     [communityThreadInfo],
   );
   const communityRootsMembersToRole = useCommunityRootMembersToRole(
     communityThreadInfoArray,
   );
   const memberToRole = communityRootsMembersToRole[communityThreadInfo?.id];
 
   const memberHasAdminRole = threadMembersWithoutAddedAdmin(threadInfo).some(
     m => roleIsAdminRole(memberToRole?.[m.id]),
   );
 
   return React.useMemo(() => {
     if (memberHasAdminRole) {
       return false;
     }
 
     return threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
       threadInfo,
       viewerID,
       userInfos,
       true,
     );
   }, [memberHasAdminRole, threadInfo, userInfos, viewerID]);
 }
 
 const threadTypeDescriptions: { [ThreadType]: string } = {
   [threadTypes.COMMUNITY_OPEN_SUBTHREAD]:
     'Anybody in the parent channel can see an open subchannel.',
   [threadTypes.COMMUNITY_SECRET_SUBTHREAD]:
     'Only visible to its members and admins of ancestor channels.',
 };
 
 function roleIsDefaultRole(
   roleInfo: ?ClientLegacyRoleInfo | ?RoleInfo,
 ): boolean {
   if (roleInfo?.specialRole === specialRoles.DEFAULT_ROLE) {
     return true;
   }
   return !!(roleInfo && roleInfo.isDefault);
 }
 
 function roleIsAdminRole(roleInfo: ?ClientLegacyRoleInfo | ?RoleInfo): boolean {
   if (roleInfo?.specialRole === specialRoles.ADMIN_ROLE) {
     return true;
   }
   return !!(roleInfo && !roleInfo.isDefault && roleInfo.name === 'Admins');
 }
 
 function threadHasAdminRole(
   threadInfo: ?(
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo
     | ServerThreadInfo
   ),
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   let hasSpecialRoleFieldBeenEncountered = false;
   for (const role of Object.values(threadInfo.roles)) {
     if (role.specialRole === specialRoles.ADMIN_ROLE) {
       return true;
     }
     if (role.specialRole !== undefined) {
       hasSpecialRoleFieldBeenEncountered = true;
     }
   }
   if (hasSpecialRoleFieldBeenEncountered) {
     return false;
   }
   return !!_find({ name: 'Admins' })(threadInfo.roles);
 }
 
 function identifyInvalidatedThreads(
   updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
 ): Set<string> {
   const invalidated = new Set<string>();
   for (const updateInfo of updateInfos) {
     if (updateInfo.type === updateTypes.DELETE_THREAD) {
       invalidated.add(updateInfo.threadID);
     }
   }
   return invalidated;
 }
 
 const permissionsDisabledByBlockArray = values(
   threadPermissionsDisabledByBlock,
 );
 
 const permissionsDisabledByBlock: Set<ThreadPermission> = new Set(
   permissionsDisabledByBlockArray,
 );
 
 const disabledPermissions: ThreadPermissionsInfo =
   permissionsDisabledByBlockArray.reduce(
     (permissions: ThreadPermissionsInfo, permission: string) => ({
       ...permissions,
       [permission]: { value: false, source: null },
     }),
     {},
   );
 
 // Consider updating itemHeight in native/chat/chat-thread-list.react.js
 // if you change this
 const emptyItemText: string =
   `Muted chats are just like normal chats, except they don't ` +
   `contribute to your unread count.\n\n` +
   `To move a chat over here, switch the “Muted” option in its settings.`;
 
 function threadNoun(threadType: ThreadType, parentThreadID: ?string): string {
   if (threadTypeIsSidebar(threadType)) {
     return 'thread';
   } else if (
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD &&
     parentThreadID === genesis().id
   ) {
     return 'chat';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.GENESIS
   ) {
     return 'channel';
   } else {
     return 'chat';
   }
 }
 
 function threadLabel(threadType: ThreadType): string {
   if (
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD
   ) {
     return 'Open';
   } else if (threadType === threadTypes.GENESIS_PERSONAL) {
     return 'Personal';
   } else if (threadTypeIsSidebar(threadType)) {
     return 'Thread';
   } else if (threadType === threadTypes.GENESIS_PRIVATE) {
     return 'Private';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.GENESIS
   ) {
     return 'Community';
   } else {
     return 'Secret';
   }
 }
 
 type ExistingThreadInfoFinderParams = {
   +searching: boolean,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
 };
 type ExistingThreadInfoFinder = (
   params: ExistingThreadInfoFinderParams,
 ) => ?ThreadInfo;
 
 function useExistingThreadInfoFinder(
   baseThreadInfo: ?ThreadInfo,
 ): ExistingThreadInfoFinder {
   const threadInfos = useSelector(threadInfoSelector);
   const loggedInUserInfo = useLoggedInUserInfo();
 
   const pendingToRealizedThreadIDs = useSelector(state =>
     pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
   );
   return React.useCallback(
     (params: ExistingThreadInfoFinderParams): ?ThreadInfo => {
       if (!baseThreadInfo) {
         return null;
       }
 
       const realizedThreadInfo = threadInfos[baseThreadInfo.id];
       if (realizedThreadInfo) {
         return realizedThreadInfo;
       }
 
       if (!loggedInUserInfo || !threadIsPending(baseThreadInfo.id)) {
         return baseThreadInfo;
       }
       const viewerID = loggedInUserInfo?.id;
 
       invariant(
         threadTypeCanBePending(baseThreadInfo.type),
         `ThreadInfo has pending ID ${baseThreadInfo.id}, but type that ` +
           `should not be pending ${baseThreadInfo.type}`,
       );
 
       const { searching, userInfoInputArray } = params;
 
       const { sourceMessageID } = baseThreadInfo;
       const pendingThreadID = searching
         ? getPendingThreadID(
             pendingThreadType(userInfoInputArray.length),
             [...userInfoInputArray.map(user => user.id), viewerID],
             sourceMessageID,
           )
         : getPendingThreadID(
             baseThreadInfo.type,
             baseThreadInfo.members.map(member => member.id),
             sourceMessageID,
           );
 
       const realizedThreadID = pendingToRealizedThreadIDs.get(pendingThreadID);
       if (realizedThreadID && threadInfos[realizedThreadID]) {
         return threadInfos[realizedThreadID];
       }
 
       const updatedThread = searching
         ? createPendingThread({
             viewerID,
             threadType: pendingThreadType(userInfoInputArray.length),
             members: [loggedInUserInfo, ...userInfoInputArray],
           })
         : baseThreadInfo;
 
       return updatedThread;
     },
     [baseThreadInfo, threadInfos, loggedInUserInfo, pendingToRealizedThreadIDs],
   );
 }
 
 type ThreadTypeParentRequirement = 'optional' | 'required' | 'disabled';
 
 function getThreadTypeParentRequirement(
   threadType: ThreadType,
 ): ThreadTypeParentRequirement {
   if (
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD ||
     //threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD ||
     threadTypeIsSidebar(threadType)
   ) {
     return 'required';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.GENESIS ||
     threadType === threadTypes.GENESIS_PERSONAL ||
     threadType === threadTypes.GENESIS_PRIVATE
   ) {
     return 'disabled';
   } else {
     return 'optional';
   }
 }
 
 function checkIfDefaultMembersAreVoiced(threadInfo: ThreadInfo): boolean {
   const defaultRoleID = Object.keys(threadInfo.roles).find(roleID =>
     roleIsDefaultRole(threadInfo.roles[roleID]),
   );
   invariant(
     defaultRoleID !== undefined,
     'all threads should have a default role',
   );
   const defaultRole = threadInfo.roles[defaultRoleID];
   const defaultRolePermissions =
     decodeMinimallyEncodedRoleInfo(defaultRole).permissions;
 
   return !!defaultRolePermissions[threadPermissions.VOICED];
 }
 
 const draftKeySuffix = '/message_composer';
 
 function draftKeyFromThreadID(threadID: string): string {
   return `${threadID}${draftKeySuffix}`;
 }
 
 function getContainingThreadID(
   parentThreadInfo:
     | ?ServerThreadInfo
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo,
   threadType: ThreadType,
 ): ?string {
   if (!parentThreadInfo) {
     return null;
   }
   if (threadTypeIsSidebar(threadType)) {
     return parentThreadInfo.id;
   }
   if (!parentThreadInfo.containingThreadID) {
     return parentThreadInfo.id;
   }
   return parentThreadInfo.containingThreadID;
 }
 
 function getCommunity(
   parentThreadInfo:
     | ?ServerThreadInfo
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo,
 ): ?string {
   if (!parentThreadInfo) {
     return null;
   }
   const { id, community, type } = parentThreadInfo;
   if (community !== null && community !== undefined) {
     return community;
   }
   if (threadTypeIsCommunityRoot(type)) {
     return id;
   }
   return null;
 }
 
 function getThreadListSearchResults(
   chatListData: $ReadOnlyArray<ChatThreadItem>,
   searchText: string,
   threadFilter: ThreadInfo => boolean,
   threadSearchResults: $ReadOnlySet<string>,
   usersSearchResults: $ReadOnlyArray<GlobalAccountUserInfo>,
   loggedInUserInfo: ?LoggedInUserInfo,
 ): $ReadOnlyArray<ChatThreadItem> {
   if (!searchText) {
     return chatListData.filter(
       item =>
         threadIsTopLevel(item.threadInfo) && threadFilter(item.threadInfo),
     );
   }
 
   const privateThreads = [];
   const personalThreads = [];
   const otherThreads = [];
   for (const item of chatListData) {
     if (!threadSearchResults.has(item.threadInfo.id)) {
       continue;
     }
     if (item.threadInfo.type === threadTypes.GENESIS_PRIVATE) {
       privateThreads.push({ ...item, sidebars: [] });
     } else if (item.threadInfo.type === threadTypes.GENESIS_PERSONAL) {
       personalThreads.push({ ...item, sidebars: [] });
     } else {
       otherThreads.push({ ...item, sidebars: [] });
     }
   }
 
   const chatItems: ChatThreadItem[] = [
     ...privateThreads,
     ...personalThreads,
     ...otherThreads,
   ];
   if (loggedInUserInfo) {
     chatItems.push(
       ...usersSearchResults.map(user =>
         createPendingThreadItem(loggedInUserInfo, user),
       ),
     );
   }
   return chatItems;
 }
 
 function reorderThreadSearchResults<T: RawThreadInfo | ThreadInfo>(
   threadInfos: $ReadOnlyArray<T>,
   threadSearchResults: $ReadOnlyArray<string>,
 ): T[] {
   const privateThreads = [];
   const personalThreads = [];
   const otherThreads = [];
   const threadSearchResultsSet = new Set(threadSearchResults);
   for (const threadInfo of threadInfos) {
     if (!threadSearchResultsSet.has(threadInfo.id)) {
       continue;
     }
     if (threadInfo.type === threadTypes.GENESIS_PRIVATE) {
       privateThreads.push(threadInfo);
     } else if (threadInfo.type === threadTypes.GENESIS_PERSONAL) {
       personalThreads.push(threadInfo);
     } else {
       otherThreads.push(threadInfo);
     }
   }
 
   return [...privateThreads, ...personalThreads, ...otherThreads];
 }
 
 function useAvailableThreadMemberActions(
   memberInfo: RelativeMemberInfo,
   threadInfo: ThreadInfo,
   canEdit: ?boolean = true,
 ): $ReadOnlyArray<'change_role' | 'remove_user'> {
   const canRemoveMembers = useThreadHasPermission(
     threadInfo,
     threadPermissions.REMOVE_MEMBERS,
   );
   const canChangeRoles = useThreadHasPermission(
     threadInfo,
     threadPermissions.CHANGE_ROLE,
   );
 
   return React.useMemo(() => {
     const { role } = memberInfo;
     if (!canEdit || !role) {
       return [];
     }
 
     const result = [];
 
     if (
       canChangeRoles &&
       memberInfo.username &&
       threadHasAdminRole(threadInfo)
     ) {
       result.push('change_role');
     }
 
     if (
       canRemoveMembers &&
       !memberInfo.isViewer &&
       (canChangeRoles || roleIsDefaultRole(threadInfo.roles[role]))
     ) {
       result.push('remove_user');
     }
 
     return result;
   }, [canChangeRoles, canEdit, canRemoveMembers, memberInfo, threadInfo]);
 }
 
 function patchThreadInfoToIncludeMentionedMembersOfParent(
   threadInfo: ThreadInfo,
   parentThreadInfo: ThreadInfo,
   messageText: string,
   viewerID: string,
 ): ThreadInfo {
   const members: UserIDAndUsername[] = threadInfo.members
     .map(({ id, username }) =>
       username ? ({ id, username }: UserIDAndUsername) : null,
     )
     .filter(Boolean);
   const mentionedNewMembers = extractNewMentionedParentMembers(
     messageText,
     threadInfo,
     parentThreadInfo,
   );
   if (mentionedNewMembers.length === 0) {
     return threadInfo;
   }
   members.push(...mentionedNewMembers);
   return createPendingThread({
     viewerID,
     threadType: threadTypes.SIDEBAR,
     members,
     parentThreadInfo,
     threadColor: threadInfo.color,
     name: threadInfo.name,
     sourceMessageID: threadInfo.sourceMessageID,
   });
 }
 
 function threadInfoInsideCommunity(
   threadInfo: RawThreadInfo | ThreadInfo,
   communityID: string,
 ): boolean {
   return threadInfo.community === communityID || threadInfo.id === communityID;
 }
 
 type RoleAndMemberCount = {
   [roleName: string]: number,
 };
 
 function useRoleMemberCountsForCommunity(
   threadInfo: ThreadInfo,
 ): RoleAndMemberCount {
   return React.useMemo(() => {
     const roleIDsToNames: { [string]: string } = {};
 
     Object.keys(threadInfo.roles).forEach(roleID => {
       roleIDsToNames[roleID] = threadInfo.roles[roleID].name;
     });
 
     const roleNamesToMemberCount: RoleAndMemberCount = {};
 
     threadInfo.members.forEach(({ role: roleID }) => {
       invariant(roleID, 'Community member should have a role');
       const roleName = roleIDsToNames[roleID];
 
       roleNamesToMemberCount[roleName] =
         (roleNamesToMemberCount[roleName] ?? 0) + 1;
     });
 
     // For all community roles with no members, add them to the list with 0
     Object.keys(roleIDsToNames).forEach(roleName => {
       if (roleNamesToMemberCount[roleIDsToNames[roleName]] === undefined) {
         roleNamesToMemberCount[roleIDsToNames[roleName]] = 0;
       }
     });
 
     return roleNamesToMemberCount;
   }, [threadInfo.members, threadInfo.roles]);
 }
 
 function useRoleNamesToSpecialRole(threadInfo: ThreadInfo): {
   +[roleName: string]: ?SpecialRole,
 } {
   return React.useMemo(() => {
     const roleNamesToSpecialRole: { [roleName: string]: ?SpecialRole } = {};
     values(threadInfo.roles).forEach(role => {
       if (roleNamesToSpecialRole[role.name] !== undefined) {
         return;
       }
       if (roleIsDefaultRole(role)) {
         roleNamesToSpecialRole[role.name] = specialRoles.DEFAULT_ROLE;
       } else if (roleIsAdminRole(role)) {
         roleNamesToSpecialRole[role.name] = specialRoles.ADMIN_ROLE;
       } else {
         roleNamesToSpecialRole[role.name] = null;
       }
     });
     return roleNamesToSpecialRole;
   }, [threadInfo.roles]);
 }
 
 type RoleUserSurfacedPermissions = {
   +[roleName: string]: $ReadOnlySet<UserSurfacedPermission>,
 };
 // Iterates through the existing roles in the community and 'reverse maps'
 // the set of permission literals for each role to user-facing permission enums
 // to help pre-populate the permission checkboxes when editing roles.
 function useRoleUserSurfacedPermissions(
   threadInfo: ThreadInfo,
 ): RoleUserSurfacedPermissions {
   return React.useMemo(() => {
     const roleNamesToPermissions: { [string]: Set<UserSurfacedPermission> } =
       {};
 
     Object.keys(threadInfo.roles).forEach(roleID => {
       const roleName = threadInfo.roles[roleID].name;
       const rolePermissions = decodeMinimallyEncodedRoleInfo(
         threadInfo.roles[roleID],
       ).permissions;
       roleNamesToPermissions[roleName] =
         userSurfacedPermissionsFromRolePermissions(rolePermissions);
     });
 
     return roleNamesToPermissions;
   }, [threadInfo.roles]);
 }
 
 function communityOrThreadNoun(threadInfo: RawThreadInfo | ThreadInfo): string {
   return threadTypeIsCommunityRoot(threadInfo.type)
     ? 'community'
     : threadNoun(threadInfo.type, threadInfo.parentThreadID);
 }
 
 function getThreadsToDeleteText(
   threadInfo: RawThreadInfo | ThreadInfo,
 ): string {
   return `${
     threadTypeIsCommunityRoot(threadInfo.type)
       ? 'Subchannels and threads'
       : 'Threads'
   } within this ${communityOrThreadNoun(threadInfo)}`;
 }
 
 function useUserProfileThreadInfo(userInfo: ?UserInfo): ?UserProfileThreadInfo {
   const userID = userInfo?.id;
   const username = userInfo?.username;
 
   const loggedInUserInfo = useLoggedInUserInfo();
   const isViewerProfile = loggedInUserInfo?.id === userID;
 
   const privateThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.GENESIS_PRIVATE,
   );
   const privateThreadInfos = useSelector(privateThreadInfosSelector);
 
   const personalThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.GENESIS_PERSONAL,
   );
 
   const personalThreadInfos = useSelector(personalThreadInfosSelector);
 
   const usersWithPersonalThread = useSelector(usersWithPersonalThreadSelector);
 
   return React.useMemo(() => {
     if (!loggedInUserInfo || !userID || !username) {
       return null;
     }
 
     if (isViewerProfile) {
       const privateThreadInfo: ?ThreadInfo = privateThreadInfos[0];
 
       return privateThreadInfo ? { threadInfo: privateThreadInfo } : null;
     }
 
     if (usersWithPersonalThread.has(userID)) {
       const personalThreadInfo: ?ThreadInfo = personalThreadInfos.find(
         threadInfo =>
           userID === getSingleOtherUser(threadInfo, loggedInUserInfo.id),
       );
 
       return personalThreadInfo ? { threadInfo: personalThreadInfo } : null;
     }
 
     const pendingPersonalThreadInfo = createPendingPersonalThread(
       loggedInUserInfo,
       userID,
       username,
     );
 
     return pendingPersonalThreadInfo;
   }, [
     isViewerProfile,
     loggedInUserInfo,
     personalThreadInfos,
     privateThreadInfos,
     userID,
     username,
     usersWithPersonalThread,
   ]);
 }
 
 function assertAllThreadInfosAreLegacy(rawThreadInfos: MixedRawThreadInfos): {
   [id: string]: LegacyRawThreadInfo,
 } {
   return Object.fromEntries(
     Object.entries(rawThreadInfos).map(([id, rawThreadInfo]) => {
       invariant(
         !rawThreadInfo.minimallyEncoded,
         `rawThreadInfos shouldn't be minimallyEncoded`,
       );
       return [id, rawThreadInfo];
     }),
   );
 }
 
 function useOnScreenEntryEditableThreadInfos(): $ReadOnlyArray<ThreadInfo> {
   const visibleThreadInfos = useSelector(onScreenThreadInfos);
   const editableVisibleThreadInfos = useThreadsWithPermission(
     visibleThreadInfos,
     threadPermissions.EDIT_ENTRIES,
   );
   return editableVisibleThreadInfos;
 }
 
+function createThreadTimestamps(
+  timestamp: number,
+  memberIDs: $ReadOnlyArray<string>,
+): ThreadTimestamps {
+  return {
+    name: timestamp,
+    avatar: timestamp,
+    description: timestamp,
+    color: timestamp,
+    members: Object.fromEntries(
+      memberIDs.map(id => [
+        id,
+        { isMember: timestamp, subscription: timestamp },
+      ]),
+    ),
+    currentUser: {
+      unread: timestamp,
+    },
+  };
+}
+
 export {
   threadHasPermission,
   useCommunityRootMembersToRole,
   useThreadHasPermission,
   viewerIsMember,
   threadInChatList,
   useIsThreadInChatList,
   useThreadsInChatList,
   threadIsTopLevel,
   threadIsChannel,
   threadIsSidebar,
   threadInBackgroundChatList,
   threadInHomeChatList,
   threadIsInHome,
   threadInFilterList,
   userIsMember,
   threadActualMembers,
   threadOtherMembers,
   threadIsGroupChat,
   threadIsPending,
   threadIsPendingSidebar,
   getSingleOtherUser,
   getPendingThreadID,
   parsePendingThreadID,
   createPendingThread,
   extractNewMentionedParentMembers,
   pendingThreadType,
   filterOutDisabledPermissions,
   useThreadFrozenDueToViewerBlock,
   rawThreadInfoFromServerThreadInfo,
   threadUIName,
   threadInfoFromRawThreadInfo,
   threadTypeDescriptions,
   threadIsWithBlockedUserOnlyWithoutAdminRoleCheck,
   roleIsDefaultRole,
   roleIsAdminRole,
   threadHasAdminRole,
   identifyInvalidatedThreads,
   permissionsDisabledByBlock,
   emptyItemText,
   threadNoun,
   threadLabel,
   useExistingThreadInfoFinder,
   getThreadTypeParentRequirement,
   checkIfDefaultMembersAreVoiced,
   draftKeySuffix,
   draftKeyFromThreadID,
   threadTypeCanBePending,
   getContainingThreadID,
   getCommunity,
   getThreadListSearchResults,
   reorderThreadSearchResults,
   useAvailableThreadMemberActions,
   threadMembersWithoutAddedAdmin,
   patchThreadInfoToIncludeMentionedMembersOfParent,
   threadInfoInsideCommunity,
   useRoleMemberCountsForCommunity,
   useRoleNamesToSpecialRole,
   useRoleUserSurfacedPermissions,
   getThreadsToDeleteText,
   useUserProfileThreadInfo,
   assertAllThreadInfosAreLegacy,
   useOnScreenEntryEditableThreadInfos,
   extractMentionedMembers,
   isMemberActive,
+  createThreadTimestamps,
 };
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index 1f26afd35..8a83e8f33 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,471 +1,506 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type AvatarDBContent,
   type ClientAvatar,
   clientAvatarValidator,
   type UpdateUserAvatarRequest,
 } from './avatar-types.js';
 import type { CalendarQuery } from './entry-types.js';
 import type { Media } from './media-types.js';
 import type {
   MessageTruncationStatuses,
   RawMessageInfo,
 } from './message-types.js';
 import type {
   RawThreadInfo,
   ResolvedThreadInfo,
   ThreadInfo,
   ThickRawThreadInfo,
 } from './minimally-encoded-thread-permissions-types.js';
 import {
   type ThreadSubscription,
   threadSubscriptionValidator,
 } from './subscription-types.js';
 import {
   type ThreadPermissionsInfo,
   threadPermissionsInfoValidator,
   type ThreadRolePermissionsBlob,
   threadRolePermissionsBlobValidator,
   type UserSurfacedPermission,
 } from './thread-permission-types.js';
 import {
   type ThinThreadType,
   type ThickThreadType,
   threadTypeValidator,
 } from './thread-types-enum.js';
 import type { ClientUpdateInfo, ServerUpdateInfo } from './update-types.js';
 import type { UserInfo, UserInfos } from './user-types.js';
 import type { SpecialRole } from '../permissions/special-roles.js';
 import { type ThreadEntity } from '../utils/entity-text.js';
 import { tID, tShape, tUserID } from '../utils/validation-utils.js';
 
 export type LegacyMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +isSender: boolean,
 };
 export const legacyMemberInfoValidator: TInterface<LegacyMemberInfo> =
   tShape<LegacyMemberInfo>({
     id: tUserID,
     role: t.maybe(tID),
     permissions: threadPermissionsInfoValidator,
     isSender: t.Boolean,
   });
 
 export type ClientLegacyRoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
 };
 export const clientLegacyRoleInfoValidator: TInterface<ClientLegacyRoleInfo> =
   tShape<ClientLegacyRoleInfo>({
     id: tID,
     name: t.String,
     permissions: threadRolePermissionsBlobValidator,
     isDefault: t.Boolean,
   });
 
 export type ServerLegacyRoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
   +specialRole: ?SpecialRole,
 };
 
 export type LegacyThreadCurrentUserInfo = {
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
 };
 export const legacyThreadCurrentUserInfoValidator: TInterface<LegacyThreadCurrentUserInfo> =
   tShape<LegacyThreadCurrentUserInfo>({
     role: t.maybe(tID),
     permissions: threadPermissionsInfoValidator,
     subscription: threadSubscriptionValidator,
     unread: t.maybe(t.Boolean),
   });
 
 export type LegacyThinRawThreadInfo = {
   +id: string,
   +type: ThinThreadType,
   +name?: ?string,
   +avatar?: ?ClientAvatar,
   +description?: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID?: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<LegacyMemberInfo>,
   +roles: { +[id: string]: ClientLegacyRoleInfo },
   +currentUser: LegacyThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 
 export type ThickMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +isSender: boolean,
 };
 
+export type ThreadTimestamps = {
+  +name: number,
+  +avatar: number,
+  +description: number,
+  +color: number,
+  +members: {
+    +[id: string]: {
+      +isMember: number,
+      +subscription: number,
+    },
+  },
+  +currentUser: {
+    +unread: number,
+  },
+};
+
+export const threadTimestampsValidator: TInterface<ThreadTimestamps> =
+  tShape<ThreadTimestamps>({
+    name: t.Number,
+    avatar: t.Number,
+    description: t.Number,
+    color: t.Number,
+    members: t.dict(
+      tUserID,
+      tShape({
+        isMember: t.Number,
+        subscription: t.Number,
+      }),
+    ),
+    currentUser: tShape({
+      unread: t.Number,
+    }),
+  });
+
 export type LegacyThickRawThreadInfo = {
   +thick: true,
   +id: string,
   +type: ThickThreadType,
   +name?: ?string,
   +avatar?: ?ClientAvatar,
   +description?: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID?: ?string,
   +containingThreadID?: ?string,
   +members: $ReadOnlyArray<ThickMemberInfo>,
   +roles: { +[id: string]: ClientLegacyRoleInfo },
   +currentUser: LegacyThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
+  +timestamps: ThreadTimestamps,
 };
 
 export type LegacyRawThreadInfo =
   | LegacyThinRawThreadInfo
   | LegacyThickRawThreadInfo;
 
 export type LegacyRawThreadInfos = {
   +[id: string]: LegacyRawThreadInfo,
 };
 export const legacyRawThreadInfoValidator: TInterface<LegacyRawThreadInfo> =
   tShape<LegacyRawThreadInfo>({
     id: tID,
     type: threadTypeValidator,
     name: t.maybe(t.String),
     avatar: t.maybe(clientAvatarValidator),
     description: t.maybe(t.String),
     color: t.String,
     creationTime: t.Number,
     parentThreadID: t.maybe(tID),
     containingThreadID: t.maybe(tID),
     community: t.maybe(tID),
     members: t.list(legacyMemberInfoValidator),
     roles: t.dict(tID, clientLegacyRoleInfoValidator),
     currentUser: legacyThreadCurrentUserInfoValidator,
     sourceMessageID: t.maybe(tID),
     repliesCount: t.Number,
     pinnedCount: t.maybe(t.Number),
   });
 
 export type MixedRawThreadInfos = {
   +[id: string]: LegacyRawThreadInfo | RawThreadInfo,
 };
 export type ThickRawThreadInfos = {
   +[id: string]: ThickRawThreadInfo,
 };
 export type RawThreadInfos = {
   +[id: string]: RawThreadInfo,
 };
 
 export type ServerMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
   +isSender: boolean,
 };
 
 export type ServerThreadInfo = {
   +id: string,
   +type: ThinThreadType,
   +name: ?string,
   +avatar?: AvatarDBContent,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +depth: number,
   +members: $ReadOnlyArray<ServerMemberInfo>,
   +roles: { +[id: string]: ServerLegacyRoleInfo },
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount: number,
 };
 
 export type LegacyThreadStore = {
   +threadInfos: MixedRawThreadInfos,
 };
 
 export type ThreadStore = {
   +threadInfos: RawThreadInfos,
 };
 
 export type ClientDBThreadInfo = {
   +id: string,
   +type: number,
   +name: ?string,
   +avatar?: ?string,
   +description: ?string,
   +color: string,
   +creationTime: string,
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: string,
   +roles: string,
   +currentUser: string,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
   +timestamps?: ?string,
 };
 
 export type ThreadDeletionRequest = {
   +threadID: string,
   +accountPassword?: empty,
 };
 
 export type RemoveMembersRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
 };
 
 export type RoleChangeRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +role: string,
 };
 
 export type ChangeThreadSettingsResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type ChangeThreadSettingsPayload = {
   +threadID: string,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type LeaveThreadRequest = {
   +threadID: string,
 };
 export type LeaveThreadResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type LeaveThreadPayload = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 export type ThreadChanges = Partial<{
   +type: ThinThreadType,
   +name: string,
   +description: string,
   +color: string,
   +parentThreadID: ?string,
   +newMemberIDs: $ReadOnlyArray<string>,
   +avatar: UpdateUserAvatarRequest,
 }>;
 
 export type UpdateThreadRequest = {
   +threadID: string,
   +changes: ThreadChanges,
   +accountPassword?: empty,
 };
 
 export type BaseNewThreadRequest = {
   +id?: ?string,
   +name?: ?string,
   +description?: ?string,
   +color?: ?string,
   +parentThreadID?: ?string,
   +initialMemberIDs?: ?$ReadOnlyArray<string>,
   +ghostMemberIDs?: ?$ReadOnlyArray<string>,
 };
 type NewThinThreadRequest =
   | {
       +type: 3 | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 12,
       ...BaseNewThreadRequest,
     }
   | {
       +type: 5,
       +sourceMessageID: string,
       ...BaseNewThreadRequest,
     };
 
 export type ClientNewThinThreadRequest = {
   ...NewThinThreadRequest,
   +calendarQuery: CalendarQuery,
 };
 export type ServerNewThinThreadRequest = {
   ...NewThinThreadRequest,
   +calendarQuery?: ?CalendarQuery,
 };
 
 export type NewThreadResponse = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userInfos: UserInfos,
   +newThreadID: string,
 };
 export type NewThreadResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userInfos: UserInfos,
   +newThreadID: string,
 };
 
 export type ServerThreadJoinRequest = {
   +threadID: string,
   +calendarQuery?: ?CalendarQuery,
   +inviteLinkSecret?: string,
   +defaultSubscription?: ThreadSubscription,
 };
 export type ClientThreadJoinRequest = {
   +threadID: string,
   +calendarQuery: CalendarQuery,
   +inviteLinkSecret?: string,
   +defaultSubscription?: ThreadSubscription,
 };
 export type ThreadJoinResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: UserInfos,
 };
 export type ThreadJoinPayload = {
   +updatesResult: {
     newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +keyserverID: string,
 };
 
 export type ThreadFetchMediaResult = {
   +media: $ReadOnlyArray<Media>,
 };
 export type ThreadFetchMediaRequest = {
   +threadID: string,
   +limit: number,
   +offset: number,
 };
 
 export type SidebarInfo = {
   +threadInfo: ThreadInfo,
   +lastUpdatedTime: number,
   +mostRecentNonLocalMessage: ?string,
 };
 
 export type ToggleMessagePinRequest = {
   +messageID: string,
   +action: 'pin' | 'unpin',
 };
 
 export type ToggleMessagePinResult = {
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +threadID: string,
 };
 
 type CreateRoleAction = {
   +community: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'create_role',
 };
 
 type EditRoleAction = {
   +community: string,
   +existingRoleID: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'edit_role',
 };
 
 export type RoleModificationRequest = CreateRoleAction | EditRoleAction;
 
 export type RoleModificationResult = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type RoleModificationPayload = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 export type RoleDeletionRequest = {
   +community: string,
   +roleID: string,
 };
 
 export type RoleDeletionResult = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type RoleDeletionPayload = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 // We can show a max of 3 sidebars inline underneath their parent in the chat
 // tab. If there are more, we show a button that opens a modal to see the rest
 export const maxReadSidebars = 3;
 
 // We can show a max of 5 sidebars inline underneath their parent
 // in the chat tab if every one of the displayed sidebars is unread
 export const maxUnreadSidebars = 5;
 
 export type ThreadStoreThreadInfos = LegacyRawThreadInfos;
 
 export type ChatMentionCandidate = {
   +threadInfo: ResolvedThreadInfo,
   +rawChatName: string | ThreadEntity,
 };
 export type ChatMentionCandidates = {
   +[id: string]: ChatMentionCandidate,
 };
 export type ChatMentionCandidatesObj = {
   +[id: string]: ChatMentionCandidates,
 };
 
 export type UserProfileThreadInfo = {
   +threadInfo: ThreadInfo,
   +pendingPersonalThreadUserInfo?: UserInfo,
 };
diff --git a/lib/utils/thread-ops-utils.js b/lib/utils/thread-ops-utils.js
index 5e578bf5a..20c7c9cfb 100644
--- a/lib/utils/thread-ops-utils.js
+++ b/lib/utils/thread-ops-utils.js
@@ -1,171 +1,185 @@
 // @flow
 
 import invariant from 'invariant';
 
+import { assertWithValidator } from './validation-utils.js';
 import {
   memberInfoWithPermissionsValidator,
   persistedRoleInfoValidator,
   threadCurrentUserInfoValidator,
   minimallyEncodedThickMemberInfoValidator,
   memberInfoSansPermissionsValidator,
 } from '../permissions/minimally-encoded-raw-thread-info-validators.js';
 import type {
   RawThreadInfo,
   RoleInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import {
   deprecatedDecodeMinimallyEncodedRawThreadInfo,
   minimallyEncodeMemberInfo,
   minimallyEncodeRoleInfo,
   minimallyEncodeThreadCurrentUserInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import {
   assertThreadType,
   threadTypeIsThick,
   assertThinThreadType,
   assertThickThreadType,
 } from '../types/thread-types-enum.js';
 import {
   type ClientDBThreadInfo,
   legacyMemberInfoValidator,
   type LegacyRawThreadInfo,
   clientLegacyRoleInfoValidator,
   legacyThreadCurrentUserInfoValidator,
+  threadTimestampsValidator,
 } from '../types/thread-types.js';
 
 function convertRawThreadInfoToClientDBThreadInfo(
   rawThreadInfo: LegacyRawThreadInfo | RawThreadInfo,
 ): ClientDBThreadInfo {
   const { minimallyEncoded, thick, ...rest } = rawThreadInfo;
   return {
     ...rest,
     creationTime: rawThreadInfo.creationTime.toString(),
     members: JSON.stringify(rawThreadInfo.members),
     roles: JSON.stringify(rawThreadInfo.roles),
     currentUser: JSON.stringify(rawThreadInfo.currentUser),
     avatar: rawThreadInfo.avatar ? JSON.stringify(rawThreadInfo.avatar) : null,
     community: rawThreadInfo.community,
+    timestamps: rawThreadInfo.timestamps
+      ? JSON.stringify(rawThreadInfo.timestamps)
+      : null,
   };
 }
 
 function convertClientDBThreadInfoToRawThreadInfo(
   clientDBThreadInfo: ClientDBThreadInfo,
 ): RawThreadInfo {
   // 1. Validate and potentially minimally encode `rawMembers`.
   const rawMembers = JSON.parse(clientDBThreadInfo.members);
   const minimallyEncodedMembers = rawMembers.map(rawMember => {
     invariant(
       memberInfoSansPermissionsValidator.is(rawMember) ||
         minimallyEncodedThickMemberInfoValidator.is(rawMember) ||
         memberInfoWithPermissionsValidator.is(rawMember) ||
         legacyMemberInfoValidator.is(rawMember),
       'rawMember must be valid [MinimallyEncoded/Legacy]MemberInfo',
     );
     return rawMember.minimallyEncoded
       ? rawMember
       : minimallyEncodeMemberInfo(rawMember);
   });
 
   // 2. Validate and potentially minimally encode `rawRoles`.
   const rawRoles = JSON.parse(clientDBThreadInfo.roles);
   const minimallyEncodedRoles: { +[id: string]: RoleInfo } = Object.keys(
     rawRoles,
   ).reduce((acc: { [string]: RoleInfo }, roleID: string) => {
     const roleInfo = rawRoles[roleID];
     invariant(
       persistedRoleInfoValidator.is(roleInfo) ||
         clientLegacyRoleInfoValidator.is(roleInfo),
       'rawRole must be valid [MinimallyEncoded/Legacy]RoleInfo',
     );
     acc[roleID] = roleInfo.minimallyEncoded
       ? roleInfo
       : minimallyEncodeRoleInfo(roleInfo);
     return acc;
   }, {});
 
   // 3. Validate and potentially minimally encode `rawCurrentUser`.
   const rawCurrentUser = JSON.parse(clientDBThreadInfo.currentUser);
   invariant(
     threadCurrentUserInfoValidator.is(rawCurrentUser) ||
       legacyThreadCurrentUserInfoValidator.is(rawCurrentUser),
     'rawCurrentUser must be valid [MinimallyEncoded]ThreadCurrentUserInfo',
   );
   const minimallyEncodedCurrentUser = rawCurrentUser.minimallyEncoded
     ? rawCurrentUser
     : minimallyEncodeThreadCurrentUserInfo(rawCurrentUser);
 
   let rawThreadInfo: RawThreadInfo;
   const threadType = assertThreadType(clientDBThreadInfo.type);
   if (threadTypeIsThick(threadType)) {
     const thickThreadType = assertThickThreadType(threadType);
+    invariant(
+      clientDBThreadInfo.timestamps,
+      'Thick thread info must contain the timestamps',
+    );
+    const threadTimestamps = assertWithValidator(
+      JSON.parse(clientDBThreadInfo.timestamps),
+      threadTimestampsValidator,
+    );
     rawThreadInfo = {
       minimallyEncoded: true,
       thick: true,
       id: clientDBThreadInfo.id,
       type: thickThreadType,
       name: clientDBThreadInfo.name,
       description: clientDBThreadInfo.description,
       color: clientDBThreadInfo.color,
       creationTime: Number(clientDBThreadInfo.creationTime),
       parentThreadID: clientDBThreadInfo.parentThreadID,
       containingThreadID: clientDBThreadInfo.containingThreadID,
       members: minimallyEncodedMembers,
       roles: minimallyEncodedRoles,
       currentUser: minimallyEncodedCurrentUser,
       repliesCount: clientDBThreadInfo.repliesCount,
       pinnedCount: clientDBThreadInfo.pinnedCount,
+      timestamps: threadTimestamps,
     };
   } else {
     const thinThreadType = assertThinThreadType(threadType);
     rawThreadInfo = {
       minimallyEncoded: true,
       id: clientDBThreadInfo.id,
       type: thinThreadType,
       name: clientDBThreadInfo.name,
       description: clientDBThreadInfo.description,
       color: clientDBThreadInfo.color,
       creationTime: Number(clientDBThreadInfo.creationTime),
       parentThreadID: clientDBThreadInfo.parentThreadID,
       containingThreadID: clientDBThreadInfo.containingThreadID,
       community: clientDBThreadInfo.community,
       members: minimallyEncodedMembers,
       roles: minimallyEncodedRoles,
       currentUser: minimallyEncodedCurrentUser,
       repliesCount: clientDBThreadInfo.repliesCount,
       pinnedCount: clientDBThreadInfo.pinnedCount,
     };
   }
 
   if (clientDBThreadInfo.sourceMessageID) {
     rawThreadInfo = {
       ...rawThreadInfo,
       sourceMessageID: clientDBThreadInfo.sourceMessageID,
     };
   }
 
   if (clientDBThreadInfo.avatar) {
     rawThreadInfo = {
       ...rawThreadInfo,
       avatar: JSON.parse(clientDBThreadInfo.avatar),
     };
   }
 
   return rawThreadInfo;
 }
 
 // WARNING: Do not consume or delete this function!
 // This function is being left in the codebase **SOLELY** to ensure that
 // previous `native` redux migrations continue to behave as expected.
 function deprecatedConvertClientDBThreadInfoToRawThreadInfo(
   clientDBThreadInfo: ClientDBThreadInfo,
 ): LegacyRawThreadInfo {
   const minimallyEncoded =
     convertClientDBThreadInfoToRawThreadInfo(clientDBThreadInfo);
   return deprecatedDecodeMinimallyEncodedRawThreadInfo(minimallyEncoded);
 }
 
 export {
   convertRawThreadInfoToClientDBThreadInfo,
   convertClientDBThreadInfoToRawThreadInfo,
   deprecatedConvertClientDBThreadInfoToRawThreadInfo,
 };
diff --git a/lib/utils/thread-ops-utils.test.js b/lib/utils/thread-ops-utils.test.js
index 4db617a02..66febe5bb 100644
--- a/lib/utils/thread-ops-utils.test.js
+++ b/lib/utils/thread-ops-utils.test.js
@@ -1,431 +1,432 @@
 // @flow
 
 import {
   convertClientDBThreadInfoToRawThreadInfo,
   convertRawThreadInfoToClientDBThreadInfo,
 } from './thread-ops-utils.js';
 import type {
   ClientDBThreadInfo,
   LegacyRawThreadInfo,
 } from '../types/thread-types.js';
 
 const rawThreadInfo: LegacyRawThreadInfo = {
   id: '84015',
   type: 6,
   name: 'atul_web',
   description: 'Hello world!',
   color: '4b87aa',
   creationTime: 1679595843051,
   parentThreadID: '1',
   members: [
     {
       id: '256',
       role: null,
       permissions: {
         know_of: {
           value: true,
           source: '1',
         },
         visible: {
           value: true,
           source: '1',
         },
         voiced: {
           value: true,
           source: '1',
         },
         edit_entries: {
           value: true,
           source: '1',
         },
         edit_thread: {
           value: true,
           source: '1',
         },
         edit_thread_description: {
           value: true,
           source: '1',
         },
         edit_thread_color: {
           value: true,
           source: '1',
         },
         delete_thread: {
           value: true,
           source: '1',
         },
         create_subthreads: {
           value: true,
           source: '1',
         },
         create_sidebars: {
           value: true,
           source: '1',
         },
         join_thread: {
           value: true,
           source: '1',
         },
         edit_permissions: {
           value: true,
           source: '1',
         },
         add_members: {
           value: true,
           source: '1',
         },
         remove_members: {
           value: true,
           source: '1',
         },
         change_role: {
           value: true,
           source: '1',
         },
         leave_thread: {
           value: false,
           source: null,
         },
         react_to_message: {
           value: false,
           source: null,
         },
         edit_message: {
           value: false,
           source: null,
         },
       },
       isSender: false,
     },
     {
       id: '83809',
       role: '84016',
       permissions: {
         know_of: {
           value: true,
           source: '84015',
         },
         visible: {
           value: true,
           source: '84015',
         },
         voiced: {
           value: true,
           source: '84015',
         },
         edit_entries: {
           value: true,
           source: '84015',
         },
         edit_thread: {
           value: true,
           source: '84015',
         },
         edit_thread_description: {
           value: true,
           source: '84015',
         },
         edit_thread_color: {
           value: true,
           source: '84015',
         },
         delete_thread: {
           value: false,
           source: null,
         },
         create_subthreads: {
           value: false,
           source: null,
         },
         create_sidebars: {
           value: true,
           source: '84015',
         },
         join_thread: {
           value: false,
           source: null,
         },
         edit_permissions: {
           value: false,
           source: null,
         },
         add_members: {
           value: false,
           source: null,
         },
         remove_members: {
           value: false,
           source: null,
         },
         change_role: {
           value: false,
           source: null,
         },
         leave_thread: {
           value: false,
           source: null,
         },
         react_to_message: {
           value: true,
           source: '84015',
         },
         edit_message: {
           value: true,
           source: '84015',
         },
       },
       isSender: true,
     },
     {
       id: '83969',
       role: '84016',
       permissions: {
         know_of: {
           value: true,
           source: '84015',
         },
         visible: {
           value: true,
           source: '84015',
         },
         voiced: {
           value: true,
           source: '84015',
         },
         edit_entries: {
           value: true,
           source: '84015',
         },
         edit_thread: {
           value: true,
           source: '84015',
         },
         edit_thread_description: {
           value: true,
           source: '84015',
         },
         edit_thread_color: {
           value: true,
           source: '84015',
         },
         delete_thread: {
           value: false,
           source: null,
         },
         create_subthreads: {
           value: false,
           source: null,
         },
         create_sidebars: {
           value: true,
           source: '84015',
         },
         join_thread: {
           value: false,
           source: null,
         },
         edit_permissions: {
           value: false,
           source: null,
         },
         add_members: {
           value: false,
           source: null,
         },
         remove_members: {
           value: false,
           source: null,
         },
         change_role: {
           value: false,
           source: null,
         },
         leave_thread: {
           value: false,
           source: null,
         },
         react_to_message: {
           value: true,
           source: '84015',
         },
         edit_message: {
           value: true,
           source: '84015',
         },
       },
       isSender: true,
     },
   ],
   roles: {
     '84016': {
       id: '84016',
       name: 'Members',
       permissions: {
         know_of: true,
         visible: true,
         voiced: true,
         react_to_message: true,
         edit_message: true,
         edit_entries: true,
         edit_thread: true,
         edit_thread_color: true,
         edit_thread_description: true,
         create_sidebars: true,
         descendant_open_know_of: true,
         descendant_open_visible: true,
         child_open_join_thread: true,
       },
       isDefault: true,
     },
   },
   currentUser: {
     role: '84016',
     permissions: {
       know_of: {
         value: true,
         source: '84015',
       },
       visible: {
         value: true,
         source: '84015',
       },
       voiced: {
         value: true,
         source: '84015',
       },
       edit_entries: {
         value: true,
         source: '84015',
       },
       edit_thread: {
         value: true,
         source: '84015',
       },
       edit_thread_description: {
         value: true,
         source: '84015',
       },
       edit_thread_color: {
         value: true,
         source: '84015',
       },
       delete_thread: {
         value: false,
         source: null,
       },
       create_subthreads: {
         value: false,
         source: null,
       },
       create_sidebars: {
         value: true,
         source: '84015',
       },
       join_thread: {
         value: false,
         source: null,
       },
       edit_permissions: {
         value: false,
         source: null,
       },
       add_members: {
         value: false,
         source: null,
       },
       remove_members: {
         value: false,
         source: null,
       },
       change_role: {
         value: false,
         source: null,
       },
       leave_thread: {
         value: false,
         source: null,
       },
       react_to_message: {
         value: true,
         source: '84015',
       },
       edit_message: {
         value: true,
         source: '84015',
       },
     },
     subscription: {
       home: true,
       pushNotifs: true,
     },
     unread: false,
   },
   repliesCount: 0,
   containingThreadID: '1',
   community: '1',
   pinnedCount: 0,
 };
 
 const clientDBThreadInfo: ClientDBThreadInfo = {
   id: '84015',
   type: 6,
   name: 'atul_web',
   description: 'Hello world!',
   color: '4b87aa',
   creationTime: '1679595843051',
   parentThreadID: '1',
   members:
     '[{"id":"256","role":null,"permissions":{"know_of":{"value":true,"source":"1"},"visible":{"value":true,"source":"1"},"voiced":{"value":true,"source":"1"},"edit_entries":{"value":true,"source":"1"},"edit_thread":{"value":true,"source":"1"},"edit_thread_description":{"value":true,"source":"1"},"edit_thread_color":{"value":true,"source":"1"},"delete_thread":{"value":true,"source":"1"},"create_subthreads":{"value":true,"source":"1"},"create_sidebars":{"value":true,"source":"1"},"join_thread":{"value":true,"source":"1"},"edit_permissions":{"value":true,"source":"1"},"add_members":{"value":true,"source":"1"},"remove_members":{"value":true,"source":"1"},"change_role":{"value":true,"source":"1"},"leave_thread":{"value":false,"source":null},"react_to_message":{"value":false,"source":null},"edit_message":{"value":false,"source":null}},"isSender":false},{"id":"83809","role":"84016","permissions":{"know_of":{"value":true,"source":"84015"},"visible":{"value":true,"source":"84015"},"voiced":{"value":true,"source":"84015"},"edit_entries":{"value":true,"source":"84015"},"edit_thread":{"value":true,"source":"84015"},"edit_thread_description":{"value":true,"source":"84015"},"edit_thread_color":{"value":true,"source":"84015"},"delete_thread":{"value":false,"source":null},"create_subthreads":{"value":false,"source":null},"create_sidebars":{"value":true,"source":"84015"},"join_thread":{"value":false,"source":null},"edit_permissions":{"value":false,"source":null},"add_members":{"value":false,"source":null},"remove_members":{"value":false,"source":null},"change_role":{"value":false,"source":null},"leave_thread":{"value":false,"source":null},"react_to_message":{"value":true,"source":"84015"},"edit_message":{"value":true,"source":"84015"}},"isSender":true},{"id":"83969","role":"84016","permissions":{"know_of":{"value":true,"source":"84015"},"visible":{"value":true,"source":"84015"},"voiced":{"value":true,"source":"84015"},"edit_entries":{"value":true,"source":"84015"},"edit_thread":{"value":true,"source":"84015"},"edit_thread_description":{"value":true,"source":"84015"},"edit_thread_color":{"value":true,"source":"84015"},"delete_thread":{"value":false,"source":null},"create_subthreads":{"value":false,"source":null},"create_sidebars":{"value":true,"source":"84015"},"join_thread":{"value":false,"source":null},"edit_permissions":{"value":false,"source":null},"add_members":{"value":false,"source":null},"remove_members":{"value":false,"source":null},"change_role":{"value":false,"source":null},"leave_thread":{"value":false,"source":null},"react_to_message":{"value":true,"source":"84015"},"edit_message":{"value":true,"source":"84015"}},"isSender":true}]',
   roles:
     '{"84016":{"id":"84016","name":"Members","permissions":{"know_of":true,"visible":true,"voiced":true,"react_to_message":true,"edit_message":true,"edit_entries":true,"edit_thread":true,"edit_thread_color":true,"edit_thread_description":true,"create_sidebars":true,"descendant_open_know_of":true,"descendant_open_visible":true,"child_open_join_thread":true},"isDefault":true}}',
   currentUser:
     '{"role":"84016","permissions":{"know_of":{"value":true,"source":"84015"},"visible":{"value":true,"source":"84015"},"voiced":{"value":true,"source":"84015"},"edit_entries":{"value":true,"source":"84015"},"edit_thread":{"value":true,"source":"84015"},"edit_thread_description":{"value":true,"source":"84015"},"edit_thread_color":{"value":true,"source":"84015"},"delete_thread":{"value":false,"source":null},"create_subthreads":{"value":false,"source":null},"create_sidebars":{"value":true,"source":"84015"},"join_thread":{"value":false,"source":null},"edit_permissions":{"value":false,"source":null},"add_members":{"value":false,"source":null},"remove_members":{"value":false,"source":null},"change_role":{"value":false,"source":null},"leave_thread":{"value":false,"source":null},"react_to_message":{"value":true,"source":"84015"},"edit_message":{"value":true,"source":"84015"}},"subscription":{"home":true,"pushNotifs":true},"unread":false}',
   repliesCount: 0,
   containingThreadID: '1',
   community: '1',
   avatar: null,
   pinnedCount: 0,
+  timestamps: null,
 };
 
 describe('convertRawThreadInfoToClientDBThreadInfo', () => {
   it('should successfuly convert RawThreadInfo to ClientDBThreadInfo', () => {
     expect(
       convertRawThreadInfoToClientDBThreadInfo(rawThreadInfo),
     ).toStrictEqual(clientDBThreadInfo);
   });
 });
 
 // TODO (atul): Update test data and re-enable these tests
 xdescribe('convertClientDBThreadInfoToRawThreadInfo', () => {
   it('should successfuly convert ClientDBThreadInfo to RawThreadInfo', () => {
     expect(
       convertClientDBThreadInfoToRawThreadInfo(
         convertRawThreadInfoToClientDBThreadInfo(rawThreadInfo),
       ),
     ).toStrictEqual(rawThreadInfo);
   });
 });
 
 const rawThreadInfoWithAvatar: LegacyRawThreadInfo = {
   ...rawThreadInfo,
   avatar: { type: 'emoji', color: '4b87aa', emoji: '😀' },
 };
 
 describe('convertRawThreadInfoToClientDBThreadInfo', () => {
   it('should NOT convert rawThreadInfoWithAvatar to clientDBThreadInfo (without avatar)', () => {
     expect(
       convertRawThreadInfoToClientDBThreadInfo(rawThreadInfoWithAvatar),
     ).not.toStrictEqual(clientDBThreadInfo);
   });
 });
 
 // TODO (atul): Update test data and re-enable these tests
 xdescribe('convertClientDBThreadInfoToRawThreadInfo', () => {
   it('should successfuly recreate original rawThreadInfoWithAvatar', () => {
     expect(
       convertClientDBThreadInfoToRawThreadInfo(
         convertRawThreadInfoToClientDBThreadInfo(rawThreadInfoWithAvatar),
       ),
     ).toStrictEqual(rawThreadInfoWithAvatar);
   });
 });