diff --git a/lib/types/crypto-types.js b/lib/types/crypto-types.js
--- a/lib/types/crypto-types.js
+++ b/lib/types/crypto-types.js
@@ -25,13 +25,15 @@
   +pickledAccount: string,
 };
 
-export type CryptoStore = {
-  +primaryAccount: ?PickledOLMAccount,
-  +primaryIdentityKeys: ?OLMIdentityKeys,
-  +notificationAccount: ?PickledOLMAccount,
-  +notificationIdentityKeys: ?OLMIdentityKeys,
+export type CompleteCryptoStore = {
+  +primaryAccount: PickledOLMAccount,
+  +primaryIdentityKeys: OLMIdentityKeys,
+  +notificationAccount: PickledOLMAccount,
+  +notificationIdentityKeys: OLMIdentityKeys,
 };
 
+export type CryptoStore = $ObjMap<CompleteCryptoStore, <T>(T) => ?T>;
+
 export type IdentityKeysBlob = {
   +primaryIdentityPublicKeys: OLMIdentityKeys,
   +notificationIdentityPublicKeys: OLMIdentityKeys,
diff --git a/web/account/account-hooks.js b/web/account/account-hooks.js
--- a/web/account/account-hooks.js
+++ b/web/account/account-hooks.js
@@ -1,35 +1,186 @@
 // @flow
 
+import olm from '@commapp/olm';
+import invariant from 'invariant';
 import * as React from 'react';
+import { useDispatch } from 'react-redux';
+import uuid from 'uuid';
 
-import type { SignedIdentityKeysBlob } from 'lib/types/crypto-types.js';
+import type {
+  SignedIdentityKeysBlob,
+  CompleteCryptoStore,
+  IdentityKeysBlob,
+} from 'lib/types/crypto-types.js';
 
+import { initOlm } from '../olm/olm-utils.js';
+import {
+  setPrimaryIdentityKeys,
+  setNotificationIdentityKeys,
+  setPickledPrimaryAccount,
+  setPickledNotificationAccount,
+} from '../redux/crypto-store-reducer.js';
 import { useSelector } from '../redux/redux-utils.js';
-import { getSignedIdentityKeysBlobSelector } from '../selectors/socket-selectors.js';
-
-function useSignedIdentityKeysBlob(): ?SignedIdentityKeysBlob {
-  const getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob> =
-    useSelector(getSignedIdentityKeysBlobSelector);
-
-  const [signedIdentityKeysBlob, setSignedIdentityKeysBlob] =
-    React.useState<?SignedIdentityKeysBlob>(null);
-
-  React.useEffect(() => {
-    (async () => {
-      if (
-        getSignedIdentityKeysBlob === null ||
-        getSignedIdentityKeysBlob === undefined
-      ) {
-        setSignedIdentityKeysBlob(null);
-        return;
-      }
-      const resolvedSignedIdentityKeysBlob: SignedIdentityKeysBlob =
-        await getSignedIdentityKeysBlob();
-      setSignedIdentityKeysBlob(resolvedSignedIdentityKeysBlob);
+
+const GetOrCreateCryptoStoreContext: React.Context<?() => Promise<CompleteCryptoStore>> =
+  React.createContext(null);
+
+type Props = {
+  +children: React.Node,
+};
+
+function GetOrCreateCryptoStoreProvider(props: Props): React.Node {
+  const dispatch = useDispatch();
+  const currentCryptoStore = useSelector(state => state.cryptoStore);
+  const createCryptoStorePromiseRef =
+    React.useRef<?Promise<CompleteCryptoStore>>(null);
+
+  const value = React.useCallback(async () => {
+    if (
+      currentCryptoStore.primaryAccount &&
+      currentCryptoStore.primaryIdentityKeys &&
+      currentCryptoStore.notificationAccount &&
+      currentCryptoStore.notificationIdentityKeys
+    ) {
+      return {
+        primaryAccount: currentCryptoStore.primaryAccount,
+        primaryIdentityKeys: currentCryptoStore.primaryIdentityKeys,
+        notificationAccount: currentCryptoStore.notificationAccount,
+        notificationIdentityKeys: currentCryptoStore.notificationIdentityKeys,
+      };
+    }
+
+    const currentCreateCryptoStorePromiseRef =
+      createCryptoStorePromiseRef.current;
+
+    if (currentCreateCryptoStorePromiseRef) {
+      return currentCreateCryptoStorePromiseRef;
+    }
+
+    const newCreateCryptoStorePromise = (async () => {
+      await initOlm();
+
+      const identityAccount = new olm.Account();
+      identityAccount.create();
+      const { ed25519: identityED25519, curve25519: identityCurve25519 } =
+        JSON.parse(identityAccount.identity_keys());
+
+      dispatch({
+        type: setPrimaryIdentityKeys,
+        payload: { ed25519: identityED25519, curve25519: identityCurve25519 },
+      });
+
+      const identityAccountPicklingKey = uuid.v4();
+      const pickledIdentityAccount = identityAccount.pickle(
+        identityAccountPicklingKey,
+      );
+
+      dispatch({
+        type: setPickledPrimaryAccount,
+        payload: {
+          picklingKey: identityAccountPicklingKey,
+          pickledAccount: pickledIdentityAccount,
+        },
+      });
+
+      const notificationAccount = new olm.Account();
+      notificationAccount.create();
+      const {
+        ed25519: notificationED25519,
+        curve25519: notificationCurve25519,
+      } = JSON.parse(notificationAccount.identity_keys());
+
+      dispatch({
+        type: setNotificationIdentityKeys,
+        payload: {
+          ed25519: notificationED25519,
+          curve25519: notificationCurve25519,
+        },
+      });
+
+      const notificationAccountPicklingKey = uuid.v4();
+      const pickledNotificationAccount = notificationAccount.pickle(
+        notificationAccountPicklingKey,
+      );
+
+      dispatch({
+        type: setPickledNotificationAccount,
+        payload: {
+          picklingKey: notificationAccountPicklingKey,
+          pickledAccount: pickledNotificationAccount,
+        },
+      });
+
+      createCryptoStorePromiseRef.current = null;
+
+      return {
+        primaryAccount: {
+          picklingKey: identityAccountPicklingKey,
+          pickledAccount: pickledIdentityAccount,
+        },
+        primaryIdentityKeys: {
+          ed25519: identityED25519,
+          curve25519: identityCurve25519,
+        },
+        notificationAccount: {
+          picklingKey: notificationAccountPicklingKey,
+          pickledAccount: pickledNotificationAccount,
+        },
+        notificationIdentityKeys: {
+          ed25519: notificationED25519,
+          curve25519: notificationCurve25519,
+        },
+      };
     })();
-  }, [getSignedIdentityKeysBlob]);
 
-  return signedIdentityKeysBlob;
+    createCryptoStorePromiseRef.current = newCreateCryptoStorePromise;
+    return newCreateCryptoStorePromise;
+  }, [dispatch, currentCryptoStore]);
+
+  return (
+    <GetOrCreateCryptoStoreContext.Provider value={value}>
+      {props.children}
+    </GetOrCreateCryptoStoreContext.Provider>
+  );
+}
+
+function useGetOrCreateCryptoStore(): () => Promise<CompleteCryptoStore> {
+  const context = React.useContext(GetOrCreateCryptoStoreContext);
+  invariant(context, 'GetOrCreateCryptoStoreContext not found');
+
+  return context;
+}
+
+function useGetSignedIdentityKeysBlob(): () => Promise<SignedIdentityKeysBlob> {
+  const getOrCreateCryptoStore = useGetOrCreateCryptoStore();
+
+  return React.useCallback(async () => {
+    const { primaryAccount, primaryIdentityKeys, notificationIdentityKeys } =
+      await getOrCreateCryptoStore();
+
+    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;
+  }, [getOrCreateCryptoStore]);
 }
 
-export { useSignedIdentityKeysBlob };
+export {
+  useGetSignedIdentityKeysBlob,
+  useGetOrCreateCryptoStore,
+  GetOrCreateCryptoStoreProvider,
+};
diff --git a/web/account/log-in-form.react.js b/web/account/log-in-form.react.js
--- a/web/account/log-in-form.react.js
+++ b/web/account/log-in-form.react.js
@@ -1,106 +1,33 @@
 // @flow
 
-import olm from '@commapp/olm';
 import { useConnectModal } from '@rainbow-me/rainbowkit';
 import * as React from 'react';
 import { useDispatch } from 'react-redux';
-import uuid from 'uuid';
 import { useWalletClient } from 'wagmi';
 
 import { isDev } from 'lib/utils/dev-utils.js';
 
+import { useGetOrCreateCryptoStore } from './account-hooks.js';
 import css from './log-in-form.css';
 import SIWEButton from './siwe-button.react.js';
 import SIWELoginForm from './siwe-login-form.react.js';
 import TraditionalLoginForm from './traditional-login-form.react.js';
 import Button from '../components/button.react.js';
 import OrBreak from '../components/or-break.react.js';
-import { initOlm } from '../olm/olm-utils.js';
 import { updateNavInfoActionType } from '../redux/action-types.js';
-import {
-  setPrimaryIdentityKeys,
-  setNotificationIdentityKeys,
-  setPickledPrimaryAccount,
-  setPickledNotificationAccount,
-} from '../redux/crypto-store-reducer.js';
-import { useSelector } from '../redux/redux-utils.js';
 
 function LoginForm(): React.Node {
   const { openConnectModal } = useConnectModal();
   const { data: signer } = useWalletClient();
   const dispatch = useDispatch();
 
-  const primaryIdentityPublicKeys = useSelector(
-    state => state.cryptoStore.primaryIdentityKeys,
-  );
-  const notificationIdentityPublicKeys = useSelector(
-    state => state.cryptoStore.notificationIdentityKeys,
-  );
+  const getOrCreateCryptoStore = useGetOrCreateCryptoStore();
 
   React.useEffect(() => {
     (async () => {
-      if (
-        primaryIdentityPublicKeys !== null &&
-        primaryIdentityPublicKeys !== undefined &&
-        notificationIdentityPublicKeys !== null &&
-        notificationIdentityPublicKeys !== undefined
-      ) {
-        return;
-      }
-      await initOlm();
-
-      const identityAccount = new olm.Account();
-      identityAccount.create();
-      const { ed25519: identityED25519, curve25519: identityCurve25519 } =
-        JSON.parse(identityAccount.identity_keys());
-
-      dispatch({
-        type: setPrimaryIdentityKeys,
-        payload: { ed25519: identityED25519, curve25519: identityCurve25519 },
-      });
-
-      const identityAccountPicklingKey = uuid.v4();
-      const pickledIdentityAccount = identityAccount.pickle(
-        identityAccountPicklingKey,
-      );
-
-      dispatch({
-        type: setPickledPrimaryAccount,
-        payload: {
-          picklingKey: identityAccountPicklingKey,
-          pickledAccount: pickledIdentityAccount,
-        },
-      });
-
-      const notificationAccount = new olm.Account();
-      notificationAccount.create();
-      const {
-        ed25519: notificationED25519,
-        curve25519: notificationCurve25519,
-      } = JSON.parse(notificationAccount.identity_keys());
-
-      dispatch({
-        type: setNotificationIdentityKeys,
-        payload: {
-          ed25519: notificationED25519,
-          curve25519: notificationCurve25519,
-        },
-      });
-
-      const notificationAccountPicklingKey = uuid.v4();
-      const pickledNotificationAccount = notificationAccount.pickle(
-        notificationAccountPicklingKey,
-      );
-
-      dispatch({
-        type: setPickledNotificationAccount,
-        payload: {
-          picklingKey: notificationAccountPicklingKey,
-          pickledAccount: pickledNotificationAccount,
-        },
-      });
+      await getOrCreateCryptoStore();
     })();
-  }, [dispatch, notificationIdentityPublicKeys, primaryIdentityPublicKeys]);
+  }, [getOrCreateCryptoStore]);
 
   const onQRCodeLoginButtonClick = React.useCallback(() => {
     dispatch({
diff --git a/web/account/siwe-login-form.react.js b/web/account/siwe-login-form.react.js
--- a/web/account/siwe-login-form.react.js
+++ b/web/account/siwe-login-form.react.js
@@ -19,10 +19,7 @@
 import stores from 'lib/facts/stores.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LogInStartingPayload } from 'lib/types/account-types.js';
-import type {
-  OLMIdentityKeys,
-  SignedIdentityKeysBlob,
-} from 'lib/types/crypto-types.js';
+import type { OLMIdentityKeys } from 'lib/types/crypto-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
@@ -34,7 +31,7 @@
   siweMessageSigningExplanationStatements,
 } from 'lib/utils/siwe-utils.js';
 
-import { useSignedIdentityKeysBlob } from './account-hooks.js';
+import { useGetSignedIdentityKeysBlob } from './account-hooks.js';
 import HeaderSeparator from './header-separator.react.js';
 import css from './siwe.css';
 import Button from '../components/button.react.js';
@@ -88,11 +85,11 @@
     state => state.cryptoStore.primaryIdentityKeys,
   );
 
-  const signedIdentityKeysBlob: ?SignedIdentityKeysBlob =
-    useSignedIdentityKeysBlob();
+  const getSignedIdentityKeysBlob = useGetSignedIdentityKeysBlob();
 
   const callSIWEAuthEndpoint = React.useCallback(
     async (message: string, signature: string, extraInfo) => {
+      const signedIdentityKeysBlob = await getSignedIdentityKeysBlob();
       invariant(
         signedIdentityKeysBlob,
         'signedIdentityKeysBlob must be set in attemptSIWEAuth',
@@ -115,7 +112,7 @@
         throw e;
       }
     },
-    [signedIdentityKeysBlob, siweAuthCall],
+    [getSignedIdentityKeysBlob, siweAuthCall],
   );
 
   const attemptSIWEAuth = React.useCallback(
@@ -186,8 +183,7 @@
   if (
     siweAuthLoadingStatus === 'loading' ||
     !siweNonce ||
-    !primaryIdentityPublicKeys ||
-    !signedIdentityKeysBlob
+    !primaryIdentityPublicKeys
   ) {
     return (
       <div className={css.loadingIndicator}>
diff --git a/web/account/traditional-login-form.react.js b/web/account/traditional-login-form.react.js
--- a/web/account/traditional-login-form.react.js
+++ b/web/account/traditional-login-form.react.js
@@ -15,13 +15,12 @@
   LogInStartingPayload,
 } from 'lib/types/account-types.js';
 import { logInActionSources } from 'lib/types/account-types.js';
-import type { SignedIdentityKeysBlob } from 'lib/types/crypto-types.js';
 import {
   useDispatchActionPromise,
   useServerCall,
 } from 'lib/utils/action-utils.js';
 
-import { useSignedIdentityKeysBlob } from './account-hooks.js';
+import { useGetSignedIdentityKeysBlob } from './account-hooks.js';
 import HeaderSeparator from './header-separator.react.js';
 import css from './log-in-form.css';
 import PasswordInput from './password-input.react.js';
@@ -39,8 +38,7 @@
   const dispatchActionPromise = useDispatchActionPromise();
   const modalContext = useModalContext();
 
-  const signedIdentityKeysBlob: ?SignedIdentityKeysBlob =
-    useSignedIdentityKeysBlob();
+  const getSignedIdentityKeysBlob = useGetSignedIdentityKeysBlob();
 
   const usernameInputRef = React.useRef();
   React.useEffect(() => {
@@ -67,6 +65,7 @@
 
   const logInAction = React.useCallback(
     async (extraInfo: LogInExtraInfo) => {
+      const signedIdentityKeysBlob = await getSignedIdentityKeysBlob();
       try {
         invariant(
           signedIdentityKeysBlob,
@@ -94,7 +93,7 @@
         throw e;
       }
     },
-    [callLogIn, modalContext, password, signedIdentityKeysBlob, username],
+    [callLogIn, modalContext, password, getSignedIdentityKeysBlob, username],
   );
 
   const onSubmit = React.useCallback(
@@ -174,11 +173,7 @@
         <Button
           variant="filled"
           type="submit"
-          disabled={
-            signedIdentityKeysBlob === null ||
-            signedIdentityKeysBlob === undefined ||
-            inputDisabled
-          }
+          disabled={inputDisabled}
           onClick={onSubmit}
           buttonColor={signInButtonColor}
         >
diff --git a/web/root.js b/web/root.js
--- a/web/root.js
+++ b/web/root.js
@@ -12,6 +12,7 @@
 import IntegrityHandler from 'lib/components/integrity-handler.react.js';
 import { reduxLoggerMiddleware } from 'lib/utils/action-logger.js';
 
+import { GetOrCreateCryptoStoreProvider } from './account/account-hooks.js';
 import App from './app.react.js';
 import { SQLiteDataHandler } from './database/sqlite-data-handler.js';
 import { localforageConfig } from './database/utils/constants.js';
@@ -37,12 +38,14 @@
   <Provider store={store}>
     <ErrorBoundary>
       <InitialReduxStateGate persistor={persistor}>
-        <Router history={history.getHistoryObject()}>
-          <Route path="*" component={App} />
-        </Router>
-        <Socket />
-        <SQLiteDataHandler />
-        <IntegrityHandler />
+        <GetOrCreateCryptoStoreProvider>
+          <Router history={history.getHistoryObject()}>
+            <Route path="*" component={App} />
+          </Router>
+          <Socket />
+          <SQLiteDataHandler />
+          <IntegrityHandler />
+        </GetOrCreateCryptoStoreProvider>
       </InitialReduxStateGate>
     </ErrorBoundary>
   </Provider>
diff --git a/web/selectors/socket-selectors.js b/web/selectors/socket-selectors.js
--- a/web/selectors/socket-selectors.js
+++ b/web/selectors/socket-selectors.js
@@ -1,6 +1,5 @@
 // @flow
 
-import olm from '@commapp/olm';
 import { createSelector } from 'reselect';
 
 import {
@@ -13,12 +12,7 @@
   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 { SignedIdentityKeysBlob } from 'lib/types/crypto-types.js';
 import type {
   ClientServerRequest,
   ClientClientResponse,
@@ -29,7 +23,6 @@
 } 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 =
@@ -51,62 +44,31 @@
   }),
 );
 
-const getSignedIdentityKeysBlobSelector: (
+type WebGetClientResponsesSelectorInputType = {
   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;
-    };
-  },
-);
+  getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
+};
 
 const webGetClientResponsesSelector: (
-  state: AppState,
+  input: WebGetClientResponsesSelectorInputType,
 ) => (
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
-  getClientResponsesSelector,
-  getSignedIdentityKeysBlobSelector,
-  (state: AppState) => state.navInfo.tab === 'calendar',
+  (input: WebGetClientResponsesSelectorInputType) =>
+    getClientResponsesSelector(input.state),
+  (input: WebGetClientResponsesSelectorInputType) =>
+    input.getSignedIdentityKeysBlob,
+  (input: WebGetClientResponsesSelectorInputType) =>
+    input.state.navInfo.tab === 'calendar',
   (
       getClientResponsesFunc: (
         calendarActive: boolean,
         oneTimeKeyGenerator: ?OneTimeKeyGenerator,
-        getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
+        getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
         getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
         serverRequests: $ReadOnlyArray<ClientServerRequest>,
       ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
-      getSignedIdentityKeysBlob: ?() => Promise<SignedIdentityKeysBlob>,
+      getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
       calendarActive: boolean,
     ) =>
     (serverRequests: $ReadOnlyArray<ClientServerRequest>) =>
@@ -134,7 +96,6 @@
 export {
   openSocketSelector,
   sessionIdentificationSelector,
-  getSignedIdentityKeysBlobSelector,
   webGetClientResponsesSelector,
   webSessionStateFuncSelector,
 };
diff --git a/web/socket.react.js b/web/socket.react.js
--- a/web/socket.react.js
+++ b/web/socket.react.js
@@ -18,6 +18,7 @@
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 
+import { useGetSignedIdentityKeysBlob } from './account/account-hooks.js';
 import { useSelector } from './redux/redux-utils.js';
 import {
   activeThreadSelector,
@@ -49,7 +50,10 @@
     invariant(openSocket, 'openSocket failed to be created');
     const sessionIdentification = useSelector(sessionIdentificationSelector);
     const preRequestUserState = useSelector(preRequestUserStateSelector);
-    const getClientResponses = useSelector(webGetClientResponsesSelector);
+    const getSignedIdentityKeysBlob = useGetSignedIdentityKeysBlob();
+    const getClientResponses = useSelector(state =>
+      webGetClientResponsesSelector({ state, getSignedIdentityKeysBlob }),
+    );
     const sessionStateFunc = useSelector(webSessionStateFuncSelector);
     const currentCalendarQuery = useSelector(webCalendarQuery);