diff --git a/lib/types/crypto-types.js b/lib/types/crypto-types.js
index c59aea237..61ce1a8c0 100644
--- a/lib/types/crypto-types.js
+++ b/lib/types/crypto-types.js
@@ -1,160 +1,161 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import type { OlmSessionInitializationInfo } from './request-types.js';
 import { type AuthMetadata } from '../shared/identity-client-context.js';
 import { tShape } from '../utils/validation-utils.js';
 
 export type OLMIdentityKeys = {
   +ed25519: string,
   +curve25519: string,
 };
 const olmIdentityKeysValidator: TInterface<OLMIdentityKeys> =
   tShape<OLMIdentityKeys>({
     ed25519: t.String,
     curve25519: t.String,
   });
 
 export type OLMPrekey = {
   +curve25519: {
     +[key: string]: string,
   },
 };
 
 export type SignedPrekeys = {
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
 };
 
 export const signedPrekeysValidator: TInterface<SignedPrekeys> =
   tShape<SignedPrekeys>({
     contentPrekey: t.String,
     contentPrekeySignature: t.String,
     notifPrekey: t.String,
     notifPrekeySignature: t.String,
   });
 
 export type OLMOneTimeKeys = {
   +curve25519: { +[string]: string },
 };
 
 export type OneTimeKeysResult = {
   +contentOneTimeKeys: OLMOneTimeKeys,
   +notificationsOneTimeKeys: OLMOneTimeKeys,
 };
 
 export type OneTimeKeysResultValues = {
   +contentOneTimeKeys: $ReadOnlyArray<string>,
   +notificationsOneTimeKeys: $ReadOnlyArray<string>,
 };
 
 export type PickledOLMAccount = {
   +picklingKey: string,
   +pickledAccount: string,
 };
 
 export type CryptoStore = {
   +primaryAccount: PickledOLMAccount,
   +primaryIdentityKeys: OLMIdentityKeys,
   +notificationAccount: PickledOLMAccount,
   +notificationIdentityKeys: OLMIdentityKeys,
 };
 
 export type CryptoStoreContextType = {
   +getInitializedCryptoStore: () => Promise<CryptoStore>,
 };
 
 export type NotificationsOlmDataType = {
   +mainSession: string,
   +picklingKey: string,
   +pendingSessionUpdate: string,
   +updateCreationTimestamp: number,
 };
 
 export type IdentityKeysBlob = {
   +primaryIdentityPublicKeys: OLMIdentityKeys,
   +notificationIdentityPublicKeys: OLMIdentityKeys,
 };
 export const identityKeysBlobValidator: TInterface<IdentityKeysBlob> =
   tShape<IdentityKeysBlob>({
     primaryIdentityPublicKeys: olmIdentityKeysValidator,
     notificationIdentityPublicKeys: olmIdentityKeysValidator,
   });
 
 export type SignedIdentityKeysBlob = {
   +payload: string,
   +signature: string,
 };
 export const signedIdentityKeysBlobValidator: TInterface<SignedIdentityKeysBlob> =
   tShape<SignedIdentityKeysBlob>({
     payload: t.String,
     signature: t.String,
   });
 
 export type UserDetail = {
   +username: string,
   +userID: string,
 };
 
 // This type should not be changed without making equivalent changes to
 // `Message` in Identity service's `reserved_users` module
 export type ReservedUsernameMessage =
   | {
       +statement: 'Add the following usernames to reserved list',
       +payload: $ReadOnlyArray<UserDetail>,
       +issuedAt: string,
     }
   | {
       +statement: 'Remove the following username from reserved list',
       +payload: string,
       +issuedAt: string,
     }
   | {
       +statement: 'This user is the owner of the following username and user ID',
       +payload: UserDetail,
       +issuedAt: string,
     };
 
 export const olmEncryptedMessageTypes = Object.freeze({
   PREKEY: 0,
   TEXT: 1,
 });
 
 export type ClientPublicKeys = {
   +primaryIdentityPublicKeys: {
     +ed25519: string,
     +curve25519: string,
   },
   +notificationIdentityPublicKeys: {
     +ed25519: string,
     +curve25519: string,
   },
   +blobPayload: string,
   +signature: string,
 };
 
 export type OlmAPI = {
   +initializeCryptoAccount: () => Promise<void>,
   +getUserPublicKey: () => Promise<ClientPublicKeys>,
   +encrypt: (content: string, deviceID: string) => Promise<string>,
   +decrypt: (encryptedContent: string, deviceID: string) => Promise<string>,
   +contentInboundSessionCreator: (
     contentIdentityKeys: OLMIdentityKeys,
     initialEncryptedContent: string,
   ) => Promise<string>,
   +contentOutboundSessionCreator: (
     contentIdentityKeys: OLMIdentityKeys,
     contentInitializationInfo: OlmSessionInitializationInfo,
   ) => Promise<string>,
   +notificationsSessionCreator: (
     cookie: ?string,
     notificationsIdentityKeys: OLMIdentityKeys,
     notificationsInitializationInfo: OlmSessionInitializationInfo,
     keyserverID: string,
   ) => Promise<string>,
   +getOneTimeKeys: (numberOfKeys: number) => Promise<OneTimeKeysResultValues>,
   +validateAndUploadPrekeys: (authMetadata: AuthMetadata) => Promise<void>,
+  +signMessage: (message: string) => Promise<string>,
 };
diff --git a/lib/utils/__mocks__/config.js b/lib/utils/__mocks__/config.js
index 4892bfaa0..5351fe784 100644
--- a/lib/utils/__mocks__/config.js
+++ b/lib/utils/__mocks__/config.js
@@ -1,30 +1,31 @@
 // @flow
 
 import { type Config } from '../config.js';
 
 const getConfig = (): Config => ({
   resolveKeyserverSessionInvalidationUsingNativeCredentials: null,
   setSessionIDOnRequest: true,
   calendarRangeInactivityLimit: null,
   platformDetails: {
     platform: 'web',
     codeVersion: 70,
     stateVersion: 50,
   },
   authoritativeKeyserverID: '123',
   olmAPI: {
     initializeCryptoAccount: jest.fn(),
     getUserPublicKey: jest.fn(),
     encrypt: jest.fn(),
     decrypt: jest.fn(),
     contentInboundSessionCreator: jest.fn(),
     contentOutboundSessionCreator: jest.fn(),
     notificationsSessionCreator: jest.fn(),
     getOneTimeKeys: jest.fn(),
     validateAndUploadPrekeys: jest.fn(),
+    signMessage: jest.fn(),
   },
 });
 
 const hasConfig = (): boolean => true;
 
 export { getConfig, hasConfig };
diff --git a/native/crypto/olm-api.js b/native/crypto/olm-api.js
index 976536240..0010b886c 100644
--- a/native/crypto/olm-api.js
+++ b/native/crypto/olm-api.js
@@ -1,90 +1,91 @@
 // @flow
 
 import { getOneTimeKeyValues } from 'lib/shared/crypto-utils.js';
 import { type AuthMetadata } from 'lib/shared/identity-client-context.js';
 import type {
   OneTimeKeysResultValues,
   OlmAPI,
   OLMIdentityKeys,
 } from 'lib/types/crypto-types.js';
 import type { OlmSessionInitializationInfo } from 'lib/types/request-types.js';
 
 import { commCoreModule } from '../native-modules.js';
 
 const olmAPI: OlmAPI = {
   async initializeCryptoAccount(): Promise<void> {
     await commCoreModule.initializeCryptoAccount();
   },
   getUserPublicKey: commCoreModule.getUserPublicKey,
   encrypt: commCoreModule.encrypt,
   decrypt: commCoreModule.decrypt,
   async contentInboundSessionCreator(
     contentIdentityKeys: OLMIdentityKeys,
     initialEncryptedContent: string,
   ): Promise<string> {
     const identityKeys = JSON.stringify({
       curve25519: contentIdentityKeys.curve25519,
       ed25519: contentIdentityKeys.ed25519,
     });
     return commCoreModule.initializeContentInboundSession(
       identityKeys,
       initialEncryptedContent,
       contentIdentityKeys.ed25519,
     );
   },
   async contentOutboundSessionCreator(
     contentIdentityKeys: OLMIdentityKeys,
     contentInitializationInfo: OlmSessionInitializationInfo,
   ): Promise<string> {
     const { prekey, prekeySignature, oneTimeKey } = contentInitializationInfo;
     const identityKeys = JSON.stringify({
       curve25519: contentIdentityKeys.curve25519,
       ed25519: contentIdentityKeys.ed25519,
     });
 
     return commCoreModule.initializeContentOutboundSession(
       identityKeys,
       prekey,
       prekeySignature,
       oneTimeKey,
       contentIdentityKeys.ed25519,
     );
   },
   notificationsSessionCreator(
     cookie: ?string,
     notificationsIdentityKeys: OLMIdentityKeys,
     notificationsInitializationInfo: OlmSessionInitializationInfo,
     keyserverID: string,
   ): Promise<string> {
     const { prekey, prekeySignature, oneTimeKey } =
       notificationsInitializationInfo;
     return commCoreModule.initializeNotificationsSession(
       JSON.stringify(notificationsIdentityKeys),
       prekey,
       prekeySignature,
       oneTimeKey,
       keyserverID,
     );
   },
   async getOneTimeKeys(numberOfKeys: number): Promise<OneTimeKeysResultValues> {
     const { contentOneTimeKeys, notificationsOneTimeKeys } =
       await commCoreModule.getOneTimeKeys(numberOfKeys);
     return {
       contentOneTimeKeys: getOneTimeKeyValues(contentOneTimeKeys),
       notificationsOneTimeKeys: getOneTimeKeyValues(notificationsOneTimeKeys),
     };
   },
   async validateAndUploadPrekeys(authMetadata: AuthMetadata): Promise<void> {
     const { userID, deviceID, accessToken } = authMetadata;
     if (!userID || !deviceID || !accessToken) {
       return;
     }
     await commCoreModule.validateAndUploadPrekeys(
       userID,
       deviceID,
       accessToken,
     );
   },
+  signMessage: commCoreModule.signMessage,
 };
 
 export { olmAPI };
diff --git a/native/qr-code/qr-code-screen.react.js b/native/qr-code/qr-code-screen.react.js
index 331983859..1c6d64ab2 100644
--- a/native/qr-code/qr-code-screen.react.js
+++ b/native/qr-code/qr-code-screen.react.js
@@ -1,181 +1,182 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text } from 'react-native';
 import QRCode from 'react-native-qrcode-svg';
 
 import { QRAuthHandler } from 'lib/components/qr-auth-handler.react.js';
 import { qrCodeLinkURL } from 'lib/facts/links.js';
 import { uintArrayToHexString } from 'lib/media/data-utils.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import { useTunnelbroker } from 'lib/tunnelbroker/tunnelbroker-context.js';
 import type { BackupKeys } from 'lib/types/backup-types.js';
 import type {
   NonceChallenge,
   SignedMessage,
 } from 'lib/types/identity-service-types.js';
 import { getContentSigningKey } from 'lib/utils/crypto-utils.js';
 
 import type { QRCodeSignInNavigationProp } from './qr-code-sign-in-navigator.react.js';
 import {
   composeTunnelbrokerQRAuthMessage,
   parseTunnelbrokerQRAuthMessage,
 } from './qr-code-utils.js';
+import { olmAPI } from '../crypto/olm-api.js';
 import { commCoreModule } from '../native-modules.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import { useStyles } from '../themes/colors.js';
 import * as AES from '../utils/aes-crypto-module.js';
 import Alert from '../utils/alert.js';
 
 type QRCodeScreenProps = {
   +navigation: QRCodeSignInNavigationProp<'QRCodeScreen'>,
   +route: NavigationRoute<'QRCodeScreen'>,
 };
 
 function performBackupRestore(backupKeys: BackupKeys): Promise<void> {
   const { backupID, backupDataKey, backupLogDataKey } = backupKeys;
   return commCoreModule.restoreBackupData(
     backupID,
     backupDataKey,
     backupLogDataKey,
   );
 }
 
 // eslint-disable-next-line no-unused-vars
 function QRCodeScreen(props: QRCodeScreenProps): React.Node {
   const [qrCodeValue, setQrCodeValue] = React.useState<?string>();
   const [qrData, setQRData] =
     React.useState<?{ +deviceID: string, +aesKey: string }>();
   const { setUnauthorizedDeviceID } = useTunnelbroker();
 
   const identityContext = React.useContext(IdentityClientContext);
   const identityClient = identityContext?.identityClient;
 
   const performRegistration = React.useCallback(
     async (userID: string) => {
       invariant(identityClient, 'identity context not set');
       try {
         const nonce = await identityClient.generateNonce();
         const nonceChallenge: NonceChallenge = { nonce };
         const nonceMessage = JSON.stringify(nonceChallenge);
-        const signature = await commCoreModule.signMessage(nonceMessage);
+        const signature = await olmAPI.signMessage(nonceMessage);
         const challengeResponse: SignedMessage = {
           message: nonceMessage,
           signature,
         };
 
         await identityClient.uploadKeysForRegisteredDeviceAndLogIn(
           userID,
           challengeResponse,
         );
         setUnauthorizedDeviceID(null);
       } catch (err) {
         console.error('Secondary device registration error:', err);
         Alert.alert('Registration failed', 'Failed to upload device keys', [
           { text: 'OK' },
         ]);
       }
     },
     [setUnauthorizedDeviceID, identityClient],
   );
 
   const generateQRCode = React.useCallback(async () => {
     try {
       const rawAESKey: Uint8Array = await AES.generateKey();
       const aesKeyAsHexString: string = uintArrayToHexString(rawAESKey);
 
       const ed25519Key: string = await getContentSigningKey();
 
       const url = qrCodeLinkURL(aesKeyAsHexString, ed25519Key);
       setUnauthorizedDeviceID(ed25519Key);
       setQrCodeValue(url);
       setQRData({ deviceID: ed25519Key, aesKey: aesKeyAsHexString });
     } catch (err) {
       console.error('Failed to generate QR Code:', err);
     }
   }, [setUnauthorizedDeviceID]);
 
   React.useEffect(() => {
     void generateQRCode();
   }, [generateQRCode]);
 
   const styles = useStyles(unboundStyles);
   return (
     <>
       <QRAuthHandler
         secondaryDeviceID={qrData?.deviceID}
         aesKey={qrData?.aesKey}
         performSecondaryDeviceRegistration={performRegistration}
         composeMessage={composeTunnelbrokerQRAuthMessage}
         processMessage={parseTunnelbrokerQRAuthMessage}
         performBackupRestore={performBackupRestore}
       />
       <View style={styles.container}>
         <Text style={styles.heading}>Log in to Comm</Text>
         <Text style={styles.headingSubtext}>
           Open the Comm app on your phone and scan the QR code below
         </Text>
         <QRCode value={qrCodeValue} size={200} />
         <View style={styles.instructionsBox}>
           <Text style={styles.instructionsTitle}>How to find the scanner:</Text>
           <Text style={styles.instructionsStep}>
             <Text>Go to </Text>
             <Text style={styles.instructionsBold}>Profile</Text>
           </Text>
           <Text style={styles.instructionsStep}>
             <Text>Select </Text>
             <Text style={styles.instructionsBold}>Linked devices </Text>
           </Text>
           <Text style={styles.instructionsStep}>
             <Text>Click </Text>
             <Text style={styles.instructionsBold}>Add </Text>
             <Text>on the top right</Text>
           </Text>
         </View>
       </View>
     </>
   );
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
     alignItems: 'center',
     marginTop: 125,
   },
   heading: {
     fontSize: 24,
     color: 'panelForegroundLabel',
     paddingBottom: 12,
   },
   headingSubtext: {
     fontSize: 12,
     color: 'panelForegroundLabel',
     paddingBottom: 30,
   },
   instructionsBox: {
     alignItems: 'center',
     width: 300,
     marginTop: 40,
     padding: 15,
     borderColor: 'panelForegroundLabel',
     borderWidth: 2,
     borderRadius: 8,
   },
   instructionsTitle: {
     fontSize: 12,
     color: 'panelForegroundLabel',
     paddingBottom: 15,
   },
   instructionsStep: {
     fontSize: 12,
     padding: 1,
     color: 'panelForegroundLabel',
   },
   instructionsBold: {
     fontWeight: 'bold',
   },
 };
 
 export default QRCodeScreen;
diff --git a/web/crypto/olm-api.js b/web/crypto/olm-api.js
index 9d917e1c9..961e65265 100644
--- a/web/crypto/olm-api.js
+++ b/web/crypto/olm-api.js
@@ -1,64 +1,65 @@
 // @flow
 
 import olm from '@commapp/olm';
 
 import { type OlmAPI } from 'lib/types/crypto-types.js';
 
 import { getCommSharedWorker } from '../shared-worker/shared-worker-provider.js';
 import { getOlmWasmPath } from '../shared-worker/utils/constants.js';
 import {
   workerRequestMessageTypes,
   workerResponseMessageTypes,
 } from '../types/worker-types.js';
 
 const usingSharedWorker = false;
 
 function proxyToWorker<T>(
   method: $Keys<OlmAPI>,
 ): (...args: $ReadOnlyArray<mixed>) => Promise<T> {
   return async (...args: $ReadOnlyArray<mixed>) => {
     const sharedWorker = await getCommSharedWorker();
     const result = await sharedWorker.schedule({
       type: workerRequestMessageTypes.CALL_OLM_API_METHOD,
       method,
       args,
     });
 
     if (!result) {
       throw new Error(`Worker OlmAPI call didn't return expected message`);
     } else if (result.type !== workerResponseMessageTypes.CALL_OLM_API_METHOD) {
       throw new Error(
         `Worker OlmAPI call didn't return expected message. Instead got: ${JSON.stringify(
           result,
         )}`,
       );
     }
 
     // Worker should return a message with the corresponding return type
     return (result.result: any);
   };
 }
 
 const olmAPI: OlmAPI = {
   async initializeCryptoAccount(): Promise<void> {
     if (usingSharedWorker) {
       const sharedWorker = await getCommSharedWorker();
       await sharedWorker.schedule({
         type: workerRequestMessageTypes.INITIALIZE_CRYPTO_ACCOUNT,
         olmWasmPath: getOlmWasmPath(),
       });
     } else {
       await olm.init();
     }
   },
   getUserPublicKey: proxyToWorker('getUserPublicKey'),
   encrypt: proxyToWorker('encrypt'),
   decrypt: proxyToWorker('decrypt'),
   contentInboundSessionCreator: proxyToWorker('contentInboundSessionCreator'),
   contentOutboundSessionCreator: proxyToWorker('contentOutboundSessionCreator'),
   notificationsSessionCreator: proxyToWorker('notificationsSessionCreator'),
   getOneTimeKeys: proxyToWorker('getOneTimeKeys'),
   validateAndUploadPrekeys: proxyToWorker('validateAndUploadPrekeys'),
+  signMessage: proxyToWorker('signMessage'),
 };
 
 export { olmAPI, usingSharedWorker };
diff --git a/web/shared-worker/worker/worker-crypto.js b/web/shared-worker/worker/worker-crypto.js
index 101c8d998..010cf4c45 100644
--- a/web/shared-worker/worker/worker-crypto.js
+++ b/web/shared-worker/worker/worker-crypto.js
@@ -1,629 +1,636 @@
 // @flow
 
 import olm from '@commapp/olm';
 import localforage from 'localforage';
 import uuid from 'uuid';
 
 import { initialEncryptedMessageContent } from 'lib/shared/crypto-utils.js';
 import {
   hasMinCodeVersion,
   NEXT_CODE_VERSION,
 } from 'lib/shared/version-utils.js';
 import {
   olmEncryptedMessageTypes,
   type OLMIdentityKeys,
   type CryptoStore,
   type PickledOLMAccount,
   type IdentityKeysBlob,
   type SignedIdentityKeysBlob,
   type OlmAPI,
   type OneTimeKeysResultValues,
   type ClientPublicKeys,
   type NotificationsOlmDataType,
 } from 'lib/types/crypto-types.js';
 import type {
   IdentityNewDeviceKeyUpload,
   IdentityExistingDeviceKeyUpload,
 } from 'lib/types/identity-service-types.js';
 import type { OlmSessionInitializationInfo } from 'lib/types/request-types.js';
 import { entries } from 'lib/utils/objects.js';
 import {
   retrieveAccountKeysSet,
   getAccountOneTimeKeys,
   getAccountPrekeysSet,
   shouldForgetPrekey,
   shouldRotatePrekey,
   retrieveIdentityKeysAndPrekeys,
 } from 'lib/utils/olm-utils.js';
 
 import { getIdentityClient } from './identity-client.js';
 import { getProcessingStoreOpsExceptionMessage } from './process-operations.js';
 import {
   getDBModule,
   getSQLiteQueryExecutor,
   getPlatformDetails,
 } from './worker-database.js';
 import {
   encryptData,
   exportKeyToJWK,
   generateCryptoKey,
 } from '../../crypto/aes-gcm-crypto-utils.js';
 import {
   getOlmDataContentKeyForCookie,
   getOlmEncryptionKeyDBLabelForCookie,
 } from '../../push-notif/notif-crypto-utils.js';
 import {
   type WorkerRequestMessage,
   type WorkerResponseMessage,
   workerRequestMessageTypes,
   workerResponseMessageTypes,
 } from '../../types/worker-types.js';
 import type { OlmPersistSession } from '../types/sqlite-query-executor.js';
 import { isDesktopSafari } from '../utils/db-utils.js';
 
 type WorkerCryptoStore = {
   +contentAccountPickleKey: string,
   +contentAccount: olm.Account,
   +contentSessions: { [deviceID: string]: olm.Session },
   +notificationAccountPickleKey: string,
   +notificationAccount: olm.Account,
 };
 
 let cryptoStore: ?WorkerCryptoStore = null;
 
 function clearCryptoStore() {
   cryptoStore = null;
 }
 
 function persistCryptoStore() {
   const sqliteQueryExecutor = getSQLiteQueryExecutor();
   const dbModule = getDBModule();
   if (!sqliteQueryExecutor || !dbModule) {
     throw new Error(
       "Couldn't persist crypto store because database is not initialized",
     );
   }
   if (!cryptoStore) {
     throw new Error("Couldn't persist crypto store because it doesn't exist");
   }
 
   const {
     contentAccountPickleKey,
     contentAccount,
     contentSessions,
     notificationAccountPickleKey,
     notificationAccount,
   } = cryptoStore;
 
   const pickledContentAccount: PickledOLMAccount = {
     picklingKey: contentAccountPickleKey,
     pickledAccount: contentAccount.pickle(contentAccountPickleKey),
   };
 
   const pickledContentSessions: OlmPersistSession[] = entries(
     contentSessions,
   ).map(([deviceID, session]) => ({
     targetUserID: deviceID,
     sessionData: session.pickle(contentAccountPickleKey),
   }));
 
   const pickledNotificationAccount: PickledOLMAccount = {
     picklingKey: notificationAccountPickleKey,
     pickledAccount: notificationAccount.pickle(notificationAccountPickleKey),
   };
 
   try {
     sqliteQueryExecutor.storeOlmPersistAccount(
       sqliteQueryExecutor.getContentAccountID(),
       JSON.stringify(pickledContentAccount),
     );
     for (const pickledSession of pickledContentSessions) {
       sqliteQueryExecutor.storeOlmPersistSession(pickledSession);
     }
     sqliteQueryExecutor.storeOlmPersistAccount(
       sqliteQueryExecutor.getNotifsAccountID(),
       JSON.stringify(pickledNotificationAccount),
     );
   } catch (err) {
     throw new Error(getProcessingStoreOpsExceptionMessage(err, dbModule));
   }
 }
 
 function getOrCreateOlmAccount(accountIDInDB: number): {
   +picklingKey: string,
   +account: olm.Account,
 } {
   const sqliteQueryExecutor = getSQLiteQueryExecutor();
   const dbModule = getDBModule();
   if (!sqliteQueryExecutor || !dbModule) {
     throw new Error('Database not initialized');
   }
 
   const account = new olm.Account();
   let picklingKey;
 
   let accountDBString;
   try {
     accountDBString =
       sqliteQueryExecutor.getOlmPersistAccountDataWeb(accountIDInDB);
   } catch (err) {
     throw new Error(getProcessingStoreOpsExceptionMessage(err, dbModule));
   }
 
   if (accountDBString.isNull) {
     picklingKey = uuid.v4();
     account.create();
   } else {
     const dbAccount: PickledOLMAccount = JSON.parse(accountDBString.value);
     picklingKey = dbAccount.picklingKey;
     account.unpickle(picklingKey, dbAccount.pickledAccount);
   }
 
   return { picklingKey, account };
 }
 
 function getOlmSessions(picklingKey: string): {
   [deviceID: string]: olm.Session,
 } {
   const sqliteQueryExecutor = getSQLiteQueryExecutor();
   const dbModule = getDBModule();
   if (!sqliteQueryExecutor || !dbModule) {
     throw new Error(
       "Couldn't get olm sessions because database is not initialized",
     );
   }
 
   let sessionsData;
   try {
     sessionsData = sqliteQueryExecutor.getOlmPersistSessionsData();
   } catch (err) {
     throw new Error(getProcessingStoreOpsExceptionMessage(err, dbModule));
   }
 
   const sessions: { [deviceID: string]: olm.Session } = {};
   for (const sessionData of sessionsData) {
     const session = new olm.Session();
     session.unpickle(picklingKey, sessionData.sessionData);
     sessions[sessionData.targetUserID] = session;
   }
 
   return sessions;
 }
 
 function unpickleInitialCryptoStoreAccount(
   account: PickledOLMAccount,
 ): olm.Account {
   const { picklingKey, pickledAccount } = account;
   const olmAccount = new olm.Account();
   olmAccount.unpickle(picklingKey, pickledAccount);
   return olmAccount;
 }
 
 async function initializeCryptoAccount(
   olmWasmPath: string,
   initialCryptoStore: ?CryptoStore,
 ) {
   const sqliteQueryExecutor = getSQLiteQueryExecutor();
   if (!sqliteQueryExecutor) {
     throw new Error('Database not initialized');
   }
 
   await olm.init({ locateFile: () => olmWasmPath });
 
   if (initialCryptoStore) {
     cryptoStore = {
       contentAccountPickleKey: initialCryptoStore.primaryAccount.picklingKey,
       contentAccount: unpickleInitialCryptoStoreAccount(
         initialCryptoStore.primaryAccount,
       ),
       contentSessions: {},
       notificationAccountPickleKey:
         initialCryptoStore.notificationAccount.picklingKey,
       notificationAccount: unpickleInitialCryptoStoreAccount(
         initialCryptoStore.notificationAccount,
       ),
     };
     persistCryptoStore();
     return;
   }
 
   await olmAPI.initializeCryptoAccount();
 }
 
 async function processAppOlmApiRequest(
   message: WorkerRequestMessage,
 ): Promise<?WorkerResponseMessage> {
   if (message.type === workerRequestMessageTypes.INITIALIZE_CRYPTO_ACCOUNT) {
     await initializeCryptoAccount(
       message.olmWasmPath,
       message.initialCryptoStore,
     );
   } else if (message.type === workerRequestMessageTypes.CALL_OLM_API_METHOD) {
     const method: (...$ReadOnlyArray<mixed>) => mixed = (olmAPI[
       message.method
     ]: any);
     // Flow doesn't allow us to bind the (stringified) method name with
     // the argument types so we need to pass the args as mixed.
     const result = await method(...message.args);
     return {
       type: workerResponseMessageTypes.CALL_OLM_API_METHOD,
       result,
     };
   }
   return undefined;
 }
 
 function getSignedIdentityKeysBlob(): SignedIdentityKeysBlob {
   if (!cryptoStore) {
     throw new Error('Crypto account not initialized');
   }
 
   const { contentAccount, notificationAccount } = cryptoStore;
 
   const identityKeysBlob: IdentityKeysBlob = {
     notificationIdentityPublicKeys: JSON.parse(
       notificationAccount.identity_keys(),
     ),
     primaryIdentityPublicKeys: JSON.parse(contentAccount.identity_keys()),
   };
 
   const payloadToBeSigned: string = JSON.stringify(identityKeysBlob);
   const signedIdentityKeysBlob: SignedIdentityKeysBlob = {
     payload: payloadToBeSigned,
     signature: contentAccount.sign(payloadToBeSigned),
   };
 
   return signedIdentityKeysBlob;
 }
 
 function getNewDeviceKeyUpload(): IdentityNewDeviceKeyUpload {
   if (!cryptoStore) {
     throw new Error('Crypto account not initialized');
   }
   const { contentAccount, notificationAccount } = cryptoStore;
 
   const signedIdentityKeysBlob = getSignedIdentityKeysBlob();
 
   const primaryAccountKeysSet = retrieveAccountKeysSet(contentAccount);
   const notificationAccountKeysSet =
     retrieveAccountKeysSet(notificationAccount);
 
   persistCryptoStore();
 
   return {
     keyPayload: signedIdentityKeysBlob.payload,
     keyPayloadSignature: signedIdentityKeysBlob.signature,
     contentPrekey: primaryAccountKeysSet.prekey,
     contentPrekeySignature: primaryAccountKeysSet.prekeySignature,
     notifPrekey: notificationAccountKeysSet.prekey,
     notifPrekeySignature: notificationAccountKeysSet.prekeySignature,
     contentOneTimeKeys: primaryAccountKeysSet.oneTimeKeys,
     notifOneTimeKeys: notificationAccountKeysSet.oneTimeKeys,
   };
 }
 
 function getExistingDeviceKeyUpload(): IdentityExistingDeviceKeyUpload {
   if (!cryptoStore) {
     throw new Error('Crypto account not initialized');
   }
   const { contentAccount, notificationAccount } = cryptoStore;
 
   const signedIdentityKeysBlob = getSignedIdentityKeysBlob();
 
   const { prekey: contentPrekey, prekeySignature: contentPrekeySignature } =
     retrieveIdentityKeysAndPrekeys(contentAccount);
   const { prekey: notifPrekey, prekeySignature: notifPrekeySignature } =
     retrieveIdentityKeysAndPrekeys(notificationAccount);
 
   persistCryptoStore();
 
   return {
     keyPayload: signedIdentityKeysBlob.payload,
     keyPayloadSignature: signedIdentityKeysBlob.signature,
     contentPrekey,
     contentPrekeySignature,
     notifPrekey,
     notifPrekeySignature,
   };
 }
 
 const olmAPI: OlmAPI = {
   async initializeCryptoAccount(): Promise<void> {
     const sqliteQueryExecutor = getSQLiteQueryExecutor();
     if (!sqliteQueryExecutor) {
       throw new Error('Database not initialized');
     }
 
     const contentAccountResult = getOrCreateOlmAccount(
       sqliteQueryExecutor.getContentAccountID(),
     );
     const notificationAccountResult = getOrCreateOlmAccount(
       sqliteQueryExecutor.getNotifsAccountID(),
     );
     const contentSessions = getOlmSessions(contentAccountResult.picklingKey);
 
     cryptoStore = {
       contentAccountPickleKey: contentAccountResult.picklingKey,
       contentAccount: contentAccountResult.account,
       contentSessions,
       notificationAccountPickleKey: notificationAccountResult.picklingKey,
       notificationAccount: notificationAccountResult.account,
     };
 
     persistCryptoStore();
   },
   async getUserPublicKey(): Promise<ClientPublicKeys> {
     if (!cryptoStore) {
       throw new Error('Crypto account not initialized');
     }
     const { contentAccount, notificationAccount } = cryptoStore;
     const { payload, signature } = getSignedIdentityKeysBlob();
 
     return {
       primaryIdentityPublicKeys: JSON.parse(contentAccount.identity_keys()),
       notificationIdentityPublicKeys: JSON.parse(
         notificationAccount.identity_keys(),
       ),
       blobPayload: payload,
       signature,
     };
   },
   async encrypt(content: string, deviceID: string): Promise<string> {
     if (!cryptoStore) {
       throw new Error('Crypto account not initialized');
     }
     const session = cryptoStore.contentSessions[deviceID];
     if (!session) {
       throw new Error(`No session for deviceID: ${deviceID}`);
     }
     const { body } = session.encrypt(content);
 
     persistCryptoStore();
 
     return body;
   },
   async decrypt(encryptedContent: string, deviceID: string): Promise<string> {
     if (!cryptoStore) {
       throw new Error('Crypto account not initialized');
     }
 
     const session = cryptoStore.contentSessions[deviceID];
     if (!session) {
       throw new Error(`No session for deviceID: ${deviceID}`);
     }
 
     const result = session.decrypt(
       olmEncryptedMessageTypes.TEXT,
       encryptedContent,
     );
 
     persistCryptoStore();
 
     return result;
   },
   async contentInboundSessionCreator(
     contentIdentityKeys: OLMIdentityKeys,
     initialEncryptedContent: string,
   ): Promise<string> {
     if (!cryptoStore) {
       throw new Error('Crypto account not initialized');
     }
     const { contentAccount, contentSessions } = cryptoStore;
 
     const session = new olm.Session();
     session.create_inbound_from(
       contentAccount,
       contentIdentityKeys.curve25519,
       initialEncryptedContent,
     );
 
     contentAccount.remove_one_time_keys(session);
     const initialEncryptedMessage = session.decrypt(
       olmEncryptedMessageTypes.PREKEY,
       initialEncryptedContent,
     );
 
     contentSessions[contentIdentityKeys.ed25519] = session;
     persistCryptoStore();
 
     return initialEncryptedMessage;
   },
   async contentOutboundSessionCreator(
     contentIdentityKeys: OLMIdentityKeys,
     contentInitializationInfo: OlmSessionInitializationInfo,
   ): Promise<string> {
     if (!cryptoStore) {
       throw new Error('Crypto account not initialized');
     }
     const { contentAccount, contentSessions } = cryptoStore;
 
     const session = new olm.Session();
     session.create_outbound(
       contentAccount,
       contentIdentityKeys.curve25519,
       contentIdentityKeys.ed25519,
       contentInitializationInfo.prekey,
       contentInitializationInfo.prekeySignature,
       contentInitializationInfo.oneTimeKey,
     );
     const { body: initialContentEncryptedMessage } = session.encrypt(
       JSON.stringify(initialEncryptedMessageContent),
     );
 
     contentSessions[contentIdentityKeys.ed25519] = session;
     persistCryptoStore();
 
     return initialContentEncryptedMessage;
   },
   async notificationsSessionCreator(
     cookie: ?string,
     notificationsIdentityKeys: OLMIdentityKeys,
     notificationsInitializationInfo: OlmSessionInitializationInfo,
     keyserverID: string,
   ): Promise<string> {
     const platformDetails = getPlatformDetails();
     if (!platformDetails) {
       throw new Error('Worker not initialized');
     }
 
     if (!cryptoStore) {
       throw new Error('Crypto account not initialized');
     }
 
     const { notificationAccountPickleKey, notificationAccount } = cryptoStore;
     const encryptionKey = await generateCryptoKey({
       extractable: isDesktopSafari,
     });
 
     const notificationsPrekey = notificationsInitializationInfo.prekey;
     const session = new olm.Session();
     session.create_outbound(
       notificationAccount,
       notificationsIdentityKeys.curve25519,
       notificationsIdentityKeys.ed25519,
       notificationsPrekey,
       notificationsInitializationInfo.prekeySignature,
       notificationsInitializationInfo.oneTimeKey,
     );
     const { body: initialNotificationsEncryptedMessage } = session.encrypt(
       JSON.stringify(initialEncryptedMessageContent),
     );
 
     const mainSession = session.pickle(notificationAccountPickleKey);
     const notificationsOlmData: NotificationsOlmDataType = {
       mainSession,
       pendingSessionUpdate: mainSession,
       updateCreationTimestamp: Date.now(),
       picklingKey: notificationAccountPickleKey,
     };
     const encryptedOlmData = await encryptData(
       new TextEncoder().encode(JSON.stringify(notificationsOlmData)),
       encryptionKey,
     );
 
     let notifsOlmDataContentKey;
     let notifsOlmDataEncryptionKeyDBLabel;
 
     if (
       hasMinCodeVersion(platformDetails, { majorDesktop: NEXT_CODE_VERSION })
     ) {
       notifsOlmDataEncryptionKeyDBLabel = getOlmEncryptionKeyDBLabelForCookie(
         cookie,
         keyserverID,
       );
       notifsOlmDataContentKey = getOlmDataContentKeyForCookie(
         cookie,
         keyserverID,
       );
     } else {
       notifsOlmDataEncryptionKeyDBLabel =
         getOlmEncryptionKeyDBLabelForCookie(cookie);
       notifsOlmDataContentKey = getOlmDataContentKeyForCookie(cookie);
     }
 
     const persistEncryptionKeyPromise = (async () => {
       let cryptoKeyPersistentForm;
       if (isDesktopSafari) {
         // Safari doesn't support structured clone algorithm in service
         // worker context so we have to store CryptoKey as JSON
         cryptoKeyPersistentForm = await exportKeyToJWK(encryptionKey);
       } else {
         cryptoKeyPersistentForm = encryptionKey;
       }
 
       await localforage.setItem(
         notifsOlmDataEncryptionKeyDBLabel,
         cryptoKeyPersistentForm,
       );
     })();
 
     await Promise.all([
       localforage.setItem(notifsOlmDataContentKey, encryptedOlmData),
       persistEncryptionKeyPromise,
     ]);
 
     return initialNotificationsEncryptedMessage;
   },
   async getOneTimeKeys(numberOfKeys: number): Promise<OneTimeKeysResultValues> {
     if (!cryptoStore) {
       throw new Error('Crypto account not initialized');
     }
     const { contentAccount, notificationAccount } = cryptoStore;
 
     const contentOneTimeKeys = getAccountOneTimeKeys(
       contentAccount,
       numberOfKeys,
     );
     contentAccount.mark_keys_as_published();
 
     const notificationsOneTimeKeys = getAccountOneTimeKeys(
       notificationAccount,
       numberOfKeys,
     );
     notificationAccount.mark_keys_as_published();
 
     persistCryptoStore();
 
     return { contentOneTimeKeys, notificationsOneTimeKeys };
   },
   async validateAndUploadPrekeys(authMetadata): Promise<void> {
     const { userID, deviceID, accessToken } = authMetadata;
     if (!userID || !deviceID || !accessToken) {
       return;
     }
     const identityClient = getIdentityClient();
 
     if (!identityClient) {
       throw new Error('Identity client not initialized');
     }
 
     if (!cryptoStore) {
       throw new Error('Crypto account not initialized');
     }
     const { contentAccount, notificationAccount } = cryptoStore;
 
     // Content and notification accounts' keys are always rotated at the same
     // time so we only need to check one of them.
     if (shouldRotatePrekey(contentAccount)) {
       contentAccount.generate_prekey();
       notificationAccount.generate_prekey();
     }
     if (shouldForgetPrekey(contentAccount)) {
       contentAccount.forget_old_prekey();
       notificationAccount.forget_old_prekey();
     }
     persistCryptoStore();
 
     if (!contentAccount.unpublished_prekey()) {
       return;
     }
 
     const { prekey: notifPrekey, prekeySignature: notifPrekeySignature } =
       getAccountPrekeysSet(notificationAccount);
     const { prekey: contentPrekey, prekeySignature: contentPrekeySignature } =
       getAccountPrekeysSet(contentAccount);
 
     if (!notifPrekeySignature || !contentPrekeySignature) {
       throw new Error('Prekey signature is missing');
     }
 
     await identityClient.publishWebPrekeys({
       contentPrekey,
       contentPrekeySignature,
       notifPrekey,
       notifPrekeySignature,
     });
     contentAccount.mark_prekey_as_published();
     notificationAccount.mark_prekey_as_published();
 
     persistCryptoStore();
   },
+  async signMessage(message: string): Promise<string> {
+    if (!cryptoStore) {
+      throw new Error('Crypto account not initialized');
+    }
+    const { contentAccount } = cryptoStore;
+    return contentAccount.sign(message);
+  },
 };
 
 export {
   clearCryptoStore,
   processAppOlmApiRequest,
   getSignedIdentityKeysBlob,
   getNewDeviceKeyUpload,
   getExistingDeviceKeyUpload,
 };