diff --git a/lib/shared/dm-ops/dm-op-utils.js b/lib/shared/dm-ops/dm-op-utils.js
index 6e963875a..32c9b0060 100644
--- a/lib/shared/dm-ops/dm-op-utils.js
+++ b/lib/shared/dm-ops/dm-op-utils.js
@@ -1,108 +1,113 @@
 // @flow
 
 import uuid from 'uuid';
 
-import type { AuxUserStore } from '../../types/aux-user-types.js';
 import type { DMOperation } from '../../types/dm-ops.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import type { RawMessageInfo } from '../../types/message-types.js';
 import type { RawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
 import {
   outboundP2PMessageStatuses,
   type OutboundP2PMessage,
 } from '../../types/sqlite-types.js';
 import { threadTypes } from '../../types/thread-types-enum.js';
 import type { LegacyRawThreadInfo } from '../../types/thread-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import type { ClientUpdateInfo } from '../../types/update-types.js';
 import type { CurrentUserInfo } from '../../types/user-types.js';
 import { getContentSigningKey } from '../../utils/crypto-utils.js';
-import { values } from '../../utils/objects.js';
 import { messageSpecs } from '../messages/message-specs.js';
 
 function generateMessagesToPeers(
   message: DMOperation,
-  peers: $ReadOnlyArray<string>,
-  userID: string,
+  peers: $ReadOnlyArray<{
+    +userID: string,
+    +deviceID: string,
+  }>,
   supportsAutoRetry: boolean,
 ): $ReadOnlyArray<OutboundP2PMessage> {
   const outboundP2PMessages = [];
-  for (const peerID of peers) {
+  for (const peer of peers) {
     const messageToPeer: OutboundP2PMessage = {
       messageID: uuid.v4(),
-      deviceID: peerID,
-      userID,
+      deviceID: peer.deviceID,
+      userID: peer.userID,
       timestamp: new Date().getTime().toString(),
       plaintext: JSON.stringify(message),
       ciphertext: '',
       status: outboundP2PMessageStatuses.persisted,
       supportsAutoRetry,
     };
     outboundP2PMessages.push(messageToPeer);
   }
   return outboundP2PMessages;
 }
 
 export type DMOperationSpecification = {
   +op: DMOperation,
   +supportsAutoRetry: boolean,
   +recipients: 'all_peer_devices' | 'self_devices',
 };
 
 async function createMessagesToPeersFromDMOp(
   operation: DMOperationSpecification,
-  auxUserStore: AuxUserStore,
+  allPeerUserIDAndDeviceIDs: $ReadOnlyArray<{
+    +userID: string,
+    +deviceID: string,
+  }>,
   currentUserInfo: ?CurrentUserInfo,
 ): Promise<$ReadOnlyArray<OutboundP2PMessage>> {
   if (!currentUserInfo?.id) {
     return [];
   }
-  const selfDevices =
-    auxUserStore.auxUserInfos[currentUserInfo.id].deviceList?.devices ?? [];
-  const allPeerDevices = values(auxUserStore.auxUserInfos)
-    .map(info => info.deviceList?.devices ?? [])
-    .flat();
-  const devices =
-    operation.recipients === 'all_peer_devices' ? allPeerDevices : selfDevices;
+
+  let peerUserIDAndDeviceIDs = allPeerUserIDAndDeviceIDs;
+  if (operation.recipients === 'self_devices') {
+    peerUserIDAndDeviceIDs = allPeerUserIDAndDeviceIDs.filter(
+      peer => peer.userID === currentUserInfo.id,
+    );
+  }
+
   const thisDeviceID = await getContentSigningKey();
-  const targetDevices = devices.filter(id => id !== thisDeviceID);
+  const targetPeers = peerUserIDAndDeviceIDs.filter(
+    peer => peer.deviceID !== thisDeviceID,
+  );
   return generateMessagesToPeers(
     operation.op,
-    targetDevices,
-    currentUserInfo.id,
+    targetPeers,
     operation.supportsAutoRetry,
   );
 }
 
 function createRepliesCountUpdate(
   threadInfo: RawThreadInfo | LegacyRawThreadInfo,
   newMessages: $ReadOnlyArray<RawMessageInfo>,
 ): ?ClientUpdateInfo {
   if (threadInfo.type !== threadTypes.THICK_SIDEBAR) {
     return null;
   }
   const includedMessageTypes = new Set(
     Object.keys(messageTypes)
       .map(key => messageTypes[key])
       .filter(type => messageSpecs[type].includedInRepliesCount),
   );
   const filteredMessages = newMessages.filter(message =>
     includedMessageTypes.has(message.type),
   );
   const countIncrease = filteredMessages.length;
   if (countIncrease === 0) {
     return null;
   }
   const time = Math.max(...filteredMessages.map(message => message.time));
   return {
     type: updateTypes.UPDATE_THREAD,
     id: uuid.v4(),
     time,
     threadInfo: {
       ...threadInfo,
       repliesCount: threadInfo.repliesCount + countIncrease,
     },
   };
 }
 
 export { createMessagesToPeersFromDMOp, createRepliesCountUpdate };
diff --git a/lib/tunnelbroker/peer-to-peer-context.js b/lib/tunnelbroker/peer-to-peer-context.js
index 40e928e48..5faf96a92 100644
--- a/lib/tunnelbroker/peer-to-peer-context.js
+++ b/lib/tunnelbroker/peer-to-peer-context.js
@@ -1,349 +1,350 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import uuid from 'uuid';
 
 import {
   type TunnelbrokerClientMessageToDevice,
   useTunnelbroker,
 } from './tunnelbroker-context.js';
 import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
+import { getAllPeerUserIDAndDeviceIDs } from '../selectors/user-selectors.js';
 import {
   createMessagesToPeersFromDMOp,
   type DMOperationSpecification,
 } from '../shared/dm-ops/dm-op-utils.js';
 import {
   type AuthMetadata,
   IdentityClientContext,
   type IdentityClientContextType,
 } from '../shared/identity-client-context.js';
 import { scheduleP2PMessagesActionType } from '../types/dm-ops.js';
 import {
   type OutboundP2PMessage,
   outboundP2PMessageStatuses,
 } from '../types/sqlite-types.js';
 import {
   type EncryptedMessage,
   peerToPeerMessageTypes,
 } from '../types/tunnelbroker/peer-to-peer-message-types.js';
 import { getConfig } from '../utils/config.js';
 import { getMessageForException } from '../utils/errors.js';
 import { useDispatch, useSelector } from '../utils/redux-utils.js';
 
 type PeerToPeerContextType = {
   +processOutboundMessages: (
     outboundMessageIDs: ?$ReadOnlyArray<string>,
     dmOpID: ?string,
   ) => void,
   +sendDMOperation: (op: DMOperationSpecification) => Promise<void>,
   +broadcastEphemeralMessage: (
     contentPayload: string,
     recipients: $ReadOnlyArray<{ +userID: string, +deviceID: string }>,
     authMetadata: AuthMetadata,
   ) => Promise<void>,
 };
 
 const PeerToPeerContext: React.Context<?PeerToPeerContextType> =
   React.createContext<?PeerToPeerContextType>();
 
 type Props = {
   +children: React.Node,
 };
 
 async function processOutboundP2PMessages(
   sendMessage: (
     message: TunnelbrokerClientMessageToDevice,
     messageID: ?string,
   ) => Promise<void>,
   identityContext: IdentityClientContextType,
   peerOlmSessionsCreator: (userID: string, deviceID: string) => Promise<void>,
   messageIDs: ?$ReadOnlyArray<string>,
 ): Promise<void> {
   const authMetadata = await identityContext.getAuthMetadata();
   if (
     !authMetadata.deviceID ||
     !authMetadata.userID ||
     !authMetadata.accessToken
   ) {
     return;
   }
 
   const { olmAPI, sqliteAPI } = getConfig();
   await olmAPI.initializeCryptoAccount();
   let messages;
   if (messageIDs) {
     messages = await sqliteAPI.getOutboundP2PMessagesByID(messageIDs);
   } else {
     const allMessages = await sqliteAPI.getAllOutboundP2PMessages();
     messages = allMessages.filter(message => message.supportsAutoRetry);
   }
 
   const devicesMap: { [deviceID: string]: OutboundP2PMessage[] } = {};
   for (const message: OutboundP2PMessage of messages) {
     if (!devicesMap[message.deviceID]) {
       devicesMap[message.deviceID] = [message];
     } else {
       devicesMap[message.deviceID].push(message);
     }
   }
 
   const sendMessageToPeer = async (
     message: OutboundP2PMessage,
   ): Promise<void> => {
     if (!authMetadata.deviceID || !authMetadata.userID) {
       return;
     }
     const encryptedMessage: EncryptedMessage = {
       type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
       senderInfo: {
         deviceID: authMetadata.deviceID,
         userID: authMetadata.userID,
       },
       encryptedData: JSON.parse(message.ciphertext),
     };
     await sendMessage(
       {
         deviceID: message.deviceID,
         payload: JSON.stringify(encryptedMessage),
       },
       message.messageID,
     );
     await sqliteAPI.markOutboundP2PMessageAsSent(
       message.messageID,
       message.deviceID,
     );
   };
 
   for (const peerDeviceID in devicesMap) {
     for (const message of devicesMap[peerDeviceID]) {
       if (message.status === outboundP2PMessageStatuses.persisted) {
         try {
           const result = await olmAPI.encryptAndPersist(
             message.plaintext,
             message.deviceID,
             message.messageID,
           );
 
           const encryptedMessage: OutboundP2PMessage = {
             ...message,
             ciphertext: JSON.stringify(result),
           };
           await sendMessageToPeer(encryptedMessage);
         } catch (e) {
           try {
             await peerOlmSessionsCreator(message.userID, peerDeviceID);
             const result = await olmAPI.encryptAndPersist(
               message.plaintext,
               message.deviceID,
               message.messageID,
             );
             const encryptedMessage: OutboundP2PMessage = {
               ...message,
               ciphertext: JSON.stringify(result),
             };
 
             await sendMessageToPeer(encryptedMessage);
           } catch (err) {
             console.log(`Error sending messages to peer ${peerDeviceID}`, err);
             break;
           }
         }
       } else if (message.status === outboundP2PMessageStatuses.encrypted) {
         await sendMessageToPeer(message);
       }
     }
   }
 }
 
 const AUTOMATIC_RETRY_FREQUENCY = 30 * 1000;
 
 function PeerToPeerProvider(props: Props): React.Node {
   const { children } = props;
 
   const { sendMessageToDevice } = useTunnelbroker();
   const identityContext = React.useContext(IdentityClientContext);
   invariant(identityContext, 'Identity context should be set');
 
   const dispatch = useDispatch();
   const dmOpsSendingPromiseResolvers = React.useRef<
     Map<string, { +resolve: () => mixed, +reject: Error => mixed }>,
   >(new Map());
-  const auxUserStore = useSelector(state => state.auxUserStore);
+  const allPeerUserIDAndDeviceIDs = useSelector(getAllPeerUserIDAndDeviceIDs);
   const currentUserInfo = useSelector(state => state.currentUserInfo);
 
   const sendDMOperation = React.useCallback(
     async (op: DMOperationSpecification) => {
       const dmOpID = uuid.v4();
       const promise = new Promise<void>((resolve, reject) => {
         dmOpsSendingPromiseResolvers.current.set(dmOpID, { resolve, reject });
       });
 
       const messages = await createMessagesToPeersFromDMOp(
         op,
-        auxUserStore,
+        allPeerUserIDAndDeviceIDs,
         currentUserInfo,
       );
       dispatch({
         type: scheduleP2PMessagesActionType,
         payload: {
           dmOpID,
           messages,
         },
       });
 
       return promise;
     },
-    [auxUserStore, currentUserInfo, dispatch],
+    [allPeerUserIDAndDeviceIDs, currentUserInfo, dispatch],
   );
 
   const processingQueue = React.useRef<
     Array<{
       +outboundMessageIDs: ?$ReadOnlyArray<string>,
       +dmOpID: ?string,
     }>,
   >([]);
   const promiseRunning = React.useRef<boolean>(false);
 
   const { createOlmSessionsWithPeer: peerOlmSessionsCreator } =
     usePeerOlmSessionsCreatorContext();
 
   const processOutboundMessages = React.useCallback(
     (outboundMessageIDs: ?$ReadOnlyArray<string>, dmOpID: ?string) => {
       processingQueue.current.push({ outboundMessageIDs, dmOpID });
       if (!promiseRunning.current) {
         promiseRunning.current = true;
         void (async () => {
           do {
             const queueFront = processingQueue.current.shift();
             try {
               await processOutboundP2PMessages(
                 sendMessageToDevice,
                 identityContext,
                 peerOlmSessionsCreator,
                 queueFront?.outboundMessageIDs,
               );
               if (queueFront.dmOpID) {
                 dmOpsSendingPromiseResolvers.current
                   .get(queueFront.dmOpID)
                   ?.resolve?.();
               }
             } catch (e) {
               console.log(
                 `Error processing outbound P2P messages: ${
                   getMessageForException(e) ?? 'unknown'
                 }`,
               );
               if (queueFront.dmOpID) {
                 dmOpsSendingPromiseResolvers.current
                   .get(queueFront.dmOpID)
                   ?.reject?.(e);
               }
             } finally {
               if (queueFront.dmOpID) {
                 dmOpsSendingPromiseResolvers.current.delete(queueFront.dmOpID);
               }
             }
           } while (processingQueue.current.length > 0);
           promiseRunning.current = false;
         })();
       }
     },
     [peerOlmSessionsCreator, identityContext, sendMessageToDevice],
   );
 
   const broadcastEphemeralMessage = React.useCallback(
     async (
       contentPayload: string,
       recipients: $ReadOnlyArray<{ +userID: string, +deviceID: string }>,
       authMetadata: AuthMetadata,
     ) => {
       const { userID: thisUserID, deviceID: thisDeviceID } = authMetadata;
       if (!thisDeviceID || !thisUserID) {
         throw new Error('No auth metadata');
       }
       const { olmAPI } = getConfig();
       await olmAPI.initializeCryptoAccount();
 
       // We want it distinct by device ID to avoid potentially creating
       // multiple Olm sessions with the same device simultaneously.
       const recipientsDistinctByDeviceID = [
         ...new Map(recipients.map(item => [item.deviceID, item])).values(),
       ];
       const senderInfo = { deviceID: thisDeviceID, userID: thisUserID };
       const promises = recipientsDistinctByDeviceID.map(async recipient => {
         try {
           const encryptedData = await olmAPI.encrypt(
             contentPayload,
             recipient.deviceID,
           );
           const encryptedMessage: EncryptedMessage = {
             type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
             senderInfo,
             encryptedData,
           };
           await sendMessageToDevice({
             deviceID: recipient.deviceID,
             payload: JSON.stringify(encryptedMessage),
           });
         } catch {
           try {
             await peerOlmSessionsCreator(recipient.userID, recipient.deviceID);
             const encryptedData = await olmAPI.encrypt(
               contentPayload,
               recipient.deviceID,
             );
             const encryptedMessage: EncryptedMessage = {
               type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
               senderInfo,
               encryptedData,
             };
             await sendMessageToDevice({
               deviceID: recipient.deviceID,
               payload: JSON.stringify(encryptedMessage),
             });
           } catch (err) {
             console.warn(
               `Error sending Olm-encrypted message to device ${recipient.deviceID}:`,
               err,
             );
           }
         }
       });
       await Promise.all(promises);
     },
     [peerOlmSessionsCreator, sendMessageToDevice],
   );
 
   React.useEffect(() => {
     const intervalID = setInterval(
       processOutboundMessages,
       AUTOMATIC_RETRY_FREQUENCY,
     );
     return () => clearInterval(intervalID);
   }, [processOutboundMessages]);
 
   const value: PeerToPeerContextType = React.useMemo(
     () => ({
       processOutboundMessages,
       sendDMOperation,
       broadcastEphemeralMessage,
     }),
     [broadcastEphemeralMessage, processOutboundMessages, sendDMOperation],
   );
 
   return (
     <PeerToPeerContext.Provider value={value}>
       {children}
     </PeerToPeerContext.Provider>
   );
 }
 
 function usePeerToPeerCommunication(): PeerToPeerContextType {
   const context = React.useContext(PeerToPeerContext);
   invariant(context, 'PeerToPeerContext not found');
 
   return context;
 }
 
 export { PeerToPeerProvider, usePeerToPeerCommunication };