diff --git a/keyserver/src/responders/relationship-responders.js b/keyserver/src/responders/relationship-responders.js
index dc14dae3a..2da5e8a91 100644
--- a/keyserver/src/responders/relationship-responders.js
+++ b/keyserver/src/responders/relationship-responders.js
@@ -1,35 +1,38 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type TraditionalRelationshipRequest,
   type RelationshipErrors,
-  relationshipActionsList,
+  traditionalRelationshipActionsList,
 } 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<TraditionalRelationshipRequest> =
   tShape<TraditionalRelationshipRequest>({
-    action: t.enums.of(relationshipActionsList, 'relationship action'),
+    action: t.enums.of(
+      traditionalRelationshipActionsList,
+      '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: TraditionalRelationshipRequest,
 ): Promise<RelationshipErrors> {
   return await updateRelationships(viewer, request);
 }
 
 export { updateRelationshipsResponder };
diff --git a/lib/types/relationship-types.js b/lib/types/relationship-types.js
index 755e3e39c..ac1cefbb4 100644
--- a/lib/types/relationship-types.js
+++ b/lib/types/relationship-types.js
@@ -1,117 +1,119 @@
 // @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 traditionalRelationshipActions = Object.freeze({
   FRIEND: 'friend',
   UNFRIEND: 'unfriend',
   BLOCK: 'block',
   UNBLOCK: 'unblock',
 });
 
 const farcasterRelationshipActions = Object.freeze({
   FARCASTER_MUTUAL: 'farcaster',
 });
 
 export const relationshipActions = Object.freeze({
   ...traditionalRelationshipActions,
   ...farcasterRelationshipActions,
 });
 
 export type RelationshipAction = $Values<typeof relationshipActions>;
 export const relationshipActionsList: $ReadOnlyArray<RelationshipAction> =
   values(relationshipActions);
 
 export type TraditionalRelationshipAction = $Values<
   typeof traditionalRelationshipActions,
 >;
+export const traditionalRelationshipActionsList: $ReadOnlyArray<TraditionalRelationshipAction> =
+  values(traditionalRelationshipActions);
 
 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 TraditionalRelationshipRequest = {
   +action: TraditionalRelationshipAction,
   +userIDs: $ReadOnlyArray<string>,
 };
 
 export type FarcasterRelationshipRequest = {
   +action: 'farcaster',
   +userIDsToFID: { +[userID: string]: string },
 };
 
 export type RelationshipRequest =
   | TraditionalRelationshipRequest
   | FarcasterRelationshipRequest;
 
 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>,
 };