diff --git a/lib/shared/messages/update-relationship-message-spec.js b/lib/shared/messages/update-relationship-message-spec.js
index eaf7dcff6..0ecdc902b 100644
--- a/lib/shared/messages/update-relationship-message-spec.js
+++ b/lib/shared/messages/update-relationship-message-spec.js
@@ -1,113 +1,117 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { messageTypes } from '../../types/message-types';
 import type {
   RawUpdateRelationshipMessageInfo,
   UpdateRelationshipMessageData,
   UpdateRelationshipMessageInfo,
 } from '../../types/message/update-relationship';
 import { stringForUser } from '../user-utils';
 import { hasMinCodeVersion } from '../version-utils';
 import type { MessageSpec } from './message-spec';
 import { assertSingleMessageInfo } from './utils';
 
 export const updateRelationshipMessageSpec: MessageSpec<
   UpdateRelationshipMessageData,
   RawUpdateRelationshipMessageInfo,
   UpdateRelationshipMessageInfo,
 > = Object.freeze({
   messageContent(data) {
     return JSON.stringify({
       operation: data.operation,
       targetID: data.targetID,
     });
   },
 
   rawMessageInfoFromRow(row) {
     const content = JSON.parse(row.content);
     return {
       type: messageTypes.UPDATE_RELATIONSHIP,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       targetID: content.targetID,
       operation: content.operation,
     };
   },
 
   createMessageInfo(rawMessageInfo, creator, params) {
     const target = params.createRelativeUserInfos([rawMessageInfo.targetID])[0];
     if (!target) {
       return null;
     }
     return {
       type: messageTypes.UPDATE_RELATIONSHIP,
       id: rawMessageInfo.id,
       threadID: rawMessageInfo.threadID,
       creator,
       target,
       time: rawMessageInfo.time,
       operation: rawMessageInfo.operation,
     };
   },
 
   rawMessageInfoFromMessageData(messageData, id) {
     return { ...messageData, id };
   },
 
   robotext(messageInfo, creator, params) {
     const target = params.robotextForUser(messageInfo.target);
     if (messageInfo.operation === 'request_sent') {
       return `${creator} sent ${target} a friend request`;
     } else if (messageInfo.operation === 'request_accepted') {
       const targetPossessive = messageInfo.target.isViewer
         ? 'your'
         : `${target}'s`;
       return `${creator} accepted ${targetPossessive} friend request`;
     }
     invariant(
       false,
       `Invalid operation ${messageInfo.operation} ` +
         `of message with type ${messageInfo.type}`,
     );
   },
 
   shimUnsupportedMessageInfo(rawMessageInfo, platformDetails) {
     if (hasMinCodeVersion(platformDetails, 71)) {
       return rawMessageInfo;
     }
     const { id } = rawMessageInfo;
     invariant(id !== null && id !== undefined, 'id should be set on server');
     return {
       type: messageTypes.UNSUPPORTED,
       id,
       threadID: rawMessageInfo.threadID,
       creatorID: rawMessageInfo.creatorID,
       time: rawMessageInfo.time,
       robotext: 'performed a relationship action',
       unsupportedMessageInfo: rawMessageInfo,
     };
   },
 
+  unshimMessageInfo(unwrapped) {
+    return unwrapped;
+  },
+
   notificationTexts(messageInfos, threadInfo) {
     const messageInfo = assertSingleMessageInfo(messageInfos);
     const prefix = stringForUser(messageInfo.creator);
     const title = threadInfo.uiName;
     const body =
       messageInfo.operation === 'request_sent'
         ? 'sent you a friend request'
         : 'accepted your friend request';
     const merged = `${prefix} ${body}`;
     return {
       merged,
       body,
       title,
       prefix,
     };
   },
 
   generatesNotifs: true,
 });
diff --git a/lib/shared/unshim-utils.js b/lib/shared/unshim-utils.js
index 3ed61da4f..080703cc7 100644
--- a/lib/shared/unshim-utils.js
+++ b/lib/shared/unshim-utils.js
@@ -1,52 +1,53 @@
 // @flow
 
 import _mapValues from 'lodash/fp/mapValues';
 
 import {
   type MessageStore,
   type RawMessageInfo,
   type MessageType,
   messageTypes,
 } from '../types/message-types';
 import { messageSpecs } from './messages/message-specs';
 
 function unshimFunc(
   messageInfo: RawMessageInfo,
   unshimTypes: Set<MessageType>,
 ): RawMessageInfo {
   if (messageInfo.type !== messageTypes.UNSUPPORTED) {
     return messageInfo;
   }
   if (!unshimTypes.has(messageInfo.unsupportedMessageInfo.type)) {
     return messageInfo;
   }
   const unwrapped = messageInfo.unsupportedMessageInfo;
   const { unshimMessageInfo } = messageSpecs[unwrapped.type];
   const unshimmed = unshimMessageInfo?.(unwrapped, messageInfo);
   return unshimmed ?? unwrapped;
 }
 
 function unshimMessageStore(
   messageStore: MessageStore,
   unshimTypes: $ReadOnlyArray<MessageType>,
 ): MessageStore {
   const set = new Set(unshimTypes);
   const messages = _mapValues((messageInfo: RawMessageInfo) =>
     unshimFunc(messageInfo, set),
   )(messageStore.messages);
   return { ...messageStore, messages };
 }
 
 const localUnshimTypes = new Set([
   messageTypes.IMAGES,
   messageTypes.MULTIMEDIA,
+  messageTypes.UPDATE_RELATIONSHIP,
 ]);
 function unshimMessageInfos(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
 ): RawMessageInfo[] {
   return messageInfos.map((messageInfo: RawMessageInfo) =>
     unshimFunc(messageInfo, localUnshimTypes),
   );
 }
 
 export { unshimMessageStore, unshimMessageInfos };
diff --git a/native/redux/persist.js b/native/redux/persist.js
index 4b641d334..866224603 100644
--- a/native/redux/persist.js
+++ b/native/redux/persist.js
@@ -1,221 +1,227 @@
 // @flow
 
 import AsyncStorage from '@react-native-community/async-storage';
 import invariant from 'invariant';
 import { Platform } from 'react-native';
 import Orientation from 'react-native-orientation-locker';
 import { createMigrate } from 'redux-persist';
 
 import { highestLocalIDSelector } from 'lib/selectors/local-id-selectors';
 import { inconsistencyResponsesToReports } from 'lib/shared/report-utils';
 import { unshimMessageStore } from 'lib/shared/unshim-utils';
 import { defaultCalendarFilters } from 'lib/types/filter-types';
 import { messageTypes } from 'lib/types/message-types';
 import { defaultConnectionInfo } from 'lib/types/socket-types';
 
 import { defaultNotifPermissionAlertInfo } from '../push/alerts';
 import { defaultDeviceCameraInfo } from '../types/camera';
 import { defaultGlobalThemeInfo } from '../types/themes';
 import type { AppState } from './redux-setup';
 
 const migrations = {
   [1]: (state: AppState) => ({
     ...state,
     notifPermissionAlertInfo: defaultNotifPermissionAlertInfo,
   }),
   [2]: (state: AppState) => ({
     ...state,
     messageSentFromRoute: [],
   }),
   [3]: (state) => ({
     currentUserInfo: state.currentUserInfo,
     entryStore: state.entryStore,
     threadInfos: state.threadInfos,
     userInfos: state.userInfos,
     messageStore: {
       ...state.messageStore,
       currentAsOf: state.currentAsOf,
     },
     drafts: state.drafts,
     updatesCurrentAsOf: state.currentAsOf,
     cookie: state.cookie,
     deviceToken: state.deviceToken,
     urlPrefix: state.urlPrefix,
     customServer: state.customServer,
     threadIDsToNotifIDs: state.threadIDsToNotifIDs,
     notifPermissionAlertInfo: state.notifPermissionAlertInfo,
     messageSentFromRoute: state.messageSentFromRoute,
     _persist: state._persist,
   }),
   [4]: (state: AppState) => ({
     ...state,
     pingTimestamps: undefined,
     activeServerRequests: undefined,
   }),
   [5]: (state: AppState) => ({
     ...state,
     calendarFilters: defaultCalendarFilters,
   }),
   [6]: (state) => ({
     ...state,
     threadInfos: undefined,
     threadStore: {
       threadInfos: state.threadInfos,
       inconsistencyResponses: [],
     },
   }),
   [7]: (state) => ({
     ...state,
     lastUserInteraction: undefined,
     sessionID: undefined,
     entryStore: {
       ...state.entryStore,
       inconsistencyResponses: [],
     },
   }),
   [8]: (state: AppState) => ({
     ...state,
     pingTimestamps: undefined,
     activeServerRequests: undefined,
     connection: defaultConnectionInfo(Platform.OS),
     watchedThreadIDs: [],
     foreground: true,
     entryStore: {
       ...state.entryStore,
       actualizedCalendarQuery: undefined,
     },
   }),
   [9]: (state: AppState) => ({
     ...state,
     connection: {
       ...state.connection,
       lateResponses: [],
     },
   }),
   [10]: (state: AppState) => ({
     ...state,
     nextLocalID: highestLocalIDSelector(state) + 1,
     connection: {
       ...state.connection,
       showDisconnectedBar: false,
     },
     messageStore: {
       ...state.messageStore,
       local: {},
     },
   }),
   [11]: (state: AppState) => ({
     ...state,
     messageStore: unshimMessageStore(state.messageStore, [messageTypes.IMAGES]),
   }),
   [12]: (state: AppState) => ({
     ...state,
     globalThemeInfo: defaultGlobalThemeInfo,
   }),
   [13]: (state: AppState) => ({
     ...state,
     deviceCameraInfo: defaultDeviceCameraInfo,
     deviceOrientation: Orientation.getInitialOrientation(),
   }),
   [14]: (state: AppState) => ({
     ...state,
     messageStore: unshimMessageStore(state.messageStore, [
       messageTypes.MULTIMEDIA,
     ]),
   }),
   [15]: (state) => ({
     ...state,
     threadStore: {
       ...state.threadStore,
       inconsistencyReports: inconsistencyResponsesToReports(
         state.threadStore.inconsistencyResponses,
       ),
       inconsistencyResponses: undefined,
     },
     entryStore: {
       ...state.entryStore,
       inconsistencyReports: inconsistencyResponsesToReports(
         state.entryStore.inconsistencyResponses,
       ),
       inconsistencyResponses: undefined,
     },
     queuedReports: [],
   }),
   [16]: (state) => {
     const result = {
       ...state,
       messageSentFromRoute: undefined,
       dataLoaded: !!state.currentUserInfo && !state.currentUserInfo.anonymous,
     };
     if (state.navInfo) {
       result.navInfo = {
         ...state.navInfo,
         navigationState: undefined,
       };
     }
     return result;
   },
   [17]: (state) => ({
     ...state,
     userInfos: undefined,
     userStore: {
       userInfos: state.userInfos,
       inconsistencyResponses: [],
     },
   }),
   [18]: (state) => ({
     ...state,
     userStore: {
       userInfos: state.userStore.userInfos,
       inconsistencyReports: [],
     },
   }),
   [19]: (state) => {
     const threadInfos = {};
     for (const threadID in state.threadStore.threadInfos) {
       const threadInfo = state.threadStore.threadInfos[threadID];
       const { visibilityRules, ...rest } = threadInfo;
       threadInfos[threadID] = rest;
     }
     return {
       ...state,
       threadStore: {
         ...state.threadStore,
         threadInfos,
       },
     };
   },
+  [20]: (state: AppState) => ({
+    ...state,
+    messageStore: unshimMessageStore(state.messageStore, [
+      messageTypes.UPDATE_RELATIONSHIP,
+    ]),
+  }),
 };
 
 const persistConfig = {
   key: 'root',
   storage: AsyncStorage,
   blacklist: [
     'loadingStatuses',
     'foreground',
     'dimensions',
     'connectivity',
     'deviceOrientation',
     'frozen',
   ],
   debug: __DEV__,
-  version: 18,
+  version: 20,
   migrate: createMigrate(migrations, { debug: __DEV__ }),
   timeout: __DEV__ ? 0 : undefined,
 };
 
 const codeVersion = 74;
 
 // This local exists to avoid a circular dependency where redux-setup needs to
 // import all the navigation and screen stuff, but some of those screens want to
 // access the persistor to purge its state.
 let storedPersistor = null;
 function setPersistor(persistor: *) {
   storedPersistor = persistor;
 }
 function getPersistor() {
   invariant(storedPersistor, 'should be set');
   return storedPersistor;
 }
 
 export { persistConfig, codeVersion, setPersistor, getPersistor };