diff --git a/lib/selectors/socket-selectors.js b/lib/selectors/socket-selectors.js
index 8254bcb59..2a14e451d 100644
--- a/lib/selectors/socket-selectors.js
+++ b/lib/selectors/socket-selectors.js
@@ -1,240 +1,253 @@
 // @flow
 
 import { createSelector } from 'reselect';
 import t from 'tcomb';
 
 import { currentCalendarQuery } from './nav-selectors.js';
 import {
   serverEntryInfo,
   serverEntryInfosObject,
   filterRawEntryInfosByCalendarQuery,
 } from '../shared/entry-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type { SignedIdentityKeysBlob } from '../types/crypto-types.js';
 import {
   type RawEntryInfo,
   rawEntryInfoValidator,
   type CalendarQuery,
 } from '../types/entry-types.js';
 import type { AppState } from '../types/redux-types.js';
 import type { ClientReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   type ClientServerRequest,
   type ClientClientResponse,
 } from '../types/request-types.js';
 import type { SessionState } from '../types/session-types.js';
 import type { OneTimeKeyGenerator } from '../types/socket-types.js';
 import {
   type RawThreadInfo,
   rawThreadInfoValidator,
 } from '../types/thread-types.js';
 import {
   type CurrentUserInfo,
   currentUserInfoValidator,
   type UserInfos,
   userInfosValidator,
 } from '../types/user-types.js';
 import { getConfig } from '../utils/config.js';
 import { minimumOneTimeKeysRequired } from '../utils/crypto-utils.js';
 import { values, hash } from '../utils/objects.js';
 import {
   tID,
   convertClientIDsToServerIDs,
   keyserverPrefixID,
   convertToNewIDSchema,
 } from '../utils/validation-utils.js';
 
 const queuedReports: (
   state: AppState,
 ) => $ReadOnlyArray<ClientReportCreationRequest> = createSelector(
   (state: AppState) => state.reportStore.queuedReports,
   (
     mainQueuedReports: $ReadOnlyArray<ClientReportCreationRequest>,
   ): $ReadOnlyArray<ClientReportCreationRequest> => mainQueuedReports,
 );
 
 const getClientResponsesSelector: (
   state: AppState,
 ) => (
   calendarActive: boolean,
   oneTimeKeyGenerator: ?OneTimeKeyGenerator,
   getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
+  getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
   (state: AppState) => state.threadStore.threadInfos,
   (state: AppState) => state.entryStore.entryInfos,
   (state: AppState) => state.userStore.userInfos,
   (state: AppState) => state.currentUserInfo,
   currentCalendarQuery,
   (
       threadInfos: { +[id: string]: RawThreadInfo },
       entryInfos: { +[id: string]: RawEntryInfo },
       userInfos: UserInfos,
       currentUserInfo: ?CurrentUserInfo,
       calendarQuery: (calendarActive: boolean) => CalendarQuery,
     ) =>
     async (
       calendarActive: boolean,
       oneTimeKeyGenerator: ?OneTimeKeyGenerator,
       getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
+      getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
       serverRequests: $ReadOnlyArray<ClientServerRequest>,
     ): Promise<$ReadOnlyArray<ClientClientResponse>> => {
       const clientResponses = [];
       const serverRequestedPlatformDetails = serverRequests.some(
         request => request.type === serverRequestTypes.PLATFORM_DETAILS,
       );
       for (const serverRequest of serverRequests) {
         if (
           serverRequest.type === serverRequestTypes.PLATFORM &&
           !serverRequestedPlatformDetails
         ) {
           clientResponses.push({
             type: serverRequestTypes.PLATFORM,
             platform: getConfig().platformDetails.platform,
           });
         } else if (serverRequest.type === serverRequestTypes.PLATFORM_DETAILS) {
           clientResponses.push({
             type: serverRequestTypes.PLATFORM_DETAILS,
             platformDetails: getConfig().platformDetails,
           });
         } else if (serverRequest.type === serverRequestTypes.CHECK_STATE) {
           let filteredEntryInfos = filterRawEntryInfosByCalendarQuery(
             serverEntryInfosObject(values(entryInfos)),
             calendarQuery(calendarActive),
           );
 
           if (convertToNewIDSchema) {
             threadInfos = convertClientIDsToServerIDs(
               keyserverPrefixID,
               t.dict(tID, rawThreadInfoValidator),
               threadInfos,
             );
             userInfos = convertClientIDsToServerIDs(
               keyserverPrefixID,
               userInfosValidator,
               userInfos,
             );
             currentUserInfo = convertClientIDsToServerIDs(
               keyserverPrefixID,
               t.maybe(currentUserInfoValidator),
               currentUserInfo,
             );
             filteredEntryInfos = convertClientIDsToServerIDs(
               keyserverPrefixID,
               t.dict(tID, rawEntryInfoValidator),
               filteredEntryInfos,
             );
           }
 
           const hashResults = {};
           for (const key in serverRequest.hashesToCheck) {
             const expectedHashValue = serverRequest.hashesToCheck[key];
             let hashValue;
             if (key === 'threadInfos') {
               hashValue = hash(threadInfos);
             } else if (key === 'entryInfos') {
               hashValue = hash(filteredEntryInfos);
             } else if (key === 'userInfos') {
               hashValue = hash(userInfos);
             } else if (key === 'currentUserInfo') {
               hashValue = hash(currentUserInfo);
             } else if (key.startsWith('threadInfo|')) {
               const [, threadID] = key.split('|');
               hashValue = hash(threadInfos[threadID]);
             } else if (key.startsWith('entryInfo|')) {
               const [, entryID] = key.split('|');
               let rawEntryInfo = filteredEntryInfos[entryID];
               if (rawEntryInfo) {
                 rawEntryInfo = serverEntryInfo(rawEntryInfo);
               }
               hashValue = hash(rawEntryInfo);
             } else if (key.startsWith('userInfo|')) {
               const [, userID] = key.split('|');
               hashValue = hash(userInfos[userID]);
             } else {
               continue;
             }
             hashResults[key] = expectedHashValue === hashValue;
           }
 
           const { failUnmentioned } = serverRequest;
           if (failUnmentioned && failUnmentioned.threadInfos) {
             for (const threadID in threadInfos) {
               const key = `threadInfo|${threadID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
           if (failUnmentioned && failUnmentioned.entryInfos) {
             for (const entryID in filteredEntryInfos) {
               const key = `entryInfo|${entryID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
           if (failUnmentioned && failUnmentioned.userInfos) {
             for (const userID in userInfos) {
               const key = `userInfo|${userID}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
 
           clientResponses.push({
             type: serverRequestTypes.CHECK_STATE,
             hashResults,
           });
         } else if (
           serverRequest.type === serverRequestTypes.MORE_ONE_TIME_KEYS &&
           oneTimeKeyGenerator
         ) {
           const keys: string[] = [];
           for (let i = 0; i < minimumOneTimeKeysRequired; ++i) {
             keys.push(oneTimeKeyGenerator(i));
           }
           clientResponses.push({
             type: serverRequestTypes.MORE_ONE_TIME_KEYS,
             keys,
           });
         } else if (
           serverRequest.type === serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB &&
           getSignedIdentityKeysBlob
         ) {
           const signedIdentityKeysBlob = await getSignedIdentityKeysBlob();
           clientResponses.push({
             type: serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB,
             signedIdentityKeysBlob,
           });
+        } else if (
+          serverRequest.type ===
+            serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE &&
+          getInitialNotificationsEncryptedMessage
+        ) {
+          const initialNotificationsEncryptedMessage =
+            await getInitialNotificationsEncryptedMessage();
+          clientResponses.push({
+            type: serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE,
+            initialNotificationsEncryptedMessage,
+          });
         }
       }
       return clientResponses;
     },
 );
 
 const sessionStateFuncSelector: (
   state: AppState,
 ) => (calendarActive: boolean) => SessionState = createSelector(
   (state: AppState) => state.messageStore.currentAsOf,
   (state: AppState) => state.updatesCurrentAsOf,
   currentCalendarQuery,
   (
       messagesCurrentAsOf: number,
       updatesCurrentAsOf: number,
       calendarQuery: (calendarActive: boolean) => CalendarQuery,
     ) =>
     (calendarActive: boolean): SessionState => ({
       calendarQuery: calendarQuery(calendarActive),
       messagesCurrentAsOf,
       updatesCurrentAsOf,
       watchedIDs: threadWatcher.getWatchedIDs(),
     }),
 );
 
 export { queuedReports, getClientResponsesSelector, sessionStateFuncSelector };
diff --git a/native/selectors/socket-selectors.js b/native/selectors/socket-selectors.js
index 569279bc3..52a9dda1a 100644
--- a/native/selectors/socket-selectors.js
+++ b/native/selectors/socket-selectors.js
@@ -1,108 +1,120 @@
 // @flow
 
 import { createSelector } from 'reselect';
 
 import {
   getClientResponsesSelector,
   sessionStateFuncSelector,
 } from 'lib/selectors/socket-selectors.js';
 import { createOpenSocketFunction } from 'lib/shared/socket-utils.js';
 import type { SignedIdentityKeysBlob } from 'lib/types/crypto-types.js';
 import type {
   ClientServerRequest,
   ClientClientResponse,
 } from 'lib/types/request-types.js';
 import type {
   SessionIdentification,
   SessionState,
 } from 'lib/types/session-types.js';
 import type { OneTimeKeyGenerator } from 'lib/types/socket-types.js';
 
 import { commCoreModule } from '../native-modules.js';
 import { calendarActiveSelector } from '../navigation/nav-selectors.js';
 import type { AppState } from '../redux/state-types.js';
 import type { NavPlusRedux } from '../types/selector-types.js';
 
 const openSocketSelector: (state: AppState) => () => WebSocket = createSelector(
   (state: AppState) => state.urlPrefix,
   // We don't actually use the cookie in the socket open function, but we do use
   // it in the initial message, and when the cookie changes the socket needs to
   // be reopened. By including the cookie here, whenever the cookie changes this
   // function will change, which tells the Socket component to restart the
   // connection.
   (state: AppState) => state.cookie,
   createOpenSocketFunction,
 );
 
 const sessionIdentificationSelector: (
   state: AppState,
 ) => SessionIdentification = createSelector(
   (state: AppState) => state.cookie,
   (cookie: ?string): SessionIdentification => ({ cookie }),
 );
 
 function oneTimeKeyGenerator(inc: number): string {
   // todo replace this hard code with something like
   // commCoreModule.generateOneTimeKeys()
   let str = Date.now().toString() + '_' + inc.toString() + '_';
   while (str.length < 43) {
     str += Math.random().toString(36).substr(2, 5);
   }
   str = str.substr(0, 43);
   return str;
 }
 
 async function getSignedIdentityKeysBlob(): Promise<SignedIdentityKeysBlob> {
   await commCoreModule.initializeCryptoAccount();
   const { blobPayload, signature } = await commCoreModule.getUserPublicKey();
   const signedIdentityKeysBlob: SignedIdentityKeysBlob = {
     payload: blobPayload,
     signature,
   };
   return signedIdentityKeysBlob;
 }
 
+type NativeGetClientResponsesSelectorInputType = {
+  ...NavPlusRedux,
+  getInitialNotificationsEncryptedMessage: () => Promise<string>,
+};
+
 const nativeGetClientResponsesSelector: (
-  input: NavPlusRedux,
+  input: NativeGetClientResponsesSelectorInputType,
 ) => (
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
-  (input: NavPlusRedux) => getClientResponsesSelector(input.redux),
-  (input: NavPlusRedux) => calendarActiveSelector(input.navContext),
+  (input: NativeGetClientResponsesSelectorInputType) =>
+    getClientResponsesSelector(input.redux),
+  (input: NativeGetClientResponsesSelectorInputType) =>
+    calendarActiveSelector(input.navContext),
+  (input: NativeGetClientResponsesSelectorInputType) =>
+    input.getInitialNotificationsEncryptedMessage,
   (
       getClientResponsesFunc: (
         calendarActive: boolean,
         oneTimeKeyGenerator: ?OneTimeKeyGenerator,
         getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
+        getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
         serverRequests: $ReadOnlyArray<ClientServerRequest>,
       ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
       calendarActive: boolean,
+      getInitialNotificationsEncryptedMessage: () => Promise<string>,
     ) =>
     (serverRequests: $ReadOnlyArray<ClientServerRequest>) =>
       getClientResponsesFunc(
         calendarActive,
         oneTimeKeyGenerator,
         getSignedIdentityKeysBlob,
+        getInitialNotificationsEncryptedMessage,
         serverRequests,
       ),
 );
 
 const nativeSessionStateFuncSelector: (
   input: NavPlusRedux,
 ) => () => SessionState = createSelector(
   (input: NavPlusRedux) => sessionStateFuncSelector(input.redux),
   (input: NavPlusRedux) => calendarActiveSelector(input.navContext),
   (
       sessionStateFunc: (calendarActive: boolean) => SessionState,
       calendarActive: boolean,
     ) =>
     () =>
       sessionStateFunc(calendarActive),
 );
 
 export {
   openSocketSelector,
   sessionIdentificationSelector,
   nativeGetClientResponsesSelector,
   nativeSessionStateFuncSelector,
 };
diff --git a/native/socket.react.js b/native/socket.react.js
index 64fb1336f..c6faa77b1 100644
--- a/native/socket.react.js
+++ b/native/socket.react.js
@@ -1,155 +1,157 @@
 // @flow
 
 import * as React from 'react';
 import Alert from 'react-native/Libraries/Alert/Alert.js';
 import { useDispatch } from 'react-redux';
 
 import { logOut, logOutActionTypes } from 'lib/actions/user-actions.js';
 import { preRequestUserStateSelector } from 'lib/selectors/account-selectors.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { accountHasPassword } from 'lib/shared/account-utils.js';
 import Socket, { type BaseSocketProps } from 'lib/socket/socket.react.js';
 import { logInActionSources } from 'lib/types/account-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
   fetchNewCookieFromNativeCredentials,
 } from 'lib/utils/action-utils.js';
 
 import { InputStateContext } from './input/input-state.js';
 import {
   activeMessageListSelector,
   nativeCalendarQuery,
 } from './navigation/nav-selectors.js';
 import { NavContext } from './navigation/navigation-context.js';
 import { useSelector } from './redux/redux-utils.js';
 import { noDataAfterPolicyAcknowledgmentSelector } from './selectors/account-selectors.js';
 import {
   openSocketSelector,
   sessionIdentificationSelector,
   nativeGetClientResponsesSelector,
   nativeSessionStateFuncSelector,
 } from './selectors/socket-selectors.js';
 import { useInitialNotificationsEncryptedMessage } from './utils/crypto-utils.js';
 
 const NativeSocket: React.ComponentType<BaseSocketProps> =
   React.memo<BaseSocketProps>(function NativeSocket(props: BaseSocketProps) {
     const inputState = React.useContext(InputStateContext);
     const navContext = React.useContext(NavContext);
 
     const cookie = useSelector(state => state.cookie);
     const urlPrefix = useSelector(state => state.urlPrefix);
     const connection = useSelector(state => state.connection);
     const frozen = useSelector(state => state.frozen);
     const active = useSelector(
       state => isLoggedIn(state) && state.lifecycleState !== 'background',
     );
     const noDataAfterPolicyAcknowledgment = useSelector(
       noDataAfterPolicyAcknowledgmentSelector,
     );
     const currentUserInfo = useSelector(state => state.currentUserInfo);
 
     const openSocket = useSelector(openSocketSelector);
     const sessionIdentification = useSelector(sessionIdentificationSelector);
     const preRequestUserState = useSelector(preRequestUserStateSelector);
 
+    const getInitialNotificationsEncryptedMessage =
+      useInitialNotificationsEncryptedMessage();
+
     const getClientResponses = useSelector(state =>
       nativeGetClientResponsesSelector({
         redux: state,
         navContext,
+        getInitialNotificationsEncryptedMessage,
       }),
     );
     const sessionStateFunc = useSelector(state =>
       nativeSessionStateFuncSelector({
         redux: state,
         navContext,
       }),
     );
     const currentCalendarQuery = useSelector(state =>
       nativeCalendarQuery({
         redux: state,
         navContext,
       }),
     );
 
     const canSendReports = useSelector(
       state =>
         !state.frozen &&
         state.connectivity.hasWiFi &&
         (!inputState || !inputState.uploadInProgress()),
     );
 
     const activeThread = React.useMemo(() => {
       if (!active) {
         return null;
       }
       return activeMessageListSelector(navContext);
     }, [active, navContext]);
 
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const callLogOut = useServerCall(logOut);
-    const getInitialNotificationsEncryptedMessage =
-      useInitialNotificationsEncryptedMessage();
 
     const socketCrashLoopRecovery = React.useCallback(async () => {
       if (!accountHasPassword(currentUserInfo)) {
         dispatchActionPromise(
           logOutActionTypes,
           callLogOut(preRequestUserState),
         );
         Alert.alert(
           'Log in needed',
           'After acknowledging the policies, we need you to log in to your account again',
           [{ text: 'OK' }],
         );
         return;
       }
 
       await fetchNewCookieFromNativeCredentials(
         dispatch,
         cookie,
         urlPrefix,
         logInActionSources.refetchUserDataAfterAcknowledgment,
         getInitialNotificationsEncryptedMessage,
       );
     }, [
       callLogOut,
       cookie,
       currentUserInfo,
       dispatch,
       dispatchActionPromise,
       preRequestUserState,
       urlPrefix,
       getInitialNotificationsEncryptedMessage,
     ]);
 
     return (
       <Socket
         {...props}
         active={active}
         openSocket={openSocket}
         getClientResponses={getClientResponses}
         activeThread={activeThread}
         sessionStateFunc={sessionStateFunc}
         sessionIdentification={sessionIdentification}
         cookie={cookie}
         urlPrefix={urlPrefix}
         connection={connection}
         currentCalendarQuery={currentCalendarQuery}
         canSendReports={canSendReports}
         frozen={frozen}
         preRequestUserState={preRequestUserState}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         logOut={callLogOut}
         noDataAfterPolicyAcknowledgment={noDataAfterPolicyAcknowledgment}
         socketCrashLoopRecovery={socketCrashLoopRecovery}
         getInitialNotificationsEncryptedMessage={
           getInitialNotificationsEncryptedMessage
         }
       />
     );
   });
 
 export default NativeSocket;
diff --git a/web/selectors/socket-selectors.js b/web/selectors/socket-selectors.js
index a556f90d9..d0ca97c35 100644
--- a/web/selectors/socket-selectors.js
+++ b/web/selectors/socket-selectors.js
@@ -1,126 +1,128 @@
 // @flow
 
 import olm from '@commapp/olm';
 import { createSelector } from 'reselect';
 
 import {
   getClientResponsesSelector,
   sessionStateFuncSelector,
 } from 'lib/selectors/socket-selectors.js';
 import { createOpenSocketFunction } from 'lib/shared/socket-utils.js';
 import type {
   OLMIdentityKeys,
   PickledOLMAccount,
   SignedIdentityKeysBlob,
   IdentityKeysBlob,
 } from 'lib/types/crypto-types.js';
 import type {
   ClientServerRequest,
   ClientClientResponse,
 } from 'lib/types/request-types.js';
 import type {
   SessionIdentification,
   SessionState,
 } from 'lib/types/session-types.js';
 import type { OneTimeKeyGenerator } from 'lib/types/socket-types.js';
 
 import { initOlm } from '../olm/olm-utils.js';
 import type { AppState } from '../redux/redux-setup.js';
 
 const openSocketSelector: (state: AppState) => () => WebSocket = createSelector(
   (state: AppState) => state.baseHref,
   createOpenSocketFunction,
 );
 
 const sessionIdentificationSelector: (
   state: AppState,
 ) => SessionIdentification = createSelector(
   (state: AppState) => state.sessionID,
   (sessionID: ?string): SessionIdentification => ({ sessionID }),
 );
 
 const getSignedIdentityKeysBlobSelector: (
   state: AppState,
 ) => ?() => Promise<SignedIdentityKeysBlob> = createSelector(
   (state: AppState) => state.cryptoStore.primaryAccount,
   (state: AppState) => state.cryptoStore.primaryIdentityKeys,
   (state: AppState) => state.cryptoStore.notificationIdentityKeys,
   (
     primaryAccount: ?PickledOLMAccount,
     primaryIdentityKeys: ?OLMIdentityKeys,
     notificationIdentityKeys: ?OLMIdentityKeys,
   ) => {
     if (!primaryAccount || !primaryIdentityKeys || !notificationIdentityKeys) {
       return null;
     }
 
     return async () => {
       await initOlm();
       const primaryOLMAccount = new olm.Account();
       primaryOLMAccount.unpickle(
         primaryAccount.picklingKey,
         primaryAccount.pickledAccount,
       );
 
       const identityKeysBlob: IdentityKeysBlob = {
         primaryIdentityPublicKeys: primaryIdentityKeys,
         notificationIdentityPublicKeys: notificationIdentityKeys,
       };
 
       const payloadToBeSigned: string = JSON.stringify(identityKeysBlob);
       const signedIdentityKeysBlob: SignedIdentityKeysBlob = {
         payload: payloadToBeSigned,
         signature: primaryOLMAccount.sign(payloadToBeSigned),
       };
 
       return signedIdentityKeysBlob;
     };
   },
 );
 
 const webGetClientResponsesSelector: (
   state: AppState,
 ) => (
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
   getClientResponsesSelector,
   getSignedIdentityKeysBlobSelector,
   (state: AppState) => state.navInfo.tab === 'calendar',
   (
       getClientResponsesFunc: (
         calendarActive: boolean,
         oneTimeKeyGenerator: ?OneTimeKeyGenerator,
         getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
+        getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
         serverRequests: $ReadOnlyArray<ClientServerRequest>,
       ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
       getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
       calendarActive: boolean,
     ) =>
     (serverRequests: $ReadOnlyArray<ClientServerRequest>) =>
       getClientResponsesFunc(
         calendarActive,
         null,
         getSignedIdentityKeysBlob,
+        null,
         serverRequests,
       ),
 );
 
 const webSessionStateFuncSelector: (state: AppState) => () => SessionState =
   createSelector(
     sessionStateFuncSelector,
     (state: AppState) => state.navInfo.tab === 'calendar',
     (
         sessionStateFunc: (calendarActive: boolean) => SessionState,
         calendarActive: boolean,
       ) =>
       () =>
         sessionStateFunc(calendarActive),
   );
 
 export {
   openSocketSelector,
   sessionIdentificationSelector,
   getSignedIdentityKeysBlobSelector,
   webGetClientResponsesSelector,
   webSessionStateFuncSelector,
 };