diff --git a/lib/actions/activity-actions.js b/lib/actions/activity-actions.js
--- a/lib/actions/activity-actions.js
+++ b/lib/actions/activity-actions.js
@@ -20,7 +20,10 @@
   SetThreadUnreadStatusPayload,
   SetThreadUnreadStatusRequest,
 } from '../types/activity-types.js';
-import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
+import type {
+  RawThreadInfo,
+  ThreadInfo,
+} from '../types/minimally-encoded-thread-permissions-types.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 export type UpdateActivityInput = {
@@ -109,7 +112,7 @@
   };
 
 export type UseSetThreadUnreadStatusInput = {
-  +threadInfo: ThreadInfo,
+  +threadInfo: ThreadInfo | RawThreadInfo,
   ...SetThreadUnreadStatusRequest,
 };
 function useSetThreadUnreadStatus(): (
diff --git a/lib/handlers/dm-activity-handler.js b/lib/handlers/dm-activity-handler.js
--- a/lib/handlers/dm-activity-handler.js
+++ b/lib/handlers/dm-activity-handler.js
@@ -3,60 +3,16 @@
 import _debounce from 'lodash/debounce.js';
 import * as React from 'react';
 
-import {
-  type OutboundDMOperationSpecification,
-  dmOperationSpecificationTypes,
-} from '../shared/dm-ops/dm-op-types.js';
+import { useSetThreadUnreadStatus } from '../actions/activity-actions.js';
 import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
 import { getMostRecentNonLocalMessageID } from '../shared/id-utils.js';
 import { threadIsPending } from '../shared/thread-utils.js';
 import { threadSpecs } from '../shared/threads/thread-specs.js';
-import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
 import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 const ACTIVITY_UPDATE_DURATION = 5000;
 
-function useUpdateDMActivity(): (
-  viewerID: string,
-  activeThread: string,
-) => Promise<void> {
-  const processAndSendDMOperation = useProcessAndSendDMOperation();
-  return React.useCallback(
-    async (viewerID: string, activeThread: string) => {
-      const op: DMChangeThreadReadStatusOperation = {
-        type: 'change_thread_read_status',
-        time: Date.now(),
-        threadID: activeThread,
-        creatorID: viewerID,
-        unread: false,
-      };
-
-      const opSpecification: OutboundDMOperationSpecification = {
-        type: dmOperationSpecificationTypes.OUTBOUND,
-        op,
-        recipients: { type: 'self_devices' },
-      };
-
-      await processAndSendDMOperation(opSpecification);
-    },
-    [processAndSendDMOperation],
-  );
-}
-
-function getUpateActivityAfterLatestMessageChange(
-  viewerID: ?string,
-  activeThread: ?string,
-  updateDMActivity: (viewerID: string, activeThread: string) => Promise<void>,
-) {
-  return _debounce(() => {
-    if (!activeThread || !viewerID) {
-      return;
-    }
-    void updateDMActivity(viewerID, activeThread);
-  }, ACTIVITY_UPDATE_DURATION);
-}
-
 function useDMActivityHandler(activeThread: ?string): void {
   const activeThreadInfo = useSelector(state =>
     activeThread ? state.threadStore.threadInfos[activeThread] : null,
@@ -74,15 +30,34 @@
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
-  const updateDMActivity = useUpdateDMActivity();
+
+  const setThreadUnreadStatus = useSetThreadUnreadStatus();
+  const updateDMActivity = React.useCallback(async () => {
+    if (!activeThreadInfo) {
+      return;
+    }
+    const input = {
+      threadInfo: activeThreadInfo,
+      threadID: activeThreadInfo.id,
+      unread: false,
+      latestMessage: activeThreadLatestMessage,
+    };
+    await setThreadUnreadStatus(input);
+  }, [activeThreadInfo, activeThreadLatestMessage, setThreadUnreadStatus]);
+
+  const getUpdateActivityAfterLatestMessageChange = React.useCallback(() => {
+    return _debounce(() => {
+      if (!activeThread) {
+        return;
+      }
+      void updateDMActivity();
+    }, ACTIVITY_UPDATE_DURATION);
+  }, [activeThread, updateDMActivity]);
+
   const dispatchActionPromise = useDispatchActionPromise();
 
   const updateActivityAfterLatestMessageChangeRef = React.useRef(
-    getUpateActivityAfterLatestMessageChange(
-      viewerID,
-      activeThread,
-      updateDMActivity,
-    ),
+    getUpdateActivityAfterLatestMessageChange(),
   );
 
   React.useEffect(() => {
@@ -96,11 +71,7 @@
     const activeThreadChanged = prevActiveThread !== activeThread;
     if (activeThreadChanged) {
       updateActivityAfterLatestMessageChangeRef.current =
-        getUpateActivityAfterLatestMessageChange(
-          viewerID,
-          activeThread,
-          updateDMActivity,
-        );
+        getUpdateActivityAfterLatestMessageChange();
     }
 
     if (
@@ -115,7 +86,7 @@
     }
 
     if (activeThreadInfo.currentUser.unread) {
-      void updateDMActivity(viewerID, activeThread);
+      void updateDMActivity();
       return;
     }
 
@@ -135,6 +106,7 @@
     processAndSendDMOperation,
     activeThreadInfo,
     activeThreadLatestMessage,
+    getUpdateActivityAfterLatestMessageChange,
   ]);
 }