diff --git a/lib/hooks/peer-list-hooks.js b/lib/hooks/peer-list-hooks.js
index e86b60a1f..632e290c2 100644
--- a/lib/hooks/peer-list-hooks.js
+++ b/lib/hooks/peer-list-hooks.js
@@ -1,173 +1,138 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { setPeerDeviceListsActionType } from '../actions/aux-user-actions.js';
-import {
-  getAllPeerDevices,
-  getRelativeUserIDs,
-} from '../selectors/user-selectors.js';
+import { getAllPeerDevices } from '../selectors/user-selectors.js';
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js';
 import type {
   UsersRawDeviceLists,
   UsersDevicesPlatformDetails,
   SignedDeviceList,
   RawDeviceList,
 } from '../types/identity-service-types.js';
 import {
   type DeviceListUpdated,
   peerToPeerMessageTypes,
 } from '../types/tunnelbroker/peer-to-peer-message-types.js';
 import { getContentSigningKey } from '../utils/crypto-utils.js';
 import { convertSignedDeviceListsToRawDeviceLists } from '../utils/device-list-utils.js';
 import { values } from '../utils/objects.js';
 import { useDispatch, useSelector } from '../utils/redux-utils.js';
 
-function useCreateInitialPeerList(): () => Promise<void> {
-  const dispatch = useDispatch();
-  const relativeUserIDs = useSelector(getRelativeUserIDs);
-
-  const identityContext = React.useContext(IdentityClientContext);
-  invariant(identityContext, 'Identity context should be set');
-
-  return React.useCallback(async () => {
-    if (!identityContext) {
-      return;
-    }
-    try {
-      const peersDeviceLists =
-        await identityContext.identityClient.getDeviceListsForUsers(
-          relativeUserIDs,
-        );
-      const usersRawDeviceLists = convertSignedDeviceListsToRawDeviceLists(
-        peersDeviceLists.usersSignedDeviceLists,
-      );
-      const usersPlatformDetails = peersDeviceLists.usersDevicesPlatformDetails;
-
-      dispatch({
-        type: setPeerDeviceListsActionType,
-        payload: { deviceLists: usersRawDeviceLists, usersPlatformDetails },
-      });
-    } catch (e) {
-      console.log(`Error creating initial peer list: ${e.message}`);
-    }
-  }, [dispatch, identityContext, relativeUserIDs]);
-}
-
 function useGetDeviceListsForUsers(): (
   userIDs: $ReadOnlyArray<string>,
 ) => Promise<{
   +deviceLists: UsersRawDeviceLists,
   +usersPlatformDetails: UsersDevicesPlatformDetails,
 }> {
   const client = React.useContext(IdentityClientContext);
   const identityClient = client?.identityClient;
   invariant(identityClient, 'Identity client should be set');
   return React.useCallback(
     async (userIDs: $ReadOnlyArray<string>) => {
       const peersDeviceLists =
         await identityClient.getDeviceListsForUsers(userIDs);
       return {
         deviceLists: convertSignedDeviceListsToRawDeviceLists(
           peersDeviceLists.usersSignedDeviceLists,
         ),
         usersPlatformDetails: peersDeviceLists.usersDevicesPlatformDetails,
       };
     },
     [identityClient],
   );
 }
 
 function useGetAndUpdateDeviceListsForUsers(): (
   userIDs: $ReadOnlyArray<string>,
   broadcastUpdates: ?boolean,
 ) => Promise<void> {
   const getDeviceListsForUsers = useGetDeviceListsForUsers();
   const dispatch = useDispatch();
   const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
 
   const allPeerDevices = useSelector(getAllPeerDevices);
 
   return React.useCallback(
     async (userIDs: $ReadOnlyArray<string>, broadcastUpdates: ?boolean) => {
       const { deviceLists, usersPlatformDetails } =
         await getDeviceListsForUsers(userIDs);
       if (Object.keys(deviceLists).length === 0) {
         return;
       }
       dispatch({
         type: setPeerDeviceListsActionType,
         payload: { deviceLists, usersPlatformDetails },
       });
 
       if (!broadcastUpdates) {
         return;
       }
 
       const thisDeviceID = await getContentSigningKey();
 
       const newDevices = values(deviceLists)
         .map((deviceList: RawDeviceList) => deviceList.devices)
         .flat()
         .filter(
           deviceID =>
             !allPeerDevices.includes(deviceID) && deviceID !== thisDeviceID,
         );
 
       await broadcastDeviceListUpdates(newDevices);
     },
     [
       allPeerDevices,
       broadcastDeviceListUpdates,
       dispatch,
       getDeviceListsForUsers,
     ],
   );
 }
 
 function useBroadcastDeviceListUpdates(): (
   deviceIDs: $ReadOnlyArray<string>,
   signedDeviceList?: SignedDeviceList,
 ) => Promise<void> {
   const { sendMessage } = useTunnelbroker();
   const identityContext = React.useContext(IdentityClientContext);
   invariant(identityContext, 'identity context not set');
 
   return React.useCallback(
     async (
       deviceIDs: $ReadOnlyArray<string>,
       signedDeviceList?: SignedDeviceList,
     ) => {
       const { getAuthMetadata } = identityContext;
 
       const { userID } = await getAuthMetadata();
       if (!userID) {
         throw new Error('missing auth metadata');
       }
       const messageToPeer: DeviceListUpdated = {
         type: peerToPeerMessageTypes.DEVICE_LIST_UPDATED,
         userID,
         signedDeviceList,
       };
       const payload = JSON.stringify(messageToPeer);
 
       const promises = deviceIDs.map((deviceID: string) =>
         sendMessage({
           deviceID,
           payload,
         }),
       );
       await Promise.all(promises);
     },
     [identityContext, sendMessage],
   );
 }
 
 export {
-  useCreateInitialPeerList,
   useGetDeviceListsForUsers,
   useBroadcastDeviceListUpdates,
   useGetAndUpdateDeviceListsForUsers,
 };
diff --git a/native/profile/tunnelbroker-menu.react.js b/native/profile/tunnelbroker-menu.react.js
index 05a79e90d..15522363a 100644
--- a/native/profile/tunnelbroker-menu.react.js
+++ b/native/profile/tunnelbroker-menu.react.js
@@ -1,276 +1,264 @@
 // @flow
 
 import * as React from 'react';
 import { useState } from 'react';
 import { Text, View } from 'react-native';
 import { ScrollView } from 'react-native-gesture-handler';
 
-import { useCreateInitialPeerList } from 'lib/hooks/peer-list-hooks.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import { useTunnelbroker } from 'lib/tunnelbroker/tunnelbroker-context.js';
 import {
   tunnelbrokerMessageTypes,
   type TunnelbrokerMessage,
 } from 'lib/types/tunnelbroker/messages.js';
 import {
   type EncryptedMessage,
   peerToPeerMessageTypes,
 } from 'lib/types/tunnelbroker/peer-to-peer-message-types.js';
 import {
   createOlmSessionsWithOwnDevices,
   getContentSigningKey,
 } from 'lib/utils/crypto-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import Button from '../components/button.react.js';
 import TextInput from '../components/text-input.react.js';
 import { olmAPI } from '../crypto/olm-api.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useColors, useStyles } from '../themes/colors.js';
 
 type Props = {
   +navigation: ProfileNavigationProp<'TunnelbrokerMenu'>,
   +route: NavigationRoute<'TunnelbrokerMenu'>,
 };
 
 // eslint-disable-next-line no-unused-vars
 function TunnelbrokerMenu(props: Props): React.Node {
   const styles = useStyles(unboundStyles);
   const colors = useColors();
   const currentUserID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const identityContext = React.useContext(IdentityClientContext);
 
   const { connected, addListener, sendMessage, removeListener } =
     useTunnelbroker();
   const [messages, setMessages] = useState<TunnelbrokerMessage[]>([]);
   const [recipient, setRecipient] = useState('');
   const [message, setMessage] = useState('');
   const [deviceID, setDeviceID] = React.useState<?string>();
 
   React.useEffect(() => {
     void (async () => {
       const contentSigningKey = await getContentSigningKey();
       setDeviceID(contentSigningKey);
     })();
   }, []);
 
   const listener = React.useCallback((msg: TunnelbrokerMessage) => {
     setMessages(prev => [...prev, msg]);
   }, []);
 
   React.useEffect(() => {
     addListener(listener);
     return () => removeListener(listener);
   }, [addListener, listener, removeListener]);
 
   const onSubmit = React.useCallback(async () => {
     try {
       await sendMessage({ deviceID: recipient, payload: message });
     } catch (e) {
       console.log(e.message);
     }
   }, [message, recipient, sendMessage]);
 
   const onCreateSessions = React.useCallback(async () => {
     if (!identityContext) {
       return;
     }
     const authMetadata = await identityContext.getAuthMetadata();
     try {
       await createOlmSessionsWithOwnDevices(
         authMetadata,
         identityContext.identityClient,
         sendMessage,
       );
     } catch (e) {
       console.log(`Error creating olm sessions with own devices: ${e.message}`);
     }
   }, [identityContext, sendMessage]);
 
-  const onCreateInitialPeerList = useCreateInitialPeerList();
-
   const onSendEncryptedMessage = React.useCallback(async () => {
     try {
       if (!currentUserID) {
         return;
       }
       await olmAPI.initializeCryptoAccount();
       const encryptedData = await olmAPI.encrypt(
         `Encrypted message to ${recipient}`,
         recipient,
       );
       const signingKey = await getContentSigningKey();
       const encryptedMessage: EncryptedMessage = {
         type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
         senderInfo: {
           deviceID: signingKey,
           userID: currentUserID,
         },
         encryptedData,
       };
       await sendMessage({
         deviceID: recipient,
         payload: JSON.stringify(encryptedMessage),
       });
     } catch (e) {
       console.log(`Error sending encrypted content to device: ${e.message}`);
     }
   }, [currentUserID, recipient, sendMessage]);
 
   return (
     <ScrollView
       contentContainerStyle={styles.scrollViewContentContainer}
       style={styles.scrollView}
     >
       <Text style={styles.header}>INFO</Text>
       <View style={styles.section}>
         <View style={styles.submenuButton}>
           <Text style={styles.submenuText}>Connected</Text>
           <Text style={styles.text}>{connected.toString()}</Text>
         </View>
       </View>
 
       <Text style={styles.header}>DEVICE ID</Text>
       <View style={styles.section}>
         <View style={styles.submenuButton}>
           <Text style={styles.submenuText}>{deviceID}</Text>
         </View>
       </View>
 
       <Text style={styles.header}>USER ID</Text>
       <View style={styles.section}>
         <View style={styles.submenuButton}>
           <Text style={styles.submenuText}>{currentUserID}</Text>
         </View>
       </View>
 
       <Text style={styles.header}>SEND MESSAGE</Text>
 
       <View style={styles.section}>
         <View style={styles.submenuButton}>
           <Text style={styles.submenuText}>Recipient</Text>
           <TextInput
             style={styles.textInput}
             value={recipient}
             onChangeText={setRecipient}
           />
         </View>
         <View style={styles.submenuButton}>
           <Text style={styles.submenuText}>Message</Text>
           <TextInput
             style={styles.textInput}
             value={message}
             onChangeText={setMessage}
           />
         </View>
         <Button
           onPress={onSubmit}
           style={styles.row}
           iosFormat="highlight"
           iosHighlightUnderlayColor={colors.panelIosHighlightUnderlay}
           iosActiveOpacity={0.85}
         >
           <Text style={styles.submenuText}>Send Message</Text>
         </Button>
         <Button
           onPress={onCreateSessions}
           style={styles.row}
           iosFormat="highlight"
           iosHighlightUnderlayColor={colors.panelIosHighlightUnderlay}
           iosActiveOpacity={0.85}
         >
           <Text style={styles.submenuText}>
             Create session with own devices
           </Text>
         </Button>
-        <Button
-          onPress={onCreateInitialPeerList}
-          style={styles.row}
-          iosFormat="highlight"
-          iosHighlightUnderlayColor={colors.panelIosHighlightUnderlay}
-          iosActiveOpacity={0.85}
-        >
-          <Text style={styles.submenuText}>Create initial peer list</Text>
-        </Button>
         <Button
           onPress={onSendEncryptedMessage}
           style={styles.row}
           iosFormat="highlight"
           iosHighlightUnderlayColor={colors.panelIosHighlightUnderlay}
           iosActiveOpacity={0.85}
         >
           <Text style={styles.submenuText}>
             Send encrypted message to recipient
           </Text>
         </Button>
       </View>
 
       <Text style={styles.header}>MESSAGES</Text>
       {messages
         .filter(msg => msg.type !== tunnelbrokerMessageTypes.HEARTBEAT)
         .map((msg, id) => (
           <View key={id} style={styles.section}>
             <Text style={styles.submenuText}>{JSON.stringify(msg)}</Text>
           </View>
         ))}
     </ScrollView>
   );
 }
 
 const unboundStyles = {
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   section: {
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     borderTopWidth: 1,
     marginBottom: 24,
     marginVertical: 2,
   },
   header: {
     color: 'panelBackgroundLabel',
     fontSize: 12,
     fontWeight: '400',
     paddingBottom: 3,
     paddingHorizontal: 24,
   },
   submenuButton: {
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 10,
     alignItems: 'center',
   },
   submenuText: {
     color: 'panelForegroundLabel',
     flex: 1,
     fontSize: 16,
   },
   text: {
     color: 'panelForegroundLabel',
     fontSize: 16,
   },
   row: {
     flexDirection: 'row',
     justifyContent: 'space-between',
     paddingHorizontal: 24,
     paddingVertical: 14,
   },
   textInput: {
     color: 'modalBackgroundLabel',
     flex: 1,
     fontSize: 16,
     margin: 0,
     padding: 0,
     borderBottomColor: 'transparent',
   },
 };
 
 export default TunnelbrokerMenu;
diff --git a/web/settings/account-settings.react.js b/web/settings/account-settings.react.js
index b3905f4b4..3658b3e2e 100644
--- a/web/settings/account-settings.react.js
+++ b/web/settings/account-settings.react.js
@@ -1,311 +1,302 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useLogOut,
   logOutActionTypes,
   useSecondaryDeviceLogOut,
 } from 'lib/actions/user-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import SWMansionIcon from 'lib/components/swmansion-icon.react.js';
 import { useStringForUser } from 'lib/hooks/ens-cache.js';
-import { useCreateInitialPeerList } from 'lib/hooks/peer-list-hooks.js';
 import { accountHasPassword } from 'lib/shared/account-utils.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import { useTunnelbroker } from 'lib/tunnelbroker/tunnelbroker-context.js';
 import {
   createOlmSessionsWithOwnDevices,
   getContentSigningKey,
 } from 'lib/utils/crypto-utils.js';
 import { isDev } from 'lib/utils/dev-utils.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 
 import css from './account-settings.css';
 import AppearanceChangeModal from './appearance-change-modal.react.js';
 import BackupTestRestoreModal from './backup-test-restore-modal.react.js';
 import PasswordChangeModal from './password-change-modal.js';
 import BlockListModal from './relationship/block-list-modal.react.js';
 import FriendListModal from './relationship/friend-list-modal.react.js';
 import TunnelbrokerMessagesScreen from './tunnelbroker-message-list.react.js';
 import TunnelbrokerTestScreen from './tunnelbroker-test.react.js';
 import EditUserAvatar from '../avatars/edit-user-avatar.react.js';
 import Button from '../components/button.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 function AccountSettings(): React.Node {
   const sendLogoutRequest = useLogOut();
   const sendSecondaryDeviceLogoutRequest = useSecondaryDeviceLogOut();
   const dispatchActionPromise = useDispatchActionPromise();
   const logOutUser = React.useCallback(
     () => dispatchActionPromise(logOutActionTypes, sendLogoutRequest()),
     [dispatchActionPromise, sendLogoutRequest],
   );
   const logOutSecondaryDevice = React.useCallback(
     () =>
       dispatchActionPromise(
         logOutActionTypes,
         sendSecondaryDeviceLogoutRequest(),
       ),
     [dispatchActionPromise, sendSecondaryDeviceLogoutRequest],
   );
   const identityContext = React.useContext(IdentityClientContext);
 
   const userID = useSelector(state => state.currentUserInfo?.id);
   const [deviceID, setDeviceID] = React.useState<?string>();
 
   React.useEffect(() => {
     void (async () => {
       const contentSigningKey = await getContentSigningKey();
       setDeviceID(contentSigningKey);
     })();
   }, []);
 
   const { pushModal, popModal } = useModalContext();
   const showPasswordChangeModal = React.useCallback(
     () => pushModal(<PasswordChangeModal />),
     [pushModal],
   );
 
   const openFriendList = React.useCallback(
     () => pushModal(<FriendListModal />),
     [pushModal],
   );
 
   const openBlockList = React.useCallback(
     () => pushModal(<BlockListModal />),
     [pushModal],
   );
 
   const isAccountWithPassword = useSelector(state =>
     accountHasPassword(state.currentUserInfo),
   );
 
   const currentUserInfo = useSelector(state => state.currentUserInfo);
   const stringForUser = useStringForUser(currentUserInfo);
 
   const staffCanSee = useStaffCanSee();
   const { sendMessage, connected, addListener, removeListener } =
     useTunnelbroker();
   const openTunnelbrokerModal = React.useCallback(
     () =>
       pushModal(
         <TunnelbrokerTestScreen sendMessage={sendMessage} onClose={popModal} />,
       ),
     [popModal, pushModal, sendMessage],
   );
 
   const openTunnelbrokerMessagesModal = React.useCallback(
     () =>
       pushModal(
         <TunnelbrokerMessagesScreen
           addListener={addListener}
           removeListener={removeListener}
           onClose={popModal}
         />,
       ),
     [addListener, popModal, pushModal, removeListener],
   );
 
   const onCreateOlmSessions = React.useCallback(async () => {
     if (!identityContext) {
       return;
     }
     const authMetadata = await identityContext.getAuthMetadata();
     try {
       await createOlmSessionsWithOwnDevices(
         authMetadata,
         identityContext.identityClient,
         sendMessage,
       );
     } catch (e) {
       console.log(`Error creating olm sessions with own devices: ${e.message}`);
     }
   }, [identityContext, sendMessage]);
 
-  const onCreateInitialPeerList = useCreateInitialPeerList();
-
   const openBackupTestRestoreModal = React.useCallback(
     () => pushModal(<BackupTestRestoreModal onClose={popModal} />),
     [popModal, pushModal],
   );
 
   const showAppearanceModal = React.useCallback(
     () => pushModal(<AppearanceChangeModal />),
     [pushModal],
   );
 
   if (!currentUserInfo || currentUserInfo.anonymous) {
     return null;
   }
 
   let changePasswordSection;
   if (isAccountWithPassword) {
     changePasswordSection = (
       <li>
         <span>Password</span>
         <span className={css.passwordContainer}>
           <span className={css.password}>******</span>
           <a className={css.editPasswordLink} onClick={showPasswordChangeModal}>
             <SWMansionIcon icon="edit-1" size={22} />
           </a>
         </span>
       </li>
     );
   }
 
   let experimentalLogOutSection;
   if (isDev) {
     experimentalLogOutSection = (
       <li>
         <span>Log out secondary device</span>
         <Button variant="text" onClick={logOutSecondaryDevice}>
           <p className={css.buttonText}>Log out</p>
         </Button>
       </li>
     );
   }
 
   let preferences;
   if (staffCanSee) {
     preferences = (
       <div className={css.preferencesContainer}>
         <h4 className={css.preferencesHeader}>Preferences</h4>
         <div className={css.content}>
           <ul>
             <li>
               <span>Appearance</span>
               <a className={css.editPasswordLink} onClick={showAppearanceModal}>
                 <SWMansionIcon icon="edit-1" size={22} />
               </a>
             </li>
           </ul>
         </div>
       </div>
     );
   }
   let tunnelbroker;
   if (staffCanSee) {
     tunnelbroker = (
       <div className={css.preferencesContainer}>
         <h4 className={css.preferencesHeader}>Tunnelbroker menu</h4>
         <div className={css.content}>
           <ul>
             <li>
               <span>Connected</span>
               <span>{connected.toString()}</span>
             </li>
             <li>
               <span>Send message to device</span>
               <Button variant="text" onClick={openTunnelbrokerModal}>
                 <p className={css.buttonText}>Insert data</p>
               </Button>
             </li>
             <li>
               <span>Trace received messages</span>
               <Button variant="text" onClick={openTunnelbrokerMessagesModal}>
                 <p className={css.buttonText}>Show list</p>
               </Button>
             </li>
             <li>
               <span>Create session with own devices</span>
               <Button variant="text" onClick={onCreateOlmSessions}>
                 <p className={css.buttonText}>Create</p>
               </Button>
             </li>
-            <li>
-              <span>Create initial peer list</span>
-              <Button variant="text" onClick={onCreateInitialPeerList}>
-                <p className={css.buttonText}>Create</p>
-              </Button>
-            </li>
           </ul>
         </div>
       </div>
     );
   }
   let backup;
   if (staffCanSee) {
     backup = (
       <div className={css.preferencesContainer}>
         <h4 className={css.preferencesHeader}>Backup menu</h4>
         <div className={css.content}>
           <ul>
             <li>
               <span>Test backup restore</span>
               <Button variant="text" onClick={openBackupTestRestoreModal}>
                 <p className={css.buttonText}>Insert data</p>
               </Button>
             </li>
           </ul>
         </div>
       </div>
     );
   }
   let deviceData;
   if (staffCanSee) {
     deviceData = (
       <div className={css.preferencesContainer}>
         <h4 className={css.preferencesHeader}>Device ID</h4>
         <div className={css.content}>
           <ul>
             <li>
               <span>{deviceID}</span>
             </li>
           </ul>
         </div>
         <h4 className={css.preferencesHeader}>User ID</h4>
         <div className={css.content}>
           <ul>
             <li>
               <span>{userID}</span>
             </li>
           </ul>
         </div>
       </div>
     );
   }
 
   return (
     <div className={css.container}>
       <div className={css.contentContainer}>
         <h4 className={css.header}>My Account</h4>
         <EditUserAvatar userID={currentUserInfo.id} />
         <div className={css.content}>
           <ul>
             <li>
               <p className={css.logoutContainer}>
                 <span className={css.logoutLabel}>{'Logged in as '}</span>
                 <span className={css.username}>{stringForUser}</span>
               </p>
               <Button variant="text" onClick={logOutUser}>
                 <p className={css.buttonText}>Log out</p>
               </Button>
             </li>
             {experimentalLogOutSection}
             {changePasswordSection}
             <li>
               <span>Friend List</span>
               <Button variant="text" onClick={openFriendList}>
                 <p className={css.buttonText}>See List</p>
               </Button>
             </li>
             <li>
               <span>Block List</span>
               <Button variant="text" onClick={openBlockList}>
                 <p className={css.buttonText}>See List</p>
               </Button>
             </li>
           </ul>
         </div>
         {preferences}
         {tunnelbroker}
         {backup}
         {deviceData}
       </div>
     </div>
   );
 }
 
 export default AccountSettings;