diff --git a/lib/types/relationship-types.js b/lib/types/relationship-types.js
index efd4d18fb..5ea8ad92c 100644
--- a/lib/types/relationship-types.js
+++ b/lib/types/relationship-types.js
@@ -1,119 +1,114 @@
 // @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 farcasterRelationshipRequestValidator: TInterface<FarcasterRelationshipRequest> =
   tShape<FarcasterRelationshipRequest>({
     action: tString('farcaster'),
-    userIDsToFID: exactlyTwoDictEntriesValidator,
+    userIDsToFID: t.dict(t.String, t.String),
   });
 
 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/lib/types/relationship-types.test.js b/lib/types/relationship-types.test.js
index aa366c5fa..f4837c755 100644
--- a/lib/types/relationship-types.test.js
+++ b/lib/types/relationship-types.test.js
@@ -1,49 +1,27 @@
 // @flow
 
 import { farcasterRelationshipRequestValidator } from './relationship-types.js';
 
 describe('updateFarcasterRelationshipInputValidator', () => {
-  test('SHOULD validate input with exactly 2 userIDsToFID entries', () => {
+  test('SHOULD validate input with 2 userIDsToFID entries', () => {
     const input = {
       action: 'farcaster',
       userIDsToFID: {
         '256': 'f256',
         '512': 'f512',
       },
     };
     expect(farcasterRelationshipRequestValidator.is(input)).toBe(true);
   });
 
-  test('SHOULD NOT validate input with > 2 userIDsToFID entries', () => {
-    const input = {
-      action: 'farcaster',
-      userIDsToFID: {
-        '256': 'f256',
-        '512': 'f512',
-        '1024': 'f1024',
-      },
-    };
-    expect(farcasterRelationshipRequestValidator.is(input)).toBe(false);
-  });
-
-  test('SHOULD NOT validate input with < 2 userIDsToFID entries', () => {
-    const input = {
-      action: 'farcaster',
-      userIDsToFID: {
-        '256': 'f256',
-      },
-    };
-    expect(farcasterRelationshipRequestValidator.is(input)).toBe(false);
-  });
-
   test('Should not validate if action is not farcaster', () => {
     const input = {
       action: 'NOT_FARCASTER',
       userIDsToFID: {
         '256': 'f256',
         '512': 'f512',
       },
     };
     expect(farcasterRelationshipRequestValidator.is(input)).toBe(false);
   });
 });