diff --git a/keyserver/src/responders/relationship-responders.js b/keyserver/src/responders/relationship-responders.js
index da8bb9067..dc14dae3a 100644
--- a/keyserver/src/responders/relationship-responders.js
+++ b/keyserver/src/responders/relationship-responders.js
@@ -1,35 +1,35 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
-  type RelationshipRequest,
+  type TraditionalRelationshipRequest,
   type RelationshipErrors,
   relationshipActionsList,
 } from 'lib/types/relationship-types.js';
 import { tShape } from 'lib/utils/validation-utils.js';
 
 import type { Viewer } from '../session/viewer.js';
 import { updateRelationships } from '../updaters/relationship-updaters.js';
 
-export const updateRelationshipInputValidator: TInterface<RelationshipRequest> =
-  tShape<RelationshipRequest>({
+export const updateRelationshipInputValidator: TInterface<TraditionalRelationshipRequest> =
+  tShape<TraditionalRelationshipRequest>({
     action: t.enums.of(relationshipActionsList, 'relationship action'),
     userIDs: t.list(t.String),
   });
 
 export const relationshipErrorsValidator: TInterface<RelationshipErrors> =
   tShape<RelationshipErrors>({
     invalid_user: t.maybe(t.list(t.String)),
     already_friends: t.maybe(t.list(t.String)),
     user_blocked: t.maybe(t.list(t.String)),
   });
 
 async function updateRelationshipsResponder(
   viewer: Viewer,
-  request: RelationshipRequest,
+  request: TraditionalRelationshipRequest,
 ): Promise<RelationshipErrors> {
   return await updateRelationships(viewer, request);
 }
 
 export { updateRelationshipsResponder };
diff --git a/keyserver/src/updaters/relationship-updaters.js b/keyserver/src/updaters/relationship-updaters.js
index 292dbd42c..0b6fa4490 100644
--- a/keyserver/src/updaters/relationship-updaters.js
+++ b/keyserver/src/updaters/relationship-updaters.js
@@ -1,386 +1,386 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { sortUserIDs } from 'lib/shared/relationship-utils.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
-  type RelationshipRequest,
+  type TraditionalRelationshipRequest,
   type RelationshipErrors,
   type UndirectedRelationshipRow,
   relationshipActions,
   undirectedStatus,
   directedStatus,
 } from 'lib/types/relationship-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import type { NewThreadResponse } from 'lib/types/thread-types.js';
 import { updateTypes } from 'lib/types/update-types-enum.js';
 import { type UpdateData } from 'lib/types/update-types.js';
 import { cartesianProduct } from 'lib/utils/array.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { promiseAll } from 'lib/utils/promises.js';
 
 import createMessages from '../creators/message-creator.js';
 import { createThread } from '../creators/thread-creator.js';
 import { createUpdates } from '../creators/update-creator.js';
 import { dbQuery, SQL, mergeOrConditions } from '../database/database.js';
 import { fetchFriendRequestRelationshipOperations } from '../fetchers/relationship-fetchers.js';
 import { fetchUserInfos } from '../fetchers/user-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 
 async function updateRelationships(
   viewer: Viewer,
-  request: RelationshipRequest,
+  request: TraditionalRelationshipRequest,
 ): Promise<RelationshipErrors> {
   const { action } = request;
 
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const uniqueUserIDs = [...new Set(request.userIDs)];
   const users = await fetchUserInfos(uniqueUserIDs);
 
   let errors: RelationshipErrors = {};
   const userIDs: string[] = [];
   for (const userID of uniqueUserIDs) {
     if (userID === viewer.userID || !users[userID].username) {
       const acc = errors.invalid_user || [];
       errors.invalid_user = [...acc, userID];
     } else {
       userIDs.push(userID);
     }
   }
   if (!userIDs.length) {
     return Object.freeze({ ...errors });
   }
 
   const updateIDs = [];
   if (action === relationshipActions.FRIEND) {
     // We have to create personal threads before setting the relationship
     // status. By doing that we make sure that failed thread creation is
     // reported to the caller and can be repeated - there should be only
     // one PERSONAL thread per a pair of users and we can safely call it
     // repeatedly.
     const threadIDPerUser = await createPersonalThreads(viewer, request);
     const { userRelationshipOperations, errors: friendRequestErrors } =
       await fetchFriendRequestRelationshipOperations(viewer, userIDs);
     errors = { ...errors, ...friendRequestErrors };
 
     const undirectedInsertRows = [];
     const directedInsertRows = [];
     const directedDeleteIDs = [];
     const messageDatas = [];
     const now = Date.now();
     for (const userID in userRelationshipOperations) {
       const operations = userRelationshipOperations[userID];
       const ids = sortUserIDs(viewer.userID, userID);
 
       if (operations.length) {
         updateIDs.push(userID);
       }
 
       for (const operation of operations) {
         if (operation === 'delete_directed') {
           directedDeleteIDs.push(userID);
         } else if (operation === 'friend') {
           const [user1, user2] = ids;
           const status = undirectedStatus.FRIEND;
           undirectedInsertRows.push({ user1, user2, status });
           messageDatas.push({
             type: messageTypes.LEGACY_UPDATE_RELATIONSHIP,
             threadID: threadIDPerUser[userID],
             creatorID: viewer.userID,
             targetID: userID,
             time: now,
             operation: 'request_accepted',
           });
         } else if (operation === 'pending_friend') {
           const status = directedStatus.PENDING_FRIEND;
           directedInsertRows.push([viewer.userID, userID, status]);
           messageDatas.push({
             type: messageTypes.LEGACY_UPDATE_RELATIONSHIP,
             threadID: threadIDPerUser[userID],
             creatorID: viewer.userID,
             targetID: userID,
             time: now,
             operation: 'request_sent',
           });
         } else if (operation === 'know_of') {
           const [user1, user2] = ids;
           const status = undirectedStatus.KNOW_OF;
           undirectedInsertRows.push({ user1, user2, status });
         } else {
           invariant(false, `unexpected relationship operation ${operation}`);
         }
       }
     }
 
     const promises: Array<Promise<mixed>> = [
       updateUndirectedRelationships(undirectedInsertRows),
     ];
     if (directedInsertRows.length) {
       const directedInsertQuery = SQL`
         INSERT INTO relationships_directed (user1, user2, status)
         VALUES ${directedInsertRows}
         ON DUPLICATE KEY UPDATE status = VALUE(status)
       `;
       promises.push(dbQuery(directedInsertQuery));
     }
     if (directedDeleteIDs.length) {
       const directedDeleteQuery = SQL`
         DELETE FROM relationships_directed
         WHERE 
           (user1 = ${viewer.userID} AND user2 IN (${directedDeleteIDs})) OR
           (status = ${directedStatus.PENDING_FRIEND} AND 
             user1 IN (${directedDeleteIDs}) AND user2 = ${viewer.userID})
       `;
       promises.push(dbQuery(directedDeleteQuery));
     }
     if (messageDatas.length > 0) {
       promises.push(createMessages(viewer, messageDatas, 'broadcast'));
     }
 
     await Promise.all(promises);
   } else if (action === relationshipActions.UNFRIEND) {
     updateIDs.push(...userIDs);
 
     const updateRows = userIDs.map(userID => {
       const [user1, user2] = sortUserIDs(viewer.userID, userID);
       return { user1, user2, status: undirectedStatus.KNOW_OF };
     });
 
     const deleteQuery = SQL`
       DELETE FROM relationships_directed
       WHERE 
         status = ${directedStatus.PENDING_FRIEND} AND 
         (user1 = ${viewer.userID} AND user2 IN (${userIDs}) OR 
           user1 IN (${userIDs}) AND user2 = ${viewer.userID})
     `;
 
     await Promise.all([
       updateUndirectedRelationships(updateRows, false),
       dbQuery(deleteQuery),
     ]);
   } else if (action === relationshipActions.BLOCK) {
     updateIDs.push(...userIDs);
 
     const directedRows = [];
     const undirectedRows = [];
     for (const userID of userIDs) {
       directedRows.push([viewer.userID, userID, directedStatus.BLOCKED]);
       const [user1, user2] = sortUserIDs(viewer.userID, userID);
       undirectedRows.push({ user1, user2, status: undirectedStatus.KNOW_OF });
     }
 
     const directedInsertQuery = SQL`
       INSERT INTO relationships_directed (user1, user2, status)
       VALUES ${directedRows}
       ON DUPLICATE KEY UPDATE status = VALUE(status)
     `;
     const directedDeleteQuery = SQL`
       DELETE FROM relationships_directed
       WHERE status = ${directedStatus.PENDING_FRIEND} AND 
         user1 IN (${userIDs}) AND user2 = ${viewer.userID}
     `;
 
     await Promise.all([
       dbQuery(directedInsertQuery),
       dbQuery(directedDeleteQuery),
       updateUndirectedRelationships(undirectedRows, false),
     ]);
   } else if (action === relationshipActions.UNBLOCK) {
     updateIDs.push(...userIDs);
 
     const query = SQL`
       DELETE FROM relationships_directed
       WHERE status = ${directedStatus.BLOCKED} AND 
         user1 = ${viewer.userID} AND user2 IN (${userIDs})
     `;
     await dbQuery(query);
   } else if (action === relationshipActions.FARCASTER_MUTUAL) {
     // We have to create personal threads before setting the relationship
     // status. By doing that we make sure that failed thread creation is
     // reported to the caller and can be repeated - there should be only
     // one PERSONAL thread per a pair of users and we can safely call it
     // repeatedly.
     await createPersonalThreads(viewer, request);
     const insertRows = request.userIDs.map(otherUserID => {
       const [user1, user2] = sortUserIDs(viewer.userID, otherUserID);
       return { user1, user2, status: undirectedStatus.KNOW_OF };
     });
     const updateDatas = await updateChangedUndirectedRelationships(insertRows);
     await createUpdates(updateDatas);
   } else {
     invariant(false, `action ${action} is invalid or not supported currently`);
   }
 
   await createUpdates(
     updateDatasForUserPairs(cartesianProduct([viewer.userID], updateIDs)),
   );
 
   return Object.freeze({ ...errors });
 }
 
 function updateDatasForUserPairs(
   userPairs: $ReadOnlyArray<[string, string]>,
 ): UpdateData[] {
   const time = Date.now();
   const updateDatas: Array<UpdateData> = [];
   for (const [user1, user2] of userPairs) {
     updateDatas.push({
       type: updateTypes.UPDATE_USER,
       userID: user1,
       time,
       updatedUserID: user2,
     });
     updateDatas.push({
       type: updateTypes.UPDATE_USER,
       userID: user2,
       time,
       updatedUserID: user1,
     });
   }
   return updateDatas;
 }
 
 async function updateUndirectedRelationships(
   changeset: UndirectedRelationshipRow[],
   greatest: boolean = true,
 ) {
   if (!changeset.length) {
     return;
   }
 
   const rows = changeset.map(row => [row.user1, row.user2, row.status]);
   const query = SQL`
     INSERT INTO relationships_undirected (user1, user2, status)
     VALUES ${rows}
   `;
   if (greatest) {
     query.append(
       SQL`ON DUPLICATE KEY UPDATE status = GREATEST(status, VALUE(status))`,
     );
   } else {
     query.append(SQL`ON DUPLICATE KEY UPDATE status = VALUE(status)`);
   }
   await dbQuery(query);
 }
 
 async function updateChangedUndirectedRelationships(
   changeset: UndirectedRelationshipRow[],
 ): Promise<UpdateData[]> {
   if (changeset.length === 0) {
     return [];
   }
 
   const user2ByUser1: Map<string, Set<string>> = new Map();
   for (const { user1, user2 } of changeset) {
     if (!user2ByUser1.has(user1)) {
       user2ByUser1.set(user1, new Set());
     }
     user2ByUser1.get(user1)?.add(user2);
   }
 
   const selectQuery = SQL`
     SELECT user1, user2, status
     FROM relationships_undirected
     WHERE
   `;
   const conditions = [];
   for (const [user1, users] of user2ByUser1) {
     conditions.push(SQL`(user1 = ${user1} AND user2 IN (${[...users]}))`);
   }
   selectQuery.append(mergeOrConditions(conditions));
 
   const [result] = await dbQuery(selectQuery);
   const existingStatuses = new Map<string, number>();
   for (const row of result) {
     existingStatuses.set(`${row.user1}|${row.user2}`, row.status);
   }
 
   const insertRows = [];
   for (const row of changeset) {
     const existingStatus = existingStatuses.get(`${row.user1}|${row.user2}`);
     if (!existingStatus || existingStatus < row.status) {
       insertRows.push([row.user1, row.user2, row.status]);
     }
   }
   if (insertRows.length === 0) {
     return [];
   }
   const insertQuery = SQL`
     INSERT INTO relationships_undirected (user1, user2, status)
     VALUES ${insertRows}
     ON DUPLICATE KEY UPDATE status = GREATEST(status, VALUE(status))
   `;
   await dbQuery(insertQuery);
 
   return updateDatasForUserPairs(
     insertRows.map(([user1, user2]) => [user1, user2]),
   );
 }
 
 async function createPersonalThreads(
   viewer: Viewer,
-  request: RelationshipRequest,
+  request: TraditionalRelationshipRequest,
 ) {
   invariant(
     request.action === relationshipActions.FRIEND ||
       request.action === relationshipActions.FARCASTER_MUTUAL,
     'We should only create a PERSONAL threads when sending FRIEND or ' +
       'FARCASTER_MUTUAL requests, but we tried to do that for ' +
       request.action,
   );
 
   const threadIDPerUser: { [string]: string } = {};
 
   const personalThreadsQuery = SQL`
     SELECT t.id AS threadID, m2.user AS user2
     FROM threads t
     INNER JOIN memberships m1
       ON m1.thread = t.id AND m1.user = ${viewer.userID}
     INNER JOIN memberships m2
       ON m2.thread = t.id AND m2.user IN (${request.userIDs})
     WHERE t.type = ${threadTypes.PERSONAL}
       AND m1.role > 0
       AND m2.role > 0
   `;
   const [personalThreadsResult] = await dbQuery(personalThreadsQuery);
 
   for (const row of personalThreadsResult) {
     const user2 = row.user2.toString();
     threadIDPerUser[user2] = row.threadID.toString();
   }
 
   const threadCreationPromises: { [string]: Promise<NewThreadResponse> } = {};
   for (const userID of request.userIDs) {
     if (threadIDPerUser[userID]) {
       continue;
     }
     threadCreationPromises[userID] = createThread(
       viewer,
       {
         type: threadTypes.PERSONAL,
         initialMemberIDs: [userID],
       },
       { forceAddMembers: true, updatesForCurrentSession: 'broadcast' },
     );
   }
 
   const personalThreadPerUser = await promiseAll(threadCreationPromises);
 
   for (const userID in personalThreadPerUser) {
     const newThread = personalThreadPerUser[userID];
     threadIDPerUser[userID] = newThread.newThreadID;
   }
 
   return threadIDPerUser;
 }
 
 export {
   updateRelationships,
   updateDatasForUserPairs,
   updateUndirectedRelationships,
   updateChangedUndirectedRelationships,
 };
diff --git a/lib/actions/relationship-actions.js b/lib/actions/relationship-actions.js
index 2ce499ea9..a71e92839 100644
--- a/lib/actions/relationship-actions.js
+++ b/lib/actions/relationship-actions.js
@@ -1,37 +1,39 @@
 // @flow
 
 import type {
-  RelationshipRequest,
+  TraditionalRelationshipRequest,
   RelationshipErrors,
 } from '../types/relationship-types.js';
 import type { CallSingleKeyserverEndpoint } from '../utils/call-single-keyserver-endpoint.js';
 import { ServerError } from '../utils/errors.js';
 
 const updateRelationshipsActionTypes = Object.freeze({
   started: 'UPDATE_RELATIONSHIPS_STARTED',
   success: 'UPDATE_RELATIONSHIPS_SUCCESS',
   failed: 'UPDATE_RELATIONSHIPS_FAILED',
 });
 const updateRelationships =
   (
     callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
-  ): ((request: RelationshipRequest) => Promise<RelationshipErrors>) =>
+  ): ((
+    request: TraditionalRelationshipRequest,
+  ) => Promise<RelationshipErrors>) =>
   async request => {
     const errors = await callSingleKeyserverEndpoint(
       'update_relationships',
       request,
     );
 
     const { invalid_user, already_friends, user_blocked } = errors;
     if (invalid_user) {
       throw new ServerError('invalid_user', errors);
     } else if (already_friends) {
       throw new ServerError('already_friends', errors);
     } else if (user_blocked) {
       throw new ServerError('user_blocked', errors);
     }
 
     return errors;
   };
 
 export { updateRelationshipsActionTypes, updateRelationships };
diff --git a/lib/types/relationship-types.js b/lib/types/relationship-types.js
index 308639c33..b6f00dff9 100644
--- a/lib/types/relationship-types.js
+++ b/lib/types/relationship-types.js
@@ -1,113 +1,113 @@
 // @flow
 
 import type { TInterface, TRefinement } from 'tcomb';
 import t from 'tcomb';
 
 import type { AccountUserInfo } from './user-types.js';
 import { values } from '../utils/objects.js';
 import { tNumEnum, tShape, tString } from '../utils/validation-utils.js';
 
 export const undirectedStatus = Object.freeze({
   KNOW_OF: 0,
   FRIEND: 2,
 });
 export type UndirectedStatus = $Values<typeof undirectedStatus>;
 
 export const directedStatus = Object.freeze({
   PENDING_FRIEND: 1,
   BLOCKED: 3,
 });
 export type DirectedStatus = $Values<typeof directedStatus>;
 
 export const userRelationshipStatus = Object.freeze({
   REQUEST_SENT: 1,
   REQUEST_RECEIVED: 2,
   FRIEND: 3,
   BLOCKED_BY_VIEWER: 4,
   BLOCKED_VIEWER: 5,
   BOTH_BLOCKED: 6,
 });
 export type UserRelationshipStatus = $Values<typeof userRelationshipStatus>;
 export const userRelationshipStatusValidator: TRefinement<number> = tNumEnum(
   values(userRelationshipStatus),
 );
 
 const relationshipActionsSansFarcaster = Object.freeze({
   FRIEND: 'friend',
   UNFRIEND: 'unfriend',
   BLOCK: 'block',
   UNBLOCK: 'unblock',
 });
 
 const farcasterRelationshipActions = Object.freeze({
   FARCASTER_MUTUAL: 'farcaster',
 });
 
 export const relationshipActions = Object.freeze({
   ...relationshipActionsSansFarcaster,
   ...farcasterRelationshipActions,
 });
 
 export type RelationshipAction = $Values<typeof relationshipActions>;
 export const relationshipActionsList: $ReadOnlyArray<RelationshipAction> =
   values(relationshipActions);
 
 export type RelationshipActionSansFarcaster = $Values<
   typeof relationshipActionsSansFarcaster,
 >;
 
 export const relationshipButtons = Object.freeze({
   FRIEND: 'friend',
   UNFRIEND: 'unfriend',
   BLOCK: 'block',
   UNBLOCK: 'unblock',
   ACCEPT: 'accept',
   WITHDRAW: 'withdraw',
   REJECT: 'reject',
 });
 export type RelationshipButton = $Values<typeof relationshipButtons>;
 
-export type RelationshipRequest = {
+export type TraditionalRelationshipRequest = {
   +action: RelationshipAction,
   +userIDs: $ReadOnlyArray<string>,
 };
 
 export type FarcasterRelationshipRequest = {
   +action: 'farcaster',
   +userIDsToFID: { +[userID: string]: string },
 };
 
 const exactlyTwoDictEntriesValidator = t.refinement(
   t.dict(t.String, t.String),
   dict => Object.keys(dict).length === 2,
 );
 
 export const updateFarcasterRelationshipInputValidator: TInterface<FarcasterRelationshipRequest> =
   tShape<FarcasterRelationshipRequest>({
     action: tString('farcaster'),
     userIDsToFID: exactlyTwoDictEntriesValidator,
   });
 
 type SharedRelationshipRow = {
   user1: string,
   user2: string,
 };
 export type DirectedRelationshipRow = {
   ...SharedRelationshipRow,
   status: DirectedStatus,
 };
 export type UndirectedRelationshipRow = {
   ...SharedRelationshipRow,
   status: UndirectedStatus,
 };
 
 export type RelationshipErrors = Partial<{
   invalid_user: string[],
   already_friends: string[],
   user_blocked: string[],
 }>;
 
 export type UserRelationships = {
   +friends: $ReadOnlyArray<AccountUserInfo>,
   +blocked: $ReadOnlyArray<AccountUserInfo>,
 };
diff --git a/native/profile/relationship-list-item.react.js b/native/profile/relationship-list-item.react.js
index 49e969f82..2d8fd5d63 100644
--- a/native/profile/relationship-list-item.react.js
+++ b/native/profile/relationship-list-item.react.js
@@ -1,363 +1,363 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text, TouchableOpacity, ActivityIndicator } from 'react-native';
 
 import {
   updateRelationshipsActionTypes,
   updateRelationships,
 } from 'lib/actions/relationship-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { ReactRef } from 'lib/types/react-types.js';
 import {
-  type RelationshipRequest,
+  type TraditionalRelationshipRequest,
   type RelationshipAction,
   type RelationshipErrors,
   userRelationshipStatus,
   relationshipActions,
 } from 'lib/types/relationship-types.js';
 import type {
   AccountUserInfo,
   GlobalAccountUserInfo,
 } from 'lib/types/user-types.js';
 import { useLegacyAshoatKeyserverCall } from 'lib/utils/action-utils.js';
 import {
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/redux-promise-utils.js';
 
 import type { RelationshipListNavigate } from './relationship-list.react.js';
 import UserAvatar from '../avatars/user-avatar.react.js';
 import PencilIcon from '../components/pencil-icon.react.js';
 import SingleLine from '../components/single-line.react.js';
 import {
   type KeyboardState,
   KeyboardContext,
 } from '../keyboard/keyboard-state.js';
 import {
   OverlayContext,
   type OverlayContextType,
 } from '../navigation/overlay-context.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import {
   UserRelationshipTooltipModalRouteName,
   FriendListRouteName,
   BlockListRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../themes/colors.js';
 import type { VerticalBounds } from '../types/layout-types.js';
 import { useNavigateToUserProfileBottomSheet } from '../user-profile/user-profile-utils.js';
 import { UnknownErrorAlertDetails } from '../utils/alert-messages.js';
 import Alert from '../utils/alert.js';
 
 const unboundStyles = {
   container: {
     flex: 1,
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 10,
     backgroundColor: 'panelForeground',
     borderColor: 'panelForegroundBorder',
   },
   borderBottom: {
     borderBottomWidth: 1,
   },
   buttonContainer: {
     flexDirection: 'row',
   },
   editButtonWithMargin: {
     marginLeft: 15,
   },
   username: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontSize: 16,
     lineHeight: 20,
     marginLeft: 8,
   },
   editButton: {
     paddingLeft: 10,
   },
   blueAction: {
     color: 'link',
     fontSize: 16,
     paddingLeft: 6,
   },
   redAction: {
     color: 'redText',
     fontSize: 16,
     paddingLeft: 6,
   },
 };
 
 type BaseProps = {
   +userInfo: AccountUserInfo,
   +lastListItem: boolean,
   +verticalBounds: ?VerticalBounds,
   +relationshipListRoute: NavigationRoute<'FriendList' | 'BlockList'>,
   +navigate: RelationshipListNavigate,
   +onSelect: (selectedUser: GlobalAccountUserInfo) => void,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +removeUserLoadingStatus: LoadingStatus,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +updateRelationships: (
-    request: RelationshipRequest,
+    request: TraditionalRelationshipRequest,
   ) => Promise<RelationshipErrors>,
   // withOverlayContext
   +overlayContext: ?OverlayContextType,
   // withKeyboardState
   +keyboardState: ?KeyboardState,
   +navigateToUserProfileBottomSheet: (userID: string) => mixed,
 };
 class RelationshipListItem extends React.PureComponent<Props> {
   editButton: ReactRef<React.ElementRef<typeof View>> = React.createRef();
 
   render(): React.Node {
     const {
       lastListItem,
       removeUserLoadingStatus,
       userInfo,
       relationshipListRoute,
     } = this.props;
     const relationshipsToEdit = {
       [FriendListRouteName]: [userRelationshipStatus.FRIEND],
       [BlockListRouteName]: [
         userRelationshipStatus.BOTH_BLOCKED,
         userRelationshipStatus.BLOCKED_BY_VIEWER,
       ],
     }[relationshipListRoute.name];
 
     const canEditFriendRequest = {
       [FriendListRouteName]: true,
       [BlockListRouteName]: false,
     }[relationshipListRoute.name];
 
     const borderBottom = lastListItem ? null : this.props.styles.borderBottom;
 
     let editButton = null;
     if (removeUserLoadingStatus === 'loading') {
       editButton = (
         <ActivityIndicator
           size="small"
           color={this.props.colors.panelForegroundSecondaryLabel}
         />
       );
     } else if (relationshipsToEdit.includes(userInfo.relationshipStatus)) {
       editButton = (
         <TouchableOpacity
           onPress={this.onPressEdit}
           style={this.props.styles.editButton}
         >
           <View onLayout={this.onLayout} ref={this.editButton}>
             <PencilIcon />
           </View>
         </TouchableOpacity>
       );
     } else if (
       userInfo.relationshipStatus === userRelationshipStatus.REQUEST_RECEIVED &&
       canEditFriendRequest
     ) {
       editButton = (
         <View style={this.props.styles.buttonContainer}>
           <TouchableOpacity
             onPress={this.onPressFriendUser}
             style={this.props.styles.editButton}
           >
             <Text style={this.props.styles.blueAction}>Accept</Text>
           </TouchableOpacity>
           <TouchableOpacity
             onPress={this.onPressUnfriendUser}
             style={[
               this.props.styles.editButton,
               this.props.styles.editButtonWithMargin,
             ]}
           >
             <Text style={this.props.styles.redAction}>Reject</Text>
           </TouchableOpacity>
         </View>
       );
     } else if (
       userInfo.relationshipStatus === userRelationshipStatus.REQUEST_SENT &&
       canEditFriendRequest
     ) {
       editButton = (
         <TouchableOpacity
           onPress={this.onPressUnfriendUser}
           style={this.props.styles.editButton}
         >
           <Text style={this.props.styles.redAction}>Cancel request</Text>
         </TouchableOpacity>
       );
     } else {
       editButton = (
         <TouchableOpacity
           onPress={this.onSelect}
           style={this.props.styles.editButton}
         >
           <Text style={this.props.styles.blueAction}>Add</Text>
         </TouchableOpacity>
       );
     }
 
     return (
       <TouchableOpacity
         onPress={this.onPressUser}
         style={[this.props.styles.container, borderBottom]}
       >
         <UserAvatar size="S" userID={this.props.userInfo.id} />
         <SingleLine style={this.props.styles.username}>
           {this.props.userInfo.username}
         </SingleLine>
         {editButton}
       </TouchableOpacity>
     );
   }
 
   onPressUser = () => {
     this.props.navigateToUserProfileBottomSheet(this.props.userInfo.id);
   };
 
   onSelect = () => {
     const { id, username } = this.props.userInfo;
     this.props.onSelect({ id, username });
   };
 
   visibleEntryIDs(): [string] {
     const { relationshipListRoute } = this.props;
     const id = {
       [FriendListRouteName]: 'unfriend',
       [BlockListRouteName]: 'unblock',
     }[relationshipListRoute.name];
     return [id];
   }
 
   onPressEdit = () => {
     if (this.props.keyboardState?.dismissKeyboardIfShowing()) {
       return;
     }
 
     const {
       editButton,
       props: { verticalBounds },
     } = this;
     const { overlayContext, userInfo } = this.props;
     invariant(
       overlayContext,
       'RelationshipListItem should have OverlayContext',
     );
     overlayContext.setScrollBlockingModalStatus('open');
 
     if (!editButton.current || !verticalBounds) {
       return;
     }
     const { relationshipStatus, ...restUserInfo } = userInfo;
     const relativeUserInfo = {
       ...restUserInfo,
       isViewer: false,
     };
     editButton.current.measure((x, y, width, height, pageX, pageY) => {
       const coordinates = { x: pageX, y: pageY, width, height };
       this.props.navigate<'UserRelationshipTooltipModal'>({
         name: UserRelationshipTooltipModalRouteName,
         params: {
           presentedFrom: this.props.relationshipListRoute.key,
           initialCoordinates: coordinates,
           verticalBounds,
           visibleEntryIDs: this.visibleEntryIDs(),
           relativeUserInfo,
           tooltipButtonIcon: 'pencil',
         },
       });
     });
   };
 
   // We need to set onLayout in order to allow .measure() to be on the ref
   onLayout = () => {};
 
   onPressFriendUser = () => {
     this.onPressUpdateFriendship(relationshipActions.FRIEND);
   };
 
   onPressUnfriendUser = () => {
     this.onPressUpdateFriendship(relationshipActions.UNFRIEND);
   };
 
   onPressUpdateFriendship(action: RelationshipAction) {
     const { id } = this.props.userInfo;
     const customKeyName = `${updateRelationshipsActionTypes.started}:${id}`;
     void this.props.dispatchActionPromise(
       updateRelationshipsActionTypes,
       this.updateFriendship(action),
       { customKeyName },
     );
   }
 
   async updateFriendship(
     action: RelationshipAction,
   ): Promise<RelationshipErrors> {
     try {
       return await this.props.updateRelationships({
         action,
         userIDs: [this.props.userInfo.id],
       });
     } catch (e) {
       Alert.alert(
         UnknownErrorAlertDetails.title,
         UnknownErrorAlertDetails.message,
         [{ text: 'OK' }],
         {
           cancelable: true,
         },
       );
       throw e;
     }
   }
 }
 
 const ConnectedRelationshipListItem: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedRelationshipListItem(
     props: BaseProps,
   ) {
     const removeUserLoadingStatus = useSelector(state =>
       createLoadingStatusSelector(
         updateRelationshipsActionTypes,
         `${updateRelationshipsActionTypes.started}:${props.userInfo.id}`,
       )(state),
     );
     const colors = useColors();
     const styles = useStyles(unboundStyles);
     const dispatchActionPromise = useDispatchActionPromise();
     const boundUpdateRelationships =
       useLegacyAshoatKeyserverCall(updateRelationships);
     const overlayContext = React.useContext(OverlayContext);
     const keyboardState = React.useContext(KeyboardContext);
 
     const navigateToUserProfileBottomSheet =
       useNavigateToUserProfileBottomSheet();
 
     return (
       <RelationshipListItem
         {...props}
         removeUserLoadingStatus={removeUserLoadingStatus}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         updateRelationships={boundUpdateRelationships}
         overlayContext={overlayContext}
         keyboardState={keyboardState}
         navigateToUserProfileBottomSheet={navigateToUserProfileBottomSheet}
       />
     );
   });
 
 export default ConnectedRelationshipListItem;