diff --git a/keyserver/src/creators/role-creator.js b/keyserver/src/creators/role-creator.js
index 77c25444b..3aff1d1c5 100644
--- a/keyserver/src/creators/role-creator.js
+++ b/keyserver/src/creators/role-creator.js
@@ -1,143 +1,188 @@
 // @flow
 
 import { getRolePermissionBlobs } from 'lib/permissions/thread-permissions.js';
 import {
   universalCommunityPermissions,
   userSurfacedPermissionsSet,
   configurableCommunityPermissions,
   threadPermissions,
 } from 'lib/types/thread-permission-types.js';
 import type { ThreadType } from 'lib/types/thread-types-enum.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import type {
   RoleInfo,
   RoleModificationRequest,
+  RoleModificationResult,
 } from 'lib/types/thread-types.js';
+import { updateTypes } from 'lib/types/update-types-enum.js';
 import { ServerError } from 'lib/utils/errors.js';
 
 import createIDs from './id-creator.js';
+import { createUpdates } from './update-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
-import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
+import {
+  fetchThreadInfos,
+  fetchServerThreadInfos,
+  rawThreadInfosFromServerThreadInfos,
+} from '../fetchers/thread-fetchers.js';
 import { checkThreadPermission } from '../fetchers/thread-permission-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 
 type InitialRoles = {
   +default: RoleInfo,
   +creator: RoleInfo,
 };
 async function createInitialRolesForNewThread(
   threadID: string,
   threadType: ThreadType,
 ): Promise<InitialRoles> {
   const rolePermissions = getRolePermissionBlobs(threadType);
   const ids = await createIDs('roles', Object.values(rolePermissions).length);
 
   const time = Date.now();
   const newRows = [];
   const namesToIDs = {};
   for (const name in rolePermissions) {
     const id = ids.shift();
     namesToIDs[name] = id;
     const permissionsBlob = JSON.stringify(rolePermissions[name]);
     newRows.push([id, threadID, name, permissionsBlob, time]);
   }
 
   const query = SQL`
     INSERT INTO roles (id, thread, name, permissions, creation_time)
     VALUES ${newRows}
   `;
   await dbQuery(query);
 
   const defaultRoleInfo = {
     id: namesToIDs.Members,
     name: 'Members',
     permissions: rolePermissions.Members,
     isDefault: true,
   };
   if (!rolePermissions.Admins) {
     return {
       default: defaultRoleInfo,
       creator: defaultRoleInfo,
     };
   }
 
   const adminRoleInfo = {
     id: namesToIDs.Admins,
     name: 'Admins',
     permissions: rolePermissions.Admins,
     isDefault: false,
   };
   return {
     default: defaultRoleInfo,
     creator: adminRoleInfo,
   };
 }
 
 async function modifyRole(
   viewer: Viewer,
   request: RoleModificationRequest,
-): Promise<void> {
+): Promise<RoleModificationResult> {
   const hasPermission = await checkThreadPermission(
     viewer,
     request.community,
     threadPermissions.CHANGE_ROLE,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_credentials');
   }
 
   const { community, name, permissions, action } = request;
 
   for (const permission of permissions) {
     if (!userSurfacedPermissionsSet.has(permission)) {
       throw new ServerError('invalid_parameters');
     }
   }
 
   const [id] = await createIDs('roles', 1);
   const time = Date.now();
 
   const configuredPermissions = permissions
     .map(permission => [...configurableCommunityPermissions[permission]])
     .flat();
 
   const rolePermissions = [
     ...universalCommunityPermissions,
     ...configuredPermissions,
   ];
 
   // For communities of the type `COMMUNITY_ANNOUNCEMENT_ROOT`, the ability for
   // the role to be voiced needs to be configured (i.e. the parameters should
   // include the user-facing permission VOICED_IN_ANNOUNCEMENT_CHANNELS). This
   // means we do not give 'voiced' permissions by default to all new roles. As
   // a result, if the thread type is `COMMUNITY_ROOT`, we want to ensure that
   // the role has the voiced permission.
   const { threadInfos } = await fetchThreadInfos(viewer, {
     threadID: community,
   });
   const threadInfo = threadInfos[community];
 
   if (threadInfo.type === threadTypes.COMMUNITY_ROOT) {
     rolePermissions.push(threadPermissions.VOICED);
   }
 
   const permissionsBlob = JSON.stringify(
     Object.fromEntries(rolePermissions.map(permission => [permission, true])),
   );
 
   const row = [id, community, name, permissionsBlob, time];
 
   let query = SQL``;
   if (action === 'create_role') {
     query = SQL`
       INSERT INTO roles (id, thread, name, permissions, creation_time)
       VALUES (${row})
     `;
   } else if (action === 'edit_role') {
     throw new ServerError("unimplemented: can't edit roles yet");
   }
 
   await dbQuery(query);
+
+  const fetchServerThreadInfosResult = await fetchServerThreadInfos({
+    threadID: community,
+  });
+  const { threadInfos: serverThreadInfos } = fetchServerThreadInfosResult;
+  const serverThreadInfo = serverThreadInfos[community];
+
+  if (!serverThreadInfo) {
+    throw new ServerError('internal_error');
+  }
+
+  const updateDatas = [];
+  for (const memberInfo of serverThreadInfo.members) {
+    updateDatas.push({
+      type: updateTypes.UPDATE_THREAD,
+      userID: memberInfo.id,
+      time,
+      threadID: community,
+    });
+  }
+
+  const { viewerUpdates } = await createUpdates(updateDatas, {
+    viewer,
+    updatesForCurrentSession: 'return',
+  });
+
+  const { threadInfos: rawThreadInfos } = rawThreadInfosFromServerThreadInfos(
+    viewer,
+    fetchServerThreadInfosResult,
+  );
+  const rawThreadInfo = rawThreadInfos[community];
+
+  return {
+    threadInfo: rawThreadInfo,
+    updatesResult: {
+      newUpdates: viewerUpdates,
+    },
+  };
 }
 
 export { createInitialRolesForNewThread, modifyRole };
diff --git a/keyserver/src/responders/thread-responders.js b/keyserver/src/responders/thread-responders.js
index feec17317..d294f622a 100644
--- a/keyserver/src/responders/thread-responders.js
+++ b/keyserver/src/responders/thread-responders.js
@@ -1,383 +1,398 @@
 // @flow
 
 import t from 'tcomb';
 import type { TInterface, TUnion } from 'tcomb';
 
 import { mediaValidator } from 'lib/types/media-types.js';
 import {
   rawMessageInfoValidator,
   messageTruncationStatusesValidator,
 } from 'lib/types/message-types.js';
 import { userSurfacedPermissionValidator } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import {
   type ThreadDeletionRequest,
   type RoleChangeRequest,
   type ChangeThreadSettingsResult,
   type RemoveMembersRequest,
   type LeaveThreadRequest,
   type LeaveThreadResult,
   type UpdateThreadRequest,
   type ServerNewThreadRequest,
   type NewThreadResponse,
   type ServerThreadJoinRequest,
   type ThreadJoinResult,
   type ThreadFetchMediaResult,
   type ThreadFetchMediaRequest,
   type ToggleMessagePinRequest,
   type ToggleMessagePinResult,
   type RoleModificationRequest,
+  type RoleModificationResult,
+  rawThreadInfoValidator,
 } from 'lib/types/thread-types.js';
 import { serverUpdateInfoValidator } from 'lib/types/update-types.js';
 import { userInfosValidator } from 'lib/types/user-types.js';
 import { updateUserAvatarRequestValidator } from 'lib/utils/avatar-utils.js';
 import { values } from 'lib/utils/objects.js';
 import {
   tShape,
   tNumEnum,
   tColor,
   tPassword,
   tID,
 } from 'lib/utils/validation-utils.js';
 
 import {
   entryQueryInputValidator,
   verifyCalendarQueryThreadIDs,
 } from './entry-responders.js';
 import { modifyRole } from '../creators/role-creator.js';
 import { createThread } from '../creators/thread-creator.js';
 import { deleteThread } from '../deleters/thread-deleters.js';
 import { fetchMediaForThread } from '../fetchers/upload-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   updateRole,
   removeMembers,
   leaveThread,
   updateThread,
   joinThread,
   toggleMessagePinForThread,
 } from '../updaters/thread-updaters.js';
 import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const threadDeletionRequestInputValidator = tShape<ThreadDeletionRequest>({
   threadID: tID,
   accountPassword: t.maybe(tPassword),
 });
 
 export const leaveThreadResultValidator: TInterface<LeaveThreadResult> =
   tShape<LeaveThreadResult>({
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function threadDeletionResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<LeaveThreadResult> {
   const request = await validateInput(
     viewer,
     threadDeletionRequestInputValidator,
     input,
   );
   const result = await deleteThread(viewer, request);
   return validateOutput(
     viewer.platformDetails,
     leaveThreadResultValidator,
     result,
   );
 }
 
 export const roleChangeRequestInputValidator: TInterface<RoleChangeRequest> =
   tShape<RoleChangeRequest>({
     threadID: tID,
     memberIDs: t.list(t.String),
     role: t.refinement(tID, str => {
       if (str.indexOf('|') !== -1) {
         str = str.split('|')[1];
       }
       const int = parseInt(str, 10);
       return String(int) === str && int > 0;
     }),
   });
 
 export const changeThreadSettingsResultValidator: TInterface<ChangeThreadSettingsResult> =
   tShape<ChangeThreadSettingsResult>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function roleUpdateResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ChangeThreadSettingsResult> {
   const request = await validateInput(
     viewer,
     roleChangeRequestInputValidator,
     input,
   );
   const result = await updateRole(viewer, request);
   return validateOutput(
     viewer.platformDetails,
     changeThreadSettingsResultValidator,
     result,
   );
 }
 
 const removeMembersRequestInputValidator = tShape<RemoveMembersRequest>({
   threadID: tID,
   memberIDs: t.list(t.String),
 });
 
 async function memberRemovalResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ChangeThreadSettingsResult> {
   const request = await validateInput(
     viewer,
     removeMembersRequestInputValidator,
     input,
   );
   const result = await removeMembers(viewer, request);
   return validateOutput(
     viewer.platformDetails,
     changeThreadSettingsResultValidator,
     result,
   );
 }
 
 const leaveThreadRequestInputValidator = tShape<LeaveThreadRequest>({
   threadID: tID,
 });
 
 async function threadLeaveResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<LeaveThreadResult> {
   const request = await validateInput(
     viewer,
     leaveThreadRequestInputValidator,
     input,
   );
   const result = await leaveThread(viewer, request);
   return validateOutput(
     viewer.platformDetails,
     leaveThreadResultValidator,
     result,
   );
 }
 
 const updateThreadRequestInputValidator = tShape<UpdateThreadRequest>({
   threadID: tID,
   changes: tShape({
     type: t.maybe(tNumEnum(values(threadTypes))),
     name: t.maybe(t.String),
     description: t.maybe(t.String),
     color: t.maybe(tColor),
     parentThreadID: t.maybe(tID),
     newMemberIDs: t.maybe(t.list(t.String)),
     avatar: t.maybe(updateUserAvatarRequestValidator),
   }),
   accountPassword: t.maybe(tPassword),
 });
 
 async function threadUpdateResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ChangeThreadSettingsResult> {
   const request = await validateInput(
     viewer,
     updateThreadRequestInputValidator,
     input,
   );
   const result = await updateThread(viewer, request);
   return validateOutput(
     viewer.platformDetails,
     changeThreadSettingsResultValidator,
     result,
   );
 }
 
 const threadRequestValidationShape = {
   name: t.maybe(t.String),
   description: t.maybe(t.String),
   color: t.maybe(tColor),
   parentThreadID: t.maybe(tID),
   initialMemberIDs: t.maybe(t.list(t.String)),
   calendarQuery: t.maybe(entryQueryInputValidator),
 };
 const newThreadRequestInputValidator: TUnion<ServerNewThreadRequest> = t.union([
   tShape({
     type: tNumEnum([threadTypes.SIDEBAR]),
     sourceMessageID: tID,
     ...threadRequestValidationShape,
   }),
   tShape({
     type: tNumEnum([
       threadTypes.COMMUNITY_OPEN_SUBTHREAD,
       threadTypes.COMMUNITY_SECRET_SUBTHREAD,
       threadTypes.PERSONAL,
       threadTypes.LOCAL,
       threadTypes.COMMUNITY_ROOT,
       threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT,
     ]),
     ...threadRequestValidationShape,
   }),
 ]);
 
 export const newThreadResponseValidator: TInterface<NewThreadResponse> =
   tShape<NewThreadResponse>({
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
     newMessageInfos: t.list(rawMessageInfoValidator),
     userInfos: userInfosValidator,
     newThreadID: tID,
   });
 
 async function threadCreationResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<NewThreadResponse> {
   const request = await validateInput(
     viewer,
     newThreadRequestInputValidator,
     input,
   );
 
   const result = await createThread(viewer, request, {
     silentlyFailMembers: request.type === threadTypes.SIDEBAR,
   });
   return validateOutput(
     viewer.platformDetails,
     newThreadResponseValidator,
     result,
   );
 }
 
 const joinThreadRequestInputValidator = tShape<ServerThreadJoinRequest>({
   threadID: tID,
   calendarQuery: t.maybe(entryQueryInputValidator),
   inviteLinkSecret: t.maybe(t.String),
 });
 
 export const threadJoinResultValidator: TInterface<ThreadJoinResult> =
   tShape<ThreadJoinResult>({
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: userInfosValidator,
   });
 
 async function threadJoinResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ThreadJoinResult> {
   const request = await validateInput(
     viewer,
     joinThreadRequestInputValidator,
     input,
   );
 
   if (request.calendarQuery) {
     await verifyCalendarQueryThreadIDs(request.calendarQuery);
   }
 
   const result = await joinThread(viewer, request);
   return validateOutput(
     viewer.platformDetails,
     threadJoinResultValidator,
     result,
   );
 }
 
 const threadFetchMediaRequestInputValidator = tShape<ThreadFetchMediaRequest>({
   threadID: tID,
   limit: t.Number,
   offset: t.Number,
 });
 
 export const threadFetchMediaResultValidator: TInterface<ThreadFetchMediaResult> =
   tShape<ThreadFetchMediaResult>({ media: t.list(mediaValidator) });
 
 async function threadFetchMediaResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ThreadFetchMediaResult> {
   const request = await validateInput(
     viewer,
     threadFetchMediaRequestInputValidator,
     input,
   );
   const result = await fetchMediaForThread(viewer, request);
   return validateOutput(
     viewer.platformDetails,
     threadFetchMediaResultValidator,
     result,
   );
 }
 
 const toggleMessagePinRequestInputValidator = tShape<ToggleMessagePinRequest>({
   messageID: tID,
   action: t.enums.of(['pin', 'unpin']),
 });
 
 export const toggleMessagePinResultValidator: TInterface<ToggleMessagePinResult> =
   tShape<ToggleMessagePinResult>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     threadID: tID,
   });
 
 async function toggleMessagePinResponder(
   viewer: Viewer,
   input: mixed,
 ): Promise<ToggleMessagePinResult> {
   const request = await validateInput(
     viewer,
     toggleMessagePinRequestInputValidator,
     input,
   );
   const result = await toggleMessagePinForThread(viewer, request);
   return validateOutput(
     viewer.platformDetails,
     toggleMessagePinResultValidator,
     result,
   );
 }
 
 const roleModificationRequestInputValidator = tShape<RoleModificationRequest>({
   community: tID,
   name: t.String,
   permissions: t.list(userSurfacedPermissionValidator),
   action: t.enums.of(['create_role', 'edit_role']),
 });
 
+export const roleModificationResultValidator: TInterface<RoleModificationResult> =
+  tShape<RoleModificationResult>({
+    threadInfo: t.maybe(rawThreadInfoValidator),
+    updatesResult: tShape({
+      newUpdates: t.list(serverUpdateInfoValidator),
+    }),
+  });
+
 async function roleModificationResponder(
   viewer: Viewer,
   input: mixed,
-): Promise<void> {
+): Promise<RoleModificationResult> {
   const request = await validateInput(
     viewer,
     roleModificationRequestInputValidator,
     input,
   );
-  await modifyRole(viewer, request);
+  const response = await modifyRole(viewer, request);
+  return validateOutput(
+    viewer.platformDetails,
+    roleModificationResultValidator,
+    response,
+  );
 }
 
 export {
   threadDeletionResponder,
   roleUpdateResponder,
   memberRemovalResponder,
   threadLeaveResponder,
   threadUpdateResponder,
   threadCreationResponder,
   threadJoinResponder,
   threadFetchMediaResponder,
   newThreadRequestInputValidator,
   toggleMessagePinResponder,
   roleModificationResponder,
 };
diff --git a/lib/actions/thread-actions.js b/lib/actions/thread-actions.js
index 24ef058cd..c4c41061c 100644
--- a/lib/actions/thread-actions.js
+++ b/lib/actions/thread-actions.js
@@ -1,224 +1,235 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type {
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   UpdateThreadRequest,
   ClientNewThreadRequest,
   NewThreadResult,
   ClientThreadJoinRequest,
   ThreadJoinPayload,
   ThreadFetchMediaRequest,
   ThreadFetchMediaResult,
   ToggleMessagePinRequest,
   ToggleMessagePinResult,
   RoleModificationRequest,
+  RoleModificationPayload,
 } from '../types/thread-types.js';
 import type { CallServerEndpoint } from '../utils/call-server-endpoint.js';
 import { values } from '../utils/objects.js';
 
 const deleteThreadActionTypes = Object.freeze({
   started: 'DELETE_THREAD_STARTED',
   success: 'DELETE_THREAD_SUCCESS',
   failed: 'DELETE_THREAD_FAILED',
 });
 const deleteThread =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     threadID: string,
     currentAccountPassword: ?string,
   ) => Promise<LeaveThreadPayload>) =>
   async (threadID, currentAccountPassword) => {
     const response = await callServerEndpoint('delete_thread', {
       threadID,
       accountPassword: currentAccountPassword,
     });
     return {
       updatesResult: response.updatesResult,
     };
   };
 
 const changeThreadSettingsActionTypes = Object.freeze({
   started: 'CHANGE_THREAD_SETTINGS_STARTED',
   success: 'CHANGE_THREAD_SETTINGS_SUCCESS',
   failed: 'CHANGE_THREAD_SETTINGS_FAILED',
 });
 const changeThreadSettings =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((request: UpdateThreadRequest) => Promise<ChangeThreadSettingsPayload>) =>
   async request => {
     invariant(
       Object.keys(request.changes).length > 0,
       'No changes provided to changeThreadSettings!',
     );
     const response = await callServerEndpoint('update_thread', request);
     return {
       threadID: request.threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
 const removeUsersFromThreadActionTypes = Object.freeze({
   started: 'REMOVE_USERS_FROM_THREAD_STARTED',
   success: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
   failed: 'REMOVE_USERS_FROM_THREAD_FAILED',
 });
 const removeUsersFromThread =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     threadID: string,
     memberIDs: $ReadOnlyArray<string>,
   ) => Promise<ChangeThreadSettingsPayload>) =>
   async (threadID, memberIDs) => {
     const response = await callServerEndpoint('remove_members', {
       threadID,
       memberIDs,
     });
     return {
       threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
 const changeThreadMemberRolesActionTypes = Object.freeze({
   started: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
   success: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
   failed: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
 });
 const changeThreadMemberRoles =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((
     threadID: string,
     memberIDs: $ReadOnlyArray<string>,
     newRole: string,
   ) => Promise<ChangeThreadSettingsPayload>) =>
   async (threadID, memberIDs, newRole) => {
     const response = await callServerEndpoint('update_role', {
       threadID,
       memberIDs,
       role: newRole,
     });
     return {
       threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
 const newThreadActionTypes = Object.freeze({
   started: 'NEW_THREAD_STARTED',
   success: 'NEW_THREAD_SUCCESS',
   failed: 'NEW_THREAD_FAILED',
 });
 const newThread =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((request: ClientNewThreadRequest) => Promise<NewThreadResult>) =>
   async request => {
     const response = await callServerEndpoint('create_thread', request);
     return {
       newThreadID: response.newThreadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
       userInfos: response.userInfos,
     };
   };
 
 const joinThreadActionTypes = Object.freeze({
   started: 'JOIN_THREAD_STARTED',
   success: 'JOIN_THREAD_SUCCESS',
   failed: 'JOIN_THREAD_FAILED',
 });
 const joinThread =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((request: ClientThreadJoinRequest) => Promise<ThreadJoinPayload>) =>
   async request => {
     const response = await callServerEndpoint('join_thread', request);
     const userInfos = values(response.userInfos);
     return {
       updatesResult: response.updatesResult,
       rawMessageInfos: response.rawMessageInfos,
       truncationStatuses: response.truncationStatuses,
       userInfos,
     };
   };
 
 const leaveThreadActionTypes = Object.freeze({
   started: 'LEAVE_THREAD_STARTED',
   success: 'LEAVE_THREAD_SUCCESS',
   failed: 'LEAVE_THREAD_FAILED',
 });
 const leaveThread =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((threadID: string) => Promise<LeaveThreadPayload>) =>
   async threadID => {
     const response = await callServerEndpoint('leave_thread', { threadID });
     return {
       updatesResult: response.updatesResult,
     };
   };
 
 const fetchThreadMedia =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((request: ThreadFetchMediaRequest) => Promise<ThreadFetchMediaResult>) =>
   async request => {
     const response = await callServerEndpoint('fetch_thread_media', request);
     return response;
   };
 
 const toggleMessagePinActionTypes = Object.freeze({
   started: 'TOGGLE_MESSAGE_PIN_STARTED',
   success: 'TOGGLE_MESSAGE_PIN_SUCCESS',
   failed: 'TOGGLE_MESSAGE_PIN_FAILED',
 });
 const toggleMessagePin =
   (
     callServerEndpoint: CallServerEndpoint,
   ): ((request: ToggleMessagePinRequest) => Promise<ToggleMessagePinResult>) =>
   async request => {
     const response = await callServerEndpoint('toggle_message_pin', request);
     return {
       newMessageInfos: response.newMessageInfos,
       threadID: response.threadID,
     };
   };
 
+const modifyCommunityRoleActionTypes = Object.freeze({
+  started: 'MODIFY_COMMUNITY_ROLE_STARTED',
+  success: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
+  failed: 'MODIFY_COMMUNITY_ROLE_FAILED',
+});
 const modifyCommunityRole =
   (
     callServerEndpoint: CallServerEndpoint,
-  ): ((request: RoleModificationRequest) => Promise<void>) =>
+  ): ((request: RoleModificationRequest) => Promise<RoleModificationPayload>) =>
   async request => {
-    await callServerEndpoint('modify_community_role', request);
+    const response = await callServerEndpoint('modify_community_role', request);
+    return {
+      threadInfo: response.threadInfo,
+      updatesResult: response.updatesResult,
+    };
   };
 
 export {
   deleteThreadActionTypes,
   deleteThread,
   changeThreadSettingsActionTypes,
   changeThreadSettings,
   removeUsersFromThreadActionTypes,
   removeUsersFromThread,
   changeThreadMemberRolesActionTypes,
   changeThreadMemberRoles,
   newThreadActionTypes,
   newThread,
   joinThreadActionTypes,
   joinThread,
   leaveThreadActionTypes,
   leaveThread,
   fetchThreadMedia,
   toggleMessagePinActionTypes,
   toggleMessagePin,
+  modifyCommunityRoleActionTypes,
   modifyCommunityRole,
 };
diff --git a/lib/reducers/thread-reducer.js b/lib/reducers/thread-reducer.js
index a2eec5d98..a8371ed15 100644
--- a/lib/reducers/thread-reducer.js
+++ b/lib/reducers/thread-reducer.js
@@ -1,493 +1,495 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual.js';
 
 import {
   setThreadUnreadStatusActionTypes,
   updateActivityActionTypes,
 } from '../actions/activity-actions.js';
 import { setClientDBStoreActionType } from '../actions/client-db-store-actions.js';
 import { saveMessagesActionType } from '../actions/message-actions.js';
 import { siweAuthActionTypes } from '../actions/siwe-actions.js';
 import {
   changeThreadSettingsActionTypes,
   deleteThreadActionTypes,
   newThreadActionTypes,
   removeUsersFromThreadActionTypes,
   changeThreadMemberRolesActionTypes,
   joinThreadActionTypes,
   leaveThreadActionTypes,
+  modifyCommunityRoleActionTypes,
 } from '../actions/thread-actions.js';
 import {
   logOutActionTypes,
   deleteAccountActionTypes,
   logInActionTypes,
   registerActionTypes,
   updateSubscriptionActionTypes,
 } from '../actions/user-actions.js';
 import {
   type ThreadStoreOperation,
   threadStoreOpsHandlers,
 } from '../ops/thread-store-ops.js';
 import type { BaseAction } from '../types/redux-types.js';
 import {
   type ClientThreadInconsistencyReportCreationRequest,
   reportTypes,
 } from '../types/report-types.js';
 import {
   serverRequestTypes,
   processServerRequestsActionType,
 } from '../types/request-types.js';
 import {
   fullStateSyncActionType,
   incrementalStateSyncActionType,
 } from '../types/socket-types.js';
 import type { RawThreadInfo, ThreadStore } from '../types/thread-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import {
   type ClientUpdateInfo,
   processUpdatesActionType,
 } from '../types/update-types.js';
 import { actionLogger } from '../utils/action-logger.js';
 import { setNewSessionActionType } from '../utils/action-utils.js';
 import { getConfig } from '../utils/config.js';
 import { generateReportID } from '../utils/report-utils.js';
 import { sanitizeActionSecrets } from '../utils/sanitization.js';
 
 const { processStoreOperations: processThreadStoreOperations } =
   threadStoreOpsHandlers;
 
 function generateOpsForThreadUpdates(
   threadInfos: { +[id: string]: RawThreadInfo },
   payload: {
     +updatesResult: { +newUpdates: $ReadOnlyArray<ClientUpdateInfo>, ... },
     ...
   },
 ): $ReadOnlyArray<ThreadStoreOperation> {
   const threadOperations: ThreadStoreOperation[] = [];
   for (const update of payload.updatesResult.newUpdates) {
     if (
       (update.type === updateTypes.UPDATE_THREAD ||
         update.type === updateTypes.JOIN_THREAD) &&
       !_isEqual(threadInfos[update.threadInfo.id])(update.threadInfo)
     ) {
       threadOperations.push({
         type: 'replace',
         payload: {
           id: update.threadInfo.id,
           threadInfo: update.threadInfo,
         },
       });
     } else if (
       update.type === updateTypes.UPDATE_THREAD_READ_STATUS &&
       threadInfos[update.threadID] &&
       threadInfos[update.threadID].currentUser.unread !== update.unread
     ) {
       const updatedThread = {
         ...threadInfos[update.threadID],
         currentUser: {
           ...threadInfos[update.threadID].currentUser,
           unread: update.unread,
         },
       };
       threadOperations.push({
         type: 'replace',
         payload: {
           id: update.threadID,
           threadInfo: updatedThread,
         },
       });
     } else if (
       update.type === updateTypes.DELETE_THREAD &&
       threadInfos[update.threadID]
     ) {
       threadOperations.push({
         type: 'remove',
         payload: {
           ids: [update.threadID],
         },
       });
     } else if (update.type === updateTypes.DELETE_ACCOUNT) {
       for (const threadID in threadInfos) {
         const threadInfo = threadInfos[threadID];
         const newMembers = threadInfo.members.filter(
           member => member.id !== update.deletedUserID,
         );
         if (newMembers.length < threadInfo.members.length) {
           const updatedThread = {
             ...threadInfo,
             members: newMembers,
           };
           threadOperations.push({
             type: 'replace',
             payload: {
               id: threadID,
               threadInfo: updatedThread,
             },
           });
         }
       }
     }
   }
   return threadOperations;
 }
 
 function findInconsistencies(
   action: BaseAction,
   beforeStateCheck: { +[id: string]: RawThreadInfo },
   afterStateCheck: { +[id: string]: RawThreadInfo },
 ): ClientThreadInconsistencyReportCreationRequest[] {
   if (_isEqual(beforeStateCheck)(afterStateCheck)) {
     return [];
   }
   return [
     {
       type: reportTypes.THREAD_INCONSISTENCY,
       platformDetails: getConfig().platformDetails,
       beforeAction: beforeStateCheck,
       action: sanitizeActionSecrets(action),
       pushResult: afterStateCheck,
       lastActions: actionLogger.interestingActionSummaries,
       time: Date.now(),
       id: generateReportID(),
     },
   ];
 }
 
 function reduceThreadInfos(
   state: ThreadStore,
   action: BaseAction,
 ): {
   threadStore: ThreadStore,
   newThreadInconsistencies: $ReadOnlyArray<ClientThreadInconsistencyReportCreationRequest>,
   threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
 } {
   if (
     action.type === logInActionTypes.success ||
     action.type === siweAuthActionTypes.success ||
     action.type === registerActionTypes.success ||
     action.type === fullStateSyncActionType
   ) {
     const newThreadInfos = action.payload.threadInfos;
     const threadStoreOperations = [
       {
         type: 'remove_all',
       },
       ...Object.keys(newThreadInfos).map((id: string) => ({
         type: 'replace',
         payload: { id, threadInfo: newThreadInfos[id] },
       })),
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === logOutActionTypes.success ||
     action.type === deleteAccountActionTypes.success ||
     (action.type === setNewSessionActionType &&
       action.payload.sessionChange.cookieInvalidated)
   ) {
     if (Object.keys(state.threadInfos).length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = [
       {
         type: 'remove_all',
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (
     action.type === joinThreadActionTypes.success ||
     action.type === leaveThreadActionTypes.success ||
     action.type === deleteThreadActionTypes.success ||
     action.type === changeThreadSettingsActionTypes.success ||
     action.type === removeUsersFromThreadActionTypes.success ||
     action.type === changeThreadMemberRolesActionTypes.success ||
     action.type === incrementalStateSyncActionType ||
     action.type === processUpdatesActionType ||
-    action.type === newThreadActionTypes.success
+    action.type === newThreadActionTypes.success ||
+    action.type === modifyCommunityRoleActionTypes.success
   ) {
     const { newUpdates } = action.payload.updatesResult;
     if (newUpdates.length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = generateOpsForThreadUpdates(
       state.threadInfos,
       action.payload,
     );
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === updateSubscriptionActionTypes.success) {
     const { threadID, subscription } = action.payload;
     const newThreadInfo = {
       ...state.threadInfos[threadID],
       currentUser: {
         ...state.threadInfos[threadID].currentUser,
         subscription,
       },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: newThreadInfo,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === saveMessagesActionType) {
     const threadIDToMostRecentTime = new Map();
     for (const messageInfo of action.payload.rawMessageInfos) {
       const current = threadIDToMostRecentTime.get(messageInfo.threadID);
       if (!current || current < messageInfo.time) {
         threadIDToMostRecentTime.set(messageInfo.threadID, messageInfo.time);
       }
     }
     const changedThreadInfos = {};
     for (const [threadID, mostRecentTime] of threadIDToMostRecentTime) {
       const threadInfo = state.threadInfos[threadID];
       if (
         !threadInfo ||
         threadInfo.currentUser.unread ||
         action.payload.updatesCurrentAsOf > mostRecentTime
       ) {
         continue;
       }
       changedThreadInfos[threadID] = {
         ...state.threadInfos[threadID],
         currentUser: {
           ...state.threadInfos[threadID].currentUser,
           unread: true,
         },
       };
     }
     if (Object.keys(changedThreadInfos).length !== 0) {
       const threadStoreOperations = Object.keys(changedThreadInfos).map(id => ({
         type: 'replace',
         payload: {
           id,
           threadInfo: changedThreadInfos[id],
         },
       }));
       const updatedThreadStore = processThreadStoreOperations(
         state,
         threadStoreOperations,
       );
       return {
         threadStore: updatedThreadStore,
         newThreadInconsistencies: [],
         threadStoreOperations,
       };
     }
   } else if (action.type === processServerRequestsActionType) {
     const checkStateRequest = action.payload.serverRequests.find(
       candidate => candidate.type === serverRequestTypes.CHECK_STATE,
     );
     if (!checkStateRequest || !checkStateRequest.stateChanges) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const { rawThreadInfos, deleteThreadIDs } = checkStateRequest.stateChanges;
     if (!rawThreadInfos && !deleteThreadIDs) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const threadStoreOperations: ThreadStoreOperation[] = [];
     if (rawThreadInfos) {
       for (const rawThreadInfo of rawThreadInfos) {
         threadStoreOperations.push({
           type: 'replace',
           payload: {
             id: rawThreadInfo.id,
             threadInfo: rawThreadInfo,
           },
         });
       }
     }
     if (deleteThreadIDs) {
       threadStoreOperations.push({
         type: 'remove',
         payload: {
           ids: deleteThreadIDs,
         },
       });
     }
 
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
 
     const newThreadInconsistencies = findInconsistencies(
       action,
       state.threadInfos,
       updatedThreadStore.threadInfos,
     );
 
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies,
       threadStoreOperations,
     };
   } else if (action.type === updateActivityActionTypes.success) {
     const updatedThreadInfos = {};
     for (const setToUnread of action.payload.result.unfocusedToUnread) {
       const threadInfo = state.threadInfos[setToUnread];
       if (threadInfo && !threadInfo.currentUser.unread) {
         updatedThreadInfos[setToUnread] = {
           ...threadInfo,
           currentUser: {
             ...threadInfo.currentUser,
             unread: true,
           },
         };
       }
     }
     if (Object.keys(updatedThreadInfos).length === 0) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
     const threadStoreOperations = Object.keys(updatedThreadInfos).map(id => ({
       type: 'replace',
       payload: {
         id,
         threadInfo: updatedThreadInfos[id],
       },
     }));
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setThreadUnreadStatusActionTypes.started) {
     const { threadID, unread } = action.payload;
     const updatedThreadInfo = {
       ...state.threadInfos[threadID],
       currentUser: {
         ...state.threadInfos[threadID].currentUser,
         unread,
       },
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: updatedThreadInfo,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setThreadUnreadStatusActionTypes.success) {
     const { threadID, resetToUnread } = action.payload;
     const currentUser = state.threadInfos[threadID].currentUser;
 
     if (!resetToUnread || currentUser.unread) {
       return {
         threadStore: state,
         newThreadInconsistencies: [],
         threadStoreOperations: [],
       };
     }
 
     const updatedUser = {
       ...currentUser,
       unread: true,
     };
     const updatedThread = {
       ...state.threadInfos[threadID],
       currentUser: updatedUser,
     };
     const threadStoreOperations = [
       {
         type: 'replace',
         payload: {
           id: threadID,
           threadInfo: updatedThread,
         },
       },
     ];
     const updatedThreadStore = processThreadStoreOperations(
       state,
       threadStoreOperations,
     );
     return {
       threadStore: updatedThreadStore,
       newThreadInconsistencies: [],
       threadStoreOperations,
     };
   } else if (action.type === setClientDBStoreActionType) {
     return {
       threadStore: action.payload.threadStore ?? state,
       newThreadInconsistencies: [],
       threadStoreOperations: [],
     };
   }
   return {
     threadStore: state,
     newThreadInconsistencies: [],
     threadStoreOperations: [],
   };
 }
 
 export { reduceThreadInfos };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index 1ce0b2a3b..f1f38f258 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1189 +1,1206 @@
 // @flow
 
 import type {
   LogOutResult,
   LogInStartingPayload,
   LogInResult,
   RegisterResult,
   DefaultNotificationPayload,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type { CryptoStore } from './crypto-types.js';
 import type {
   VersionResponse,
   LastCommunicatedPlatformDetails,
 } from './device-types.js';
 import type { ClientDBDraftInfo, DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { KeyserverStore } from './keyserver-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLink,
   InviteLinksStore,
   InviteLinkVerificationResponse,
   DisableInviteLinkPayload,
 } from './link-types.js';
 import type { LoadingStatus, LoadingInfo } from './loading-types.js';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
 import type { MessageReportCreationResult } from './message-report-types.js';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
   EditMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   ClientDBMessageInfo,
   SimpleMessagesPayload,
   ClientDBThreadMessageInfo,
   FetchPinnedMessagesResult,
   SearchMessagesResponse,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo } from './nav-types.js';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types.js';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
   ClientReportCreationRequest,
 } from './report-types.js';
 import type {
   ProcessServerRequestsPayload,
   GetOlmSessionInitializationDataResponse,
 } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionInfo,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateDisconnectedBarPayload,
 } from './socket-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
+  RoleModificationPayload,
 } from './thread-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type { CurrentUserInfo, UserStore } from './user-types.js';
 import type { Shape } from '../types/core.js';
 import type { NotifPermissionAlertInfo } from '../utils/push-alerts.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo> = {
   navInfo: NavInfo,
   currentUserInfo: ?CurrentUserInfo,
   draftStore: DraftStore,
   entryStore: EntryStore,
   threadStore: ThreadStore,
   userStore: UserStore,
   messageStore: MessageStore,
   updatesCurrentAsOf: number, // millisecond timestamp
   loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   calendarFilters: $ReadOnlyArray<CalendarFilter>,
   urlPrefix: string,
   notifPermissionAlertInfo: NotifPermissionAlertInfo,
   connection: ConnectionInfo,
   watchedThreadIDs: $ReadOnlyArray<string>,
   lifecycleState: LifecycleState,
   enabledApps: EnabledApps,
   reportStore: ReportStore,
   nextLocalID: number,
   dataLoaded: boolean,
   userPolicies: UserPolicies,
   deviceToken: ?string,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +lastCommunicatedPlatformDetails: LastCommunicatedPlatformDetails,
   +keyserverStore: KeyserverStore,
   ...
 };
 
 // Web JS runtime doesn't have access to the cookie for security reasons.
 // Native JS doesn't have a sessionID because the cookieID is used instead.
 export type NativeAppState = BaseAppState<*> & {
   sessionID?: void,
   ...
 };
 export type WebAppState = BaseAppState<*> & {
   sessionID: ?string,
   cryptoStore: CryptoStore,
   pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type BaseAction =
   | {
       +type: '@@redux/INIT',
       +payload?: void,
     }
   | {
       +type: 'FETCH_ENTRIES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_ENTRIES_SUCCESS',
       +payload: FetchEntryInfosResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_OUT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ACCOUNT_SUCCESS',
       +payload: LogOutResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_LOCAL_ENTRY',
       +payload: RawEntryInfo,
     }
   | {
       +type: 'CREATE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_ENTRY_SUCCESS',
       +payload: CreateEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SAVE_ENTRY_SUCCESS',
       +payload: SaveEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CONCURRENT_MODIFICATION_RESET',
       +payload: {
         +id: string,
         +dbText: string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: {
         +localID: ?string,
         +serverID: ?string,
       },
     }
   | {
       +type: 'DELETE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_ENTRY_SUCCESS',
       +payload: ?DeleteEntryResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'LOG_IN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LOG_IN_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_STARTED',
       +loadingInfo: LoadingInfo,
       +payload: LogInStartingPayload,
     }
   | {
       +type: 'REGISTER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REGISTER_SUCCESS',
       +payload: RegisterResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_USER_PASSWORD_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DELETE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'NEW_THREAD_SUCCESS',
       +payload: NewThreadResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
       +payload: ChangeThreadSettingsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
       +payload: {
         +entryID: string,
         +text: string,
         +deleted: boolean,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RESTORE_ENTRY_SUCCESS',
       +payload: RestoreEntryPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'JOIN_THREAD_SUCCESS',
       +payload: ThreadJoinPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'LEAVE_THREAD_SUCCESS',
       +payload: LeaveThreadPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_NEW_SESSION',
       +payload: SetSessionPayload,
     }
   | {
       +type: 'persist/REHYDRATE',
       +payload: ?BaseAppState<*>,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
       +payload: FetchMessageInfosPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
       +payload: SimpleMessagesPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawTextMessageInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_TEXT_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawMultimediaMessageInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
       },
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload: RawReactionMessageInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_FAILED',
       +error: true,
       +payload: Error & {
         +localID: string,
         +threadID: string,
         +targetMessageID: string,
         +reaction: string,
         +action: string,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REACTION_MESSAGE_SUCCESS',
       +payload: SendMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_USERS_SUCCESS',
       +payload: UserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'EXACT_SEARCH_USER_SUCCESS',
       +payload: ExactUserSearchResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_DRAFT',
       +payload: {
         +key: string,
         +text: string,
       },
     }
   | {
       +type: 'MOVE_DRAFT',
       +payload: {
         +oldKey: string,
         +newKey: string,
       },
     }
   | {
       +type: 'SET_CLIENT_DB_STORE',
       +payload: {
         +currentUserID: ?string,
         +drafts: $ReadOnlyArray<ClientDBDraftInfo>,
         +messages: ?$ReadOnlyArray<ClientDBMessageInfo>,
         +threadStore: ?ThreadStore,
         +messageStoreThreads: ?$ReadOnlyArray<ClientDBThreadMessageInfo>,
         +reports: ?$ReadOnlyArray<ClientReportCreationRequest>,
       },
     }
   | {
       +type: 'UPDATE_ACTIVITY_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_ACTIVITY_SUCCESS',
       +payload: ActivityUpdateSuccessPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DEVICE_TOKEN_SUCCESS',
       +payload: ?string,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORT_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_REPORTS_SUCCESS',
       +payload?: ClearDeliveredReportsPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'QUEUE_REPORTS',
       +payload: QueueReportsPayload,
     }
   | {
       +type: 'SET_URL_PREFIX',
       +payload: string,
     }
   | {
       +type: 'SAVE_MESSAGES',
       +payload: SaveMessagesPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_THREAD_FILTER',
       +payload: CalendarThreadFilter,
     }
   | {
       +type: 'CLEAR_CALENDAR_THREAD_FILTER',
       +payload?: void,
     }
   | {
       +type: 'SET_CALENDAR_DELETED_FILTER',
       +payload: SetCalendarDeletedFilterPayload,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_SUBSCRIPTION_SUCCESS',
       +payload: SubscriptionUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_STARTED',
       +loadingInfo: LoadingInfo,
       +payload?: CalendarQueryUpdateStartingPayload,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
       +payload: CalendarQueryUpdateResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FULL_STATE_SYNC',
       +payload: StateSyncFullActionPayload,
     }
   | {
       +type: 'INCREMENTAL_STATE_SYNC',
       +payload: StateSyncIncrementalActionPayload,
     }
   | {
       +type: 'PROCESS_SERVER_REQUESTS',
       +payload: ProcessServerRequestsPayload,
     }
   | {
       +type: 'UPDATE_CONNECTION_STATUS',
       +payload: UpdateConnectionStatusPayload,
     }
   | {
       +type: 'QUEUE_ACTIVITY_UPDATES',
       +payload: QueueActivityUpdatesPayload,
     }
   | {
       +type: 'UNSUPERVISED_BACKGROUND',
       +payload?: void,
     }
   | {
       +type: 'UPDATE_LIFECYCLE_STATE',
       +payload: LifecycleState,
     }
   | {
       +type: 'ENABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'DISABLE_APP',
       +payload: SupportedApps,
     }
   | {
       +type: 'UPDATE_REPORTS_ENABLED',
       +payload: Shape<EnabledReports>,
     }
   | {
       +type: 'PROCESS_UPDATES',
       +payload: ClientUpdatesResultWithUserInfos,
     }
   | {
       +type: 'PROCESS_MESSAGES',
       +payload: NewMessagesPayload,
     }
   | {
       +type: 'MESSAGE_STORE_PRUNE',
       +payload: MessageStorePrunePayload,
     }
   | {
       +type: 'SET_LATE_RESPONSE',
       +payload: SetLateResponsePayload,
     }
   | {
       +type: 'UPDATE_DISCONNECTED_BAR',
       +payload: UpdateDisconnectedBarPayload,
     }
   | {
       +type: 'REQUEST_ACCESS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'REQUEST_ACCESS_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
       +payload: UpdateMultimediaMessageMediaPayload,
     }
   | {
       +type: 'CREATE_LOCAL_MESSAGE',
       +payload: LocallyComposedMessageInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_RELATIONSHIPS_SUCCESS',
       +payload: RelationshipErrors,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_STARTED',
       +payload: {
         +threadID: string,
         +unread: boolean,
       },
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
       +payload: SetThreadUnreadStatusPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_USER_SETTINGS_SUCCESS',
       +payload: DefaultNotificationPayload,
     }
   | {
       +type: 'SET_USER_SETTINGS_FAILED',
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_SUCCESS',
       +payload: MessageReportCreationResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_MESSAGE_REPORT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FORCE_POLICY_ACKNOWLEDGMENT',
       +payload: ForcePolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
       +payload: PolicyAcknowledgmentPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'POLICY_ACKNOWLEDGMENT_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_STARTED',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_SUCCESS',
       +payload?: void,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_SIWE_NONCE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_STARTED',
       +payload: LogInStartingPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_SUCCESS',
       +payload: LogInResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SIWE_AUTH_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'RECORD_NOTIF_PERMISSION_ALERT',
       +payload: { +time: number },
     }
   | {
       +type: 'UPDATE_USER_AVATAR_STARTED',
       +payload: UpdateUserAvatarRequest,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_SUCCESS',
       +payload: UpdateUserAvatarResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_USER_AVATAR_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_SUCCESS',
       +payload: EditMessagePayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEND_EDIT_MESSAGE_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
       +payload: ToggleMessagePinResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'TOGGLE_MESSAGE_PIN_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_SUCCESS',
       +payload: FetchPinnedMessagesResult,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PINNED_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_SUCCESS',
       +payload: InviteLinkVerificationResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'VERIFY_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
       +payload: FetchInviteLinksResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'UPDATE_CHAT_COMMUNITY_FILTER',
       +payload: string,
     }
   | {
       +type: 'CLEAR_CHAT_COMMUNITY_FILTER',
       +payload: void,
     }
   | {
       +type: 'SEARCH_MESSAGES_STARTED',
       +payload: void,
       +loadingInfo?: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_SUCCESS',
       +payload: SearchMessagesResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SEARCH_MESSAGES_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
       +payload: InviteLink,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_SUCCESS',
       +payload: DisableInviteLinkPayload,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'DISABLE_INVITE_LINK_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
       +payload: GetOlmSessionInitializationDataResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'SET_DATA_LOADED',
       +payload: {
         +dataLoaded: boolean,
       },
     }
   | {
       +type: 'GET_VERSION_STARTED',
       +loadingInfo?: LoadingInfo,
       +payload?: void,
     }
   | {
       +type: 'GET_VERSION_SUCCESS',
       +payload: VersionResponse,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'GET_VERSION_FAILED',
       +error: true,
       +payload: Error,
       +loadingInfo: LoadingInfo,
     }
   | {
       +type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
       +payload: LastCommunicatedPlatformDetails,
     }
-  | { +type: 'RESET_USER_STATE', +payload?: void };
+  | { +type: 'RESET_USER_STATE', +payload?: void }
+  | {
+      +type: 'MODIFY_COMMUNITY_ROLE_STARTED',
+      +loadingInfo?: LoadingInfo,
+      +payload?: void,
+    }
+  | {
+      +type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
+      +payload: RoleModificationPayload,
+      +loadingInfo: LoadingInfo,
+    }
+  | {
+      +type: 'MODIFY_COMMUNITY_ROLE_FAILED',
+      +error: true,
+      +payload: Error,
+      +loadingInfo: LoadingInfo,
+    };
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type SuperAction = {
   type: string,
   payload?: ActionPayload,
   loadingInfo?: LoadingInfo,
   error?: boolean,
 };
 type ThunkedAction = (dispatch: Dispatch) => void;
 export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
 export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
   ((thunkedAction: ThunkedAction) => void) &
   ((action: SuperAction) => boolean);
 
 // This is lifted from redux-persist/lib/constants.js
 // I don't want to add redux-persist to the web/server bundles...
 // import { REHYDRATE } from 'redux-persist';
 export const rehydrateActionType = 'persist/REHYDRATE';
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index 54aae9160..3165bacb5 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,415 +1,429 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type AvatarDBContent,
   type ClientAvatar,
   clientAvatarValidator,
   type UpdateUserAvatarRequest,
 } from './avatar-types.js';
 import type { Shape } from './core.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 ThreadSubscription,
   threadSubscriptionValidator,
 } from './subscription-types.js';
 import {
   type ThreadPermissionsInfo,
   threadPermissionsInfoValidator,
   type ThreadRolePermissionsBlob,
   threadRolePermissionsBlobValidator,
   type UserSurfacedPermission,
 } from './thread-permission-types.js';
 import { type ThreadType, threadTypeValidator } from './thread-types-enum.js';
 import type { ClientUpdateInfo, ServerUpdateInfo } from './update-types.js';
 import type { UserInfo, UserInfos } from './user-types.js';
 import {
   type ThreadEntity,
   threadEntityValidator,
 } from '../utils/entity-text.js';
 import { tID, tShape } from '../utils/validation-utils.js';
 
 export type MemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +isSender: boolean,
 };
 const memberInfoValidator = tShape<MemberInfo>({
   id: t.String,
   role: t.maybe(tID),
   permissions: threadPermissionsInfoValidator,
   isSender: t.Boolean,
 });
 
 export type RelativeMemberInfo = {
   ...MemberInfo,
   +username: ?string,
   +isViewer: boolean,
 };
 const relativeMemberInfoValidator = tShape<RelativeMemberInfo>({
   ...memberInfoValidator.meta.props,
   username: t.maybe(t.String),
   isViewer: t.Boolean,
 });
 
 export type RoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
 };
 const roleInfoValidator = tShape<RoleInfo>({
   id: tID,
   name: t.String,
   permissions: threadRolePermissionsBlobValidator,
   isDefault: t.Boolean,
 });
 
 export type ThreadCurrentUserInfo = {
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
 };
 const threadCurrentUserInfoValidator = tShape<ThreadCurrentUserInfo>({
   role: t.maybe(tID),
   permissions: threadPermissionsInfoValidator,
   subscription: threadSubscriptionValidator,
   unread: t.maybe(t.Boolean),
 });
 
 export type RawThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +avatar?: ?ClientAvatar,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<MemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +currentUser: ThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 export const rawThreadInfoValidator: TInterface<RawThreadInfo> =
   tShape<RawThreadInfo>({
     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(memberInfoValidator),
     roles: t.dict(tID, roleInfoValidator),
     currentUser: threadCurrentUserInfoValidator,
     sourceMessageID: t.maybe(tID),
     repliesCount: t.Number,
     pinnedCount: t.maybe(t.Number),
   });
 
 export type ThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +uiName: string | ThreadEntity,
   +avatar?: ?ClientAvatar,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<RelativeMemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +currentUser: ThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 export const threadInfoValidator: TInterface<ThreadInfo> = tShape<ThreadInfo>({
   id: tID,
   type: threadTypeValidator,
   name: t.maybe(t.String),
   uiName: t.union([t.String, threadEntityValidator]),
   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(relativeMemberInfoValidator),
   roles: t.dict(tID, roleInfoValidator),
   currentUser: threadCurrentUserInfoValidator,
   sourceMessageID: t.maybe(tID),
   repliesCount: t.Number,
   pinnedCount: t.maybe(t.Number),
 });
 
 export type ResolvedThreadInfo = {
   +id: string,
   +type: ThreadType,
   +name: ?string,
   +uiName: string,
   +avatar?: ?ClientAvatar,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<RelativeMemberInfo>,
   +roles: { +[id: string]: RoleInfo },
   +currentUser: ThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 
 export type ServerMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
   +isSender: boolean,
 };
 
 export type ServerThreadInfo = {
   +id: string,
   +type: ThreadType,
   +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]: RoleInfo },
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount: number,
 };
 
 export type ThreadStore = {
   +threadInfos: { +[id: string]: RawThreadInfo },
 };
 export const threadStoreValidator: TInterface<ThreadStore> =
   tShape<ThreadStore>({
     threadInfos: t.dict(tID, rawThreadInfoValidator),
   });
 
 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,
 };
 
 export type ThreadDeletionRequest = {
   +threadID: string,
   +accountPassword: ?string,
 };
 
 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 = Shape<{
   +type: ThreadType,
   +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 NewThreadRequest =
   | {
       +type: 3 | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 12,
       ...BaseNewThreadRequest,
     }
   | {
       +type: 5,
       +sourceMessageID: string,
       ...BaseNewThreadRequest,
     };
 
 export type ClientNewThreadRequest = {
   ...NewThreadRequest,
   +calendarQuery: CalendarQuery,
 };
 export type ServerNewThreadRequest = {
   ...NewThreadRequest,
   +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,
 };
 export type ClientThreadJoinRequest = {
   +threadID: string,
   +calendarQuery: CalendarQuery,
   +inviteLinkSecret?: string,
 };
 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>,
 };
 
 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,
 };
 
 export type RoleModificationRequest = {
   +community: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'create_role' | 'edit_role',
 };
 
+export type RoleModificationResult = {
+  +threadInfo: RawThreadInfo,
+  +updatesResult: {
+    +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
+  },
+};
+
+export type RoleModificationPayload = {
+  +threadInfo: 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 = { +[id: string]: RawThreadInfo };
diff --git a/native/roles/create-roles-header-right-button.react.js b/native/roles/create-roles-header-right-button.react.js
index b47598286..b9f213e26 100644
--- a/native/roles/create-roles-header-right-button.react.js
+++ b/native/roles/create-roles-header-right-button.react.js
@@ -1,56 +1,67 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import * as React from 'react';
 import { TouchableOpacity, Text } from 'react-native';
 
-import { modifyCommunityRole } from 'lib/actions/thread-actions.js';
-import { useServerCall } from 'lib/utils/action-utils.js';
+import {
+  modifyCommunityRole,
+  modifyCommunityRoleActionTypes,
+} from 'lib/actions/thread-actions.js';
+import {
+  useServerCall,
+  useDispatchActionPromise,
+} from 'lib/utils/action-utils.js';
 
 import type { NavigationRoute } from '../navigation/route-names';
 import { useStyles } from '../themes/colors.js';
 
 type Props = {
   +route: NavigationRoute<'CreateRolesScreen'>,
 };
 
 function CreateRolesHeaderRightButton(props: Props): React.Node {
   const { threadInfo, action, roleName, rolePermissions } = props.route.params;
   const navigation = useNavigation();
   const styles = useStyles(unboundStyles);
 
   const callModifyCommunityRole = useServerCall(modifyCommunityRole);
+  const dispatchActionPromise = useDispatchActionPromise();
 
   const onPressCreate = React.useCallback(() => {
-    callModifyCommunityRole({
-      community: threadInfo.id,
-      action,
-      name: roleName,
-      permissions: [...rolePermissions],
-    });
+    dispatchActionPromise(
+      modifyCommunityRoleActionTypes,
+      callModifyCommunityRole({
+        community: threadInfo.id,
+        action,
+        name: roleName,
+        permissions: [...rolePermissions],
+      }),
+    );
 
     navigation.goBack();
   }, [
     callModifyCommunityRole,
+    dispatchActionPromise,
     threadInfo,
     action,
     roleName,
     rolePermissions,
     navigation,
   ]);
 
   return (
     <TouchableOpacity onPress={onPressCreate}>
       <Text style={styles.createButton}>Create</Text>
     </TouchableOpacity>
   );
 }
 
 const unboundStyles = {
   createButton: {
     color: 'purpleLink',
     marginRight: 10,
   },
 };
 
 export default CreateRolesHeaderRightButton;