diff --git a/lib/tunnelbroker/use-peer-to-peer-message-handler.js b/lib/tunnelbroker/use-peer-to-peer-message-handler.js
index ebedb2ddb..d92731b2c 100644
--- a/lib/tunnelbroker/use-peer-to-peer-message-handler.js
+++ b/lib/tunnelbroker/use-peer-to-peer-message-handler.js
@@ -1,422 +1,419 @@
 // @flow
 
 import invariant from 'invariant';
 import _isEqual from 'lodash/fp/isEqual.js';
 import * as React from 'react';
 
 import { useResendPeerToPeerMessages } from './use-resend-peer-to-peer-messages.js';
 import { removePeerUsersActionType } from '../actions/aux-user-actions.js';
 import { invalidateTunnelbrokerDeviceTokenActionType } from '../actions/tunnelbroker-actions.js';
 import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';
 import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
 import {
   useBroadcastDeviceListUpdates,
   useBroadcastAccountDeletion,
   useGetAndUpdateDeviceListsForUsers,
 } from '../hooks/peer-list-hooks.js';
 import {
   getAllPeerDevices,
   getForeignPeerDevices,
 } from '../selectors/user-selectors.js';
 import {
   verifyAndGetDeviceList,
   removeDeviceFromDeviceList,
 } from '../shared/device-list-utils.js';
 import { useProcessDMOperation } from '../shared/dm-ops/process-dm-ops.js';
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import type { DeviceOlmInboundKeys } from '../types/identity-service-types.js';
 import {
   peerToPeerMessageTypes,
   type PeerToPeerMessage,
   type SenderInfo,
 } from '../types/tunnelbroker/peer-to-peer-message-types.js';
 import {
   userActionsP2PMessageTypes,
   userActionP2PMessageValidator,
   type UserActionP2PMessage,
 } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
 import { getConfig } from '../utils/config.js';
 import { getContentSigningKey } from '../utils/crypto-utils.js';
 import { getMessageForException } from '../utils/errors.js';
 import {
   hasHigherDeviceID,
   OLM_SESSION_ERROR_PREFIX,
   olmSessionErrors,
 } from '../utils/olm-utils.js';
 import { getClientMessageIDFromTunnelbrokerMessageID } from '../utils/peer-to-peer-communication-utils.js';
 import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
 import { useDispatch, useSelector } from '../utils/redux-utils.js';
 
 // When logout is requested by primary device, logging out of Identity Service
 // is already handled by the primary device
 const primaryRequestLogoutOptions = Object.freeze({ skipIdentityLogOut: true });
 
 // When re-broadcasting, we want to do it only to foreign peers
 // to avoid a vicious circle of deletion messages sent by own devices.
 const accountDeletionBroadcastOptions = Object.freeze({
   includeOwnDevices: false,
 });
 
 // handles `peerToPeerMessageTypes.ENCRYPTED_MESSAGE`
 function useHandleOlmMessageToDevice(): (
   decryptedMessageContent: string,
   senderInfo: SenderInfo,
   messageID: string,
 ) => Promise<void> {
   const identityContext = React.useContext(IdentityClientContext);
   invariant(identityContext, 'Identity context should be set');
 
   const { identityClient, getAuthMetadata } = identityContext;
   const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
   const reBroadcastAccountDeletion = useBroadcastAccountDeletion(
     accountDeletionBroadcastOptions,
   );
   const allPeerDevices = useSelector(getAllPeerDevices);
 
   const dispatch = useDispatch();
   const dispatchActionPromise = useDispatchActionPromise();
   const primaryDeviceRequestedLogOut = useLogOut(primaryRequestLogoutOptions);
 
   const processDMOperation = useProcessDMOperation();
 
   return React.useCallback(
     async (
       decryptedMessageContent: string,
       senderInfo: SenderInfo,
       messageID: string,
     ) => {
       const { sqliteAPI } = getConfig();
 
       const parsedMessageToDevice = JSON.parse(decryptedMessageContent);
 
       // Handle user-action messages
       if (!userActionP2PMessageValidator.is(parsedMessageToDevice)) {
         return;
       }
       const userActionMessage: UserActionP2PMessage = parsedMessageToDevice;
 
       if (
         userActionMessage.type ===
         userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE
       ) {
         // causes log out, there is no need to remove Inbound P2P message
         void dispatchActionPromise(
           logOutActionTypes,
           primaryDeviceRequestedLogOut(),
         );
       } else if (
         userActionMessage.type ===
         userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE
       ) {
         const { userID, deviceID: deviceIDToLogOut } = senderInfo;
         await removeDeviceFromDeviceList(
           identityClient,
           userID,
           deviceIDToLogOut,
         );
         await broadcastDeviceListUpdates(
           allPeerDevices.filter(deviceID => deviceID !== deviceIDToLogOut),
         );
         await sqliteAPI.removeInboundP2PMessages([messageID]);
       } else if (
         userActionMessage.type === userActionsP2PMessageTypes.DM_OPERATION
       ) {
         // inbound P2P message is removed in DBOpsHandler after processing
         await processDMOperation(userActionMessage.op, {
           messageID,
           senderDeviceID: senderInfo.deviceID,
         });
       } else if (
         userActionMessage.type === userActionsP2PMessageTypes.ACCOUNT_DELETION
       ) {
         const { userID: thisUserID } = await getAuthMetadata();
         if (!thisUserID) {
           return;
         }
         // own devices re-broadcast account deletion to foreign peer devices
         if (senderInfo.userID === thisUserID) {
           await reBroadcastAccountDeletion();
           // we treat account deletion the same way as primary-device-requested
           // logout, no need to remove Inbound P2P message
           void dispatchActionPromise(
             logOutActionTypes,
             primaryDeviceRequestedLogOut(),
           );
         } else {
           dispatch({
             type: removePeerUsersActionType,
             payload: { userIDs: [senderInfo.userID] },
           });
           await sqliteAPI.removeInboundP2PMessages([messageID]);
         }
       } else {
         console.warn(
           'Unsupported P2P user action message:',
           userActionMessage.type,
         );
       }
     },
     [
       allPeerDevices,
       broadcastDeviceListUpdates,
       dispatch,
       dispatchActionPromise,
       getAuthMetadata,
       identityClient,
       primaryDeviceRequestedLogOut,
       processDMOperation,
       reBroadcastAccountDeletion,
     ],
   );
 }
 
 function usePeerToPeerMessageHandler(): (
   message: PeerToPeerMessage,
   messageID: string,
 ) => Promise<void> {
   const { olmAPI, sqliteAPI } = getConfig();
 
   const identityContext = React.useContext(IdentityClientContext);
   invariant(identityContext, 'Identity context should be set');
   const { identityClient, getAuthMetadata } = identityContext;
 
   const foreignPeerDevices = useSelector(getForeignPeerDevices);
   const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
   const getAndUpdateDeviceListsForUsers = useGetAndUpdateDeviceListsForUsers();
 
   const dispatch = useDispatch();
 
   const handleOlmMessageToDevice = useHandleOlmMessageToDevice();
   const resendPeerToPeerMessages = useResendPeerToPeerMessages();
   const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
 
   return React.useCallback(
     async (message: PeerToPeerMessage, messageID: string) => {
       if (message.type === peerToPeerMessageTypes.OUTBOUND_SESSION_CREATION) {
         const { senderInfo, encryptedData, sessionVersion } = message;
         const { userID: senderUserID, deviceID: senderDeviceID } = senderInfo;
 
         let deviceKeys: ?DeviceOlmInboundKeys = null;
         try {
           const { keys } =
             await identityClient.getInboundKeysForUser(senderUserID);
           deviceKeys = keys[senderDeviceID];
         } catch (e) {
           console.log(e.message);
         }
 
         if (!deviceKeys) {
           console.log(
             'Error creating inbound session with device ' +
               `${senderDeviceID}: No keys for the device, ` +
               `session version: ${sessionVersion}`,
           );
           return;
         }
 
         try {
           await olmAPI.initializeCryptoAccount();
           const result = await olmAPI.contentInboundSessionCreator(
             deviceKeys.identityKeysBlob.primaryIdentityPublicKeys,
             encryptedData,
             sessionVersion,
             false,
           );
           console.log(
             'Created inbound session with device ' +
               `${senderDeviceID}: ${result}, ` +
               `session version: ${sessionVersion}`,
           );
         } catch (e) {
           if (e.message?.includes(olmSessionErrors.alreadyCreated)) {
             console.log(
               'Received session request with lower session version from ' +
                 `${senderDeviceID}, session version: ${sessionVersion}`,
             );
           } else if (e.message?.includes(olmSessionErrors.raceCondition)) {
             const currentDeviceID = await getContentSigningKey();
             if (hasHigherDeviceID(currentDeviceID, senderDeviceID)) {
               console.log(
                 'Race condition while creating session with ' +
                   `${senderDeviceID}, session version: ${sessionVersion}, ` +
                   `this device has a higher deviceID and the session will be kept`,
               );
             } else {
               const result = await olmAPI.contentInboundSessionCreator(
                 deviceKeys.identityKeysBlob.primaryIdentityPublicKeys,
                 encryptedData,
                 sessionVersion,
                 true,
               );
               console.log(
                 'Overwrite session with device ' +
                   `${senderDeviceID}: ${result}, ` +
                   `session version: ${sessionVersion}`,
               );
               await resendPeerToPeerMessages(senderDeviceID);
             }
           } else {
             console.log(
               'Error creating inbound session with device ' +
                 `${senderDeviceID}: ${e.message}, ` +
                 `session version: ${sessionVersion}`,
             );
           }
         }
       } else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) {
         try {
           await olmAPI.initializeCryptoAccount();
           const decrypted = await olmAPI.decryptAndPersist(
             message.encryptedData,
             message.senderInfo.deviceID,
             message.senderInfo.userID,
             messageID,
           );
           console.log(
             'Decrypted message from device ' +
               `${message.senderInfo.deviceID}: ${decrypted}`,
           );
 
           try {
             await handleOlmMessageToDevice(
               decrypted,
               message.senderInfo,
               messageID,
             );
           } catch (e) {
             console.log('Failed processing Olm P2P message:', e);
           }
         } catch (e) {
           if (e.message?.includes(olmSessionErrors.invalidSessionVersion)) {
             console.log(
               'Received message decrypted with different session from ' +
                 `${message.senderInfo.deviceID}.`,
             );
             return;
           }
           console.log(
             'Error decrypting message from device ' +
               `${message.senderInfo.deviceID}: ${e.message}`,
           );
 
           if (!e.message?.includes(OLM_SESSION_ERROR_PREFIX)) {
             throw e;
           }
 
           await createOlmSessionsWithPeer(
             message.senderInfo.userID,
             message.senderInfo.deviceID,
             {
               overwriteContentSession: true,
             },
           );
           await resendPeerToPeerMessages(message.senderInfo.deviceID);
         }
       } else if (message.type === peerToPeerMessageTypes.REFRESH_KEY_REQUEST) {
         try {
           await olmAPI.initializeCryptoAccount();
           const oneTimeKeys = await olmAPI.getOneTimeKeys(message.numberOfKeys);
           await identityClient.uploadOneTimeKeys(oneTimeKeys);
         } catch (e) {
           console.log(`Error uploading one-time keys: ${e.message}`);
         }
       } else if (message.type === peerToPeerMessageTypes.DEVICE_LIST_UPDATED) {
         try {
           const result = await verifyAndGetDeviceList(
             identityClient,
             message.userID,
             null,
           );
           if (!result.valid) {
             console.log(
               `Received invalid device list update for user ${message.userID}. Reason: ${result.reason}`,
             );
           } else {
             console.log(
               `Received valid device list update for user ${message.userID}`,
             );
           }
           await getAndUpdateDeviceListsForUsers([message.userID]);
 
           if (result.valid && message?.signedDeviceList?.rawDeviceList) {
             const receivedRawList = JSON.parse(
               message.signedDeviceList.rawDeviceList,
             );
 
             // additional check for broadcasted and Identity device
             // list equality
             const listsAreEqual = _isEqual(result.deviceList)(receivedRawList);
             console.log(
               `Identity and received device lists are ${
                 listsAreEqual ? '' : 'not'
               } equal.`,
             );
           }
         } catch (e) {
           console.log(
             `Error verifying device list for user ${message.userID}: ${e}`,
           );
         }
       } else if (
         message.type === peerToPeerMessageTypes.IDENTITY_DEVICE_LIST_UPDATED
       ) {
         try {
           const { userID } = await getAuthMetadata();
           if (!userID) {
             return;
           }
 
           await Promise.all([
             broadcastDeviceListUpdates(foreignPeerDevices),
             getAndUpdateDeviceListsForUsers([userID]),
           ]);
         } catch (e) {
           console.log(
             `Error updating device list after Identity request: ${
               getMessageForException(e) ?? 'unknown error'
             }`,
           );
         }
       } else if (message.type === peerToPeerMessageTypes.MESSAGE_PROCESSED) {
         try {
           const { deviceID, messageID: tunnelbrokerMessageID } = message;
           const clientMessageID = getClientMessageIDFromTunnelbrokerMessageID(
             tunnelbrokerMessageID,
           );
-          await sqliteAPI.removeOutboundP2PMessagesOlderThan(
-            clientMessageID,
-            deviceID,
-          );
+          await sqliteAPI.removeOutboundP2PMessage(clientMessageID, deviceID);
         } catch (e) {
           console.log(
             `Error removing message after processing: ${
               getMessageForException(e) ?? 'unknown error'
             }`,
           );
         }
       } else if (message.type === peerToPeerMessageTypes.BAD_DEVICE_TOKEN) {
         dispatch({
           type: invalidateTunnelbrokerDeviceTokenActionType,
           payload: {
             deviceToken: message.invalidatedToken,
           },
         });
       }
     },
     [
       broadcastDeviceListUpdates,
       createOlmSessionsWithPeer,
       dispatch,
       foreignPeerDevices,
       getAndUpdateDeviceListsForUsers,
       getAuthMetadata,
       handleOlmMessageToDevice,
       identityClient,
       olmAPI,
       resendPeerToPeerMessages,
       sqliteAPI,
     ],
   );
 }
 
 export { usePeerToPeerMessageHandler, useHandleOlmMessageToDevice };
diff --git a/lib/types/sqlite-types.js b/lib/types/sqlite-types.js
index c5f6529d3..f913f170a 100644
--- a/lib/types/sqlite-types.js
+++ b/lib/types/sqlite-types.js
@@ -1,77 +1,77 @@
 // @flow
 
 import type { ClientDBMessageInfo } from './message-types.js';
 import type { StoreOperations } from './store-ops-types.js';
 
 export const outboundP2PMessageStatuses = Object.freeze({
   // The message was prepared to be sent to other peers, but it's not encrypted.
   // It was inserted into DB in the same transaction as making changes to
   // the store.
   persisted: 'persisted',
   // Encryption is done in the same transaction as persisting the CryptoModule,
   // and message order is also tracked on the client side,
   // which means the message can be sent.
   encrypted: 'encrypted',
   // The message was sent to another peer (Tunnelbroker owns it),
   // waiting for the confirmation (handled in `peerToPeerMessageHandler`).
   sent: 'sent',
 });
 export type OutboundP2PMessageStatuses = $Values<
   typeof outboundP2PMessageStatuses,
 >;
 
 export type InboundP2PMessage = {
   +messageID: string,
   +senderDeviceID: string,
   +plaintext: string,
   +status: string,
   +senderUserID: string,
 };
 
 export type OutboundP2PMessage = {
   +messageID: string,
   +deviceID: string,
   +userID: string,
   +timestamp: string,
   +plaintext: string,
   +ciphertext: string,
   +status: OutboundP2PMessageStatuses,
   +supportsAutoRetry: boolean,
 };
 
 export type SQLiteAPI = {
   // read operations
   +getAllInboundP2PMessages: () => Promise<Array<InboundP2PMessage>>,
   +getAllOutboundP2PMessages: () => Promise<Array<OutboundP2PMessage>>,
   +getRelatedMessages: (
     messageID: string,
   ) => Promise<Array<ClientDBMessageInfo>>,
   +getOutboundP2PMessagesByID: (
     ids: $ReadOnlyArray<string>,
   ) => Promise<Array<OutboundP2PMessage>>,
   +searchMessages: (
     query: string,
     threadID: string,
     timestampCursor: ?string,
     messageIDCursor: ?string,
   ) => Promise<Array<ClientDBMessageInfo>>,
 
   // write operations
   +removeInboundP2PMessages: (ids: $ReadOnlyArray<string>) => Promise<void>,
   +markOutboundP2PMessageAsSent: (
     messageID: string,
     deviceID: string,
   ) => Promise<void>,
   +resetOutboundP2PMessagesForDevice: (
     deviceID: string,
   ) => Promise<Array<string>>,
-  +removeOutboundP2PMessagesOlderThan: (
+  +removeOutboundP2PMessage: (
     messageID: string,
     deviceID: string,
   ) => Promise<void>,
 
   +processDBStoreOperations: (
     operations: StoreOperations,
     userID?: ?string,
   ) => Promise<void>,
 };
diff --git a/lib/utils/__mocks__/config.js b/lib/utils/__mocks__/config.js
index b9f223ac7..0dc25dbad 100644
--- a/lib/utils/__mocks__/config.js
+++ b/lib/utils/__mocks__/config.js
@@ -1,52 +1,52 @@
 // @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(),
     encryptAndPersist: jest.fn(),
     encryptNotification: jest.fn(),
     decrypt: jest.fn(),
     decryptAndPersist: jest.fn(),
     contentInboundSessionCreator: jest.fn(),
     contentOutboundSessionCreator: jest.fn(),
     keyserverNotificationsSessionCreator: jest.fn(),
     notificationsOutboundSessionCreator: jest.fn(),
     isContentSessionInitialized: jest.fn(),
     isDeviceNotificationsSessionInitialized: jest.fn(),
     isNotificationsSessionInitializedWithDevices: jest.fn(),
     getOneTimeKeys: jest.fn(),
     validateAndUploadPrekeys: jest.fn(),
     signMessage: jest.fn(),
     verifyMessage: jest.fn(),
     markPrekeysAsPublished: jest.fn(),
   },
   sqliteAPI: {
     getAllInboundP2PMessages: jest.fn(),
     removeInboundP2PMessages: jest.fn(),
     processDBStoreOperations: jest.fn(),
     getAllOutboundP2PMessages: jest.fn(),
     markOutboundP2PMessageAsSent: jest.fn(),
-    removeOutboundP2PMessagesOlderThan: jest.fn(),
+    removeOutboundP2PMessage: jest.fn(),
     resetOutboundP2PMessagesForDevice: jest.fn(),
     getRelatedMessages: jest.fn(),
     getOutboundP2PMessagesByID: jest.fn(),
     searchMessages: jest.fn(),
   },
 });
 
 const hasConfig = (): boolean => true;
 
 export { getConfig, hasConfig };
diff --git a/native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h b/native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h
index 0b5d58a05..d732b5e73 100644
--- a/native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h
+++ b/native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h
@@ -1,208 +1,208 @@
 #pragma once
 
 #include "../CryptoTools/Persist.h"
 #include "entities/AuxUserInfo.h"
 #include "entities/CommunityInfo.h"
 #include "entities/Draft.h"
 #include "entities/EntryInfo.h"
 #include "entities/InboundP2PMessage.h"
 #include "entities/IntegrityThreadHash.h"
 #include "entities/KeyserverInfo.h"
 #include "entities/LocalMessageInfo.h"
 #include "entities/Media.h"
 #include "entities/Message.h"
 #include "entities/MessageStoreThread.h"
 #include "entities/OlmPersistAccount.h"
 #include "entities/OlmPersistSession.h"
 #include "entities/OutboundP2PMessage.h"
 #include "entities/PersistItem.h"
 #include "entities/Report.h"
 #include "entities/SyncedMetadataEntry.h"
 #include "entities/Thread.h"
 #include "entities/ThreadActivityEntry.h"
 #include "entities/UserInfo.h"
 
 #include <string>
 
 namespace comm {
 
 /**
  * if any initialization/cleaning up steps are required for specific
  * database managers they should appear in constructors/destructors
  * following the RAII pattern
  */
 class DatabaseQueryExecutor {
 public:
   virtual std::string getDraft(std::string key) const = 0;
   virtual std::unique_ptr<Thread> getThread(std::string threadID) const = 0;
   virtual void updateDraft(std::string key, std::string text) const = 0;
   virtual bool moveDraft(std::string oldKey, std::string newKey) const = 0;
   virtual std::vector<Draft> getAllDrafts() const = 0;
   virtual void removeAllDrafts() const = 0;
   virtual void removeDrafts(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllMessages() const = 0;
   virtual std::vector<MessageEntity> getAllMessages() const = 0;
   virtual void removeMessages(const std::vector<std::string> &ids) const = 0;
   virtual void
   removeMessagesForThreads(const std::vector<std::string> &threadIDs) const = 0;
   virtual void replaceMessage(const Message &message) const = 0;
   virtual void rekeyMessage(std::string from, std::string to) const = 0;
   virtual void removeAllMedia() const = 0;
   virtual void replaceMessageStoreThreads(
       const std::vector<MessageStoreThread> &threads) const = 0;
   virtual void
   removeMessageStoreThreads(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllMessageStoreThreads() const = 0;
   virtual std::vector<MessageStoreThread> getAllMessageStoreThreads() const = 0;
   virtual void
   removeMediaForMessages(const std::vector<std::string> &msgIDs) const = 0;
   virtual void removeMediaForMessage(std::string msgID) const = 0;
   virtual void
   removeMediaForThreads(const std::vector<std::string> &threadIDs) const = 0;
   virtual void replaceMedia(const Media &media) const = 0;
   virtual void rekeyMediaContainers(std::string from, std::string to) const = 0;
   virtual std::vector<Thread> getAllThreads() const = 0;
   virtual void removeThreads(std::vector<std::string> ids) const = 0;
   virtual void replaceThread(const Thread &thread) const = 0;
   virtual void removeAllThreads() const = 0;
   virtual void replaceReport(const Report &report) const = 0;
   virtual void removeReports(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllReports() const = 0;
   virtual std::vector<Report> getAllReports() const = 0;
   virtual void
   setPersistStorageItem(std::string key, std::string item) const = 0;
   virtual void removePersistStorageItem(std::string key) const = 0;
   virtual std::string getPersistStorageItem(std::string key) const = 0;
   virtual void replaceUser(const UserInfo &userInfo) const = 0;
   virtual void removeUsers(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllUsers() const = 0;
   virtual std::vector<UserInfo> getAllUsers() const = 0;
   virtual void replaceKeyserver(const KeyserverInfo &keyserverInfo) const = 0;
   virtual void removeKeyservers(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllKeyservers() const = 0;
   virtual std::vector<KeyserverInfo> getAllKeyservers() const = 0;
   virtual void replaceCommunity(const CommunityInfo &communityInfo) const = 0;
   virtual void removeCommunities(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllCommunities() const = 0;
   virtual std::vector<CommunityInfo> getAllCommunities() const = 0;
   virtual void replaceIntegrityThreadHashes(
       const std::vector<IntegrityThreadHash> &threadHashes) const = 0;
   virtual void
   removeIntegrityThreadHashes(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllIntegrityThreadHashes() const = 0;
   virtual std::vector<IntegrityThreadHash>
   getAllIntegrityThreadHashes() const = 0;
   virtual void replaceSyncedMetadataEntry(
       const SyncedMetadataEntry &syncedMetadataEntry) const = 0;
   virtual void
   removeSyncedMetadata(const std::vector<std::string> &names) const = 0;
   virtual void removeAllSyncedMetadata() const = 0;
   virtual std::vector<SyncedMetadataEntry> getAllSyncedMetadata() const = 0;
   virtual void replaceAuxUserInfo(const AuxUserInfo &userInfo) const = 0;
   virtual void
   removeAuxUserInfos(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllAuxUserInfos() const = 0;
   virtual std::vector<AuxUserInfo> getAllAuxUserInfos() const = 0;
   virtual void replaceThreadActivityEntry(
       const ThreadActivityEntry &threadActivityEntry) const = 0;
   virtual void
   removeThreadActivityEntries(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllThreadActivityEntries() const = 0;
   virtual std::vector<ThreadActivityEntry>
   getAllThreadActivityEntries() const = 0;
   virtual void replaceEntry(const EntryInfo &entryInfo) const = 0;
   virtual void removeEntries(const std::vector<std::string> &ids) const = 0;
   virtual void removeAllEntries() const = 0;
   virtual std::vector<EntryInfo> getAllEntries() const = 0;
   virtual void replaceMessageStoreLocalMessageInfo(
       const LocalMessageInfo &localMessageInfo) const = 0;
   virtual void removeMessageStoreLocalMessageInfos(
       const std::vector<std::string> &ids) const = 0;
   virtual void removeAllMessageStoreLocalMessageInfos() const = 0;
   virtual std::vector<LocalMessageInfo>
   getAllMessageStoreLocalMessageInfos() const = 0;
   virtual void beginTransaction() const = 0;
   virtual void commitTransaction() const = 0;
   virtual void rollbackTransaction() const = 0;
   virtual int getContentAccountID() const = 0;
   virtual int getNotifsAccountID() const = 0;
   virtual std::vector<OlmPersistSession> getOlmPersistSessionsData() const = 0;
   virtual std::optional<std::string>
   getOlmPersistAccountData(int accountID) const = 0;
   virtual void
   storeOlmPersistSession(const OlmPersistSession &session) const = 0;
   virtual void storeOlmPersistAccount(
       int accountID,
       const std::string &accountData) const = 0;
   virtual void
   storeOlmPersistData(int accountID, crypto::Persist persist) const = 0;
   virtual void setNotifyToken(std::string token) const = 0;
   virtual void clearNotifyToken() const = 0;
   virtual void stampSQLiteDBUserID(std::string userID) const = 0;
   virtual std::string getSQLiteStampedUserID() const = 0;
   virtual void setMetadata(std::string entryName, std::string data) const = 0;
   virtual void clearMetadata(std::string entryName) const = 0;
   virtual std::string getMetadata(std::string entryName) const = 0;
   virtual void restoreFromMainCompaction(
       std::string mainCompactionPath,
       std::string mainCompactionEncryptionKey,
       std::string maxVersion) const = 0;
   virtual void
   restoreFromBackupLog(const std::vector<std::uint8_t> &backupLog) const = 0;
   virtual void addOutboundP2PMessages(
       const std::vector<OutboundP2PMessage> &messages) const = 0;
   virtual std::vector<OutboundP2PMessage>
   getOutboundP2PMessagesByID(const std::vector<std::string> &ids) const = 0;
   virtual std::vector<OutboundP2PMessage> getAllOutboundP2PMessages() const = 0;
-  virtual void removeOutboundP2PMessagesOlderThan(
-      std::string lastConfirmedMessageID,
+  virtual void removeOutboundP2PMessage(
+      std::string confirmedMessageID,
       std::string deviceID) const = 0;
   virtual void
   removeAllOutboundP2PMessages(const std::string &deviceID) const = 0;
   virtual void setCiphertextForOutboundP2PMessage(
       std::string messageID,
       std::string deviceID,
       std::string ciphertext) const = 0;
   virtual void markOutboundP2PMessageAsSent(
       std::string messageID,
       std::string deviceID) const = 0;
   virtual std::vector<std::string>
   resetOutboundP2PMessagesForDevice(std::string deviceID) const = 0;
   virtual void addInboundP2PMessage(InboundP2PMessage message) const = 0;
   virtual std::vector<InboundP2PMessage> getAllInboundP2PMessage() const = 0;
   virtual void
   removeInboundP2PMessages(const std::vector<std::string> &ids) const = 0;
   virtual std::vector<MessageEntity>
   getRelatedMessages(const std::string &messageID) const = 0;
   virtual void updateMessageSearchIndex(
       std::string originalMessageID,
       std::string messageID,
       std::string processedContent) const = 0;
   virtual std::vector<MessageEntity> searchMessages(
       std::string query,
       std::string threadID,
       std::optional<std::string> timestampCursor,
       std::optional<std::string> messageIDCursor) const = 0;
   virtual std::vector<MessageEntity> getRelatedMessagesForSearch(
       const std::vector<std::string> &messageIDs) const = 0;
 
 #ifdef EMSCRIPTEN
   virtual std::vector<WebThread> getAllThreadsWeb() const = 0;
   virtual void replaceThreadWeb(const WebThread &thread) const = 0;
   virtual std::vector<MessageWithMedias> getAllMessagesWeb() const = 0;
   virtual void replaceMessageWeb(const WebMessage &message) const = 0;
   virtual NullableString getOlmPersistAccountDataWeb(int accountID) const = 0;
   virtual std::vector<MessageWithMedias>
   getRelatedMessagesWeb(const std::string &messageID) const = 0;
   virtual std::vector<MessageWithMedias> searchMessagesWeb(
       std::string query,
       std::string threadID,
       std::optional<std::string> timestampCursor,
       std::optional<std::string> messageIDCursor) const = 0;
 #else
   virtual void createMainCompaction(std::string backupID) const = 0;
   virtual void captureBackupLogs() const = 0;
 #endif
 };
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp b/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
index 29d9e477e..c6e6c9744 100644
--- a/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
+++ b/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
@@ -1,3187 +1,3182 @@
 #include "SQLiteQueryExecutor.h"
 #include "Logger.h"
 
 #include "../NativeModules/PersistentStorageUtilities/MessageOperationsUtilities/MessageTypeEnum.h"
 #include "entities/CommunityInfo.h"
 #include "entities/EntityQueryHelpers.h"
 #include "entities/EntryInfo.h"
 #include "entities/IntegrityThreadHash.h"
 #include "entities/KeyserverInfo.h"
 #include "entities/LocalMessageInfo.h"
 #include "entities/Metadata.h"
 #include "entities/SQLiteDataConverters.h"
 #include "entities/SyncedMetadataEntry.h"
 #include "entities/UserInfo.h"
 #include <fstream>
 #include <iostream>
 #include <thread>
 
 #ifndef EMSCRIPTEN
 #include "../CryptoTools/CryptoModule.h"
 #include "CommSecureStore.h"
 #include "PlatformSpecificTools.h"
 #include "StaffUtils.h"
 #endif
 
 const int CONTENT_ACCOUNT_ID = 1;
 const int NOTIFS_ACCOUNT_ID = 2;
 
 namespace comm {
 
 std::string SQLiteQueryExecutor::sqliteFilePath;
 std::string SQLiteQueryExecutor::encryptionKey;
 std::once_flag SQLiteQueryExecutor::initialized;
 int SQLiteQueryExecutor::sqlcipherEncryptionKeySize = 64;
 // Should match constant defined in `native_rust_library/src/constants.rs`
 std::string SQLiteQueryExecutor::secureStoreEncryptionKeyID =
     "comm.encryptionKey";
 int SQLiteQueryExecutor::backupLogsEncryptionKeySize = 32;
 std::string SQLiteQueryExecutor::secureStoreBackupLogsEncryptionKeyID =
     "comm.backupLogsEncryptionKey";
 std::string SQLiteQueryExecutor::backupLogsEncryptionKey;
 
 #ifndef EMSCRIPTEN
 NativeSQLiteConnectionManager SQLiteQueryExecutor::connectionManager;
 std::unordered_set<std::string> SQLiteQueryExecutor::backedUpTablesBlocklist = {
     "olm_persist_account",
     "olm_persist_sessions",
     "metadata",
     "outbound_p2p_messages",
     "inbound_p2p_messages",
     "integrity_store",
     "persist_storage",
     "keyservers",
 };
 #else
 SQLiteConnectionManager SQLiteQueryExecutor::connectionManager;
 #endif
 
 bool create_table(sqlite3 *db, std::string query, std::string tableName) {
   char *error;
   sqlite3_exec(db, query.c_str(), nullptr, nullptr, &error);
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error creating '" << tableName << "' table: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool create_drafts_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS drafts (threadID TEXT UNIQUE PRIMARY KEY, "
       "text TEXT);";
   return create_table(db, query, "drafts");
 }
 
 bool rename_threadID_to_key(sqlite3 *db) {
   sqlite3_stmt *key_column_stmt;
   sqlite3_prepare_v2(
       db,
       "SELECT name AS col_name FROM pragma_table_xinfo ('drafts') WHERE "
       "col_name='key';",
       -1,
       &key_column_stmt,
       nullptr);
   sqlite3_step(key_column_stmt);
 
   auto num_bytes = sqlite3_column_bytes(key_column_stmt, 0);
   sqlite3_finalize(key_column_stmt);
   if (num_bytes) {
     return true;
   }
 
   char *error;
   sqlite3_exec(
       db,
       "ALTER TABLE drafts RENAME COLUMN `threadID` TO `key`;",
       nullptr,
       nullptr,
       &error);
   if (error) {
     std::ostringstream stringStream;
     stringStream << "Error occurred renaming threadID column in drafts table "
                  << "to key: " << error;
     Logger::log(stringStream.str());
     sqlite3_free(error);
     return false;
   }
   return true;
 }
 
 bool create_persist_account_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS olm_persist_account("
       "id INTEGER UNIQUE PRIMARY KEY NOT NULL, "
       "account_data TEXT NOT NULL);";
   return create_table(db, query, "olm_persist_account");
 }
 
 bool create_persist_sessions_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS olm_persist_sessions("
       "target_user_id TEXT UNIQUE PRIMARY KEY NOT NULL, "
       "session_data TEXT NOT NULL);";
   return create_table(db, query, "olm_persist_sessions");
 }
 
 bool drop_messages_table(sqlite3 *db) {
   char *error;
   sqlite3_exec(db, "DROP TABLE IF EXISTS messages;", nullptr, nullptr, &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error dropping 'messages' table: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool recreate_messages_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS messages ( "
       "id TEXT UNIQUE PRIMARY KEY NOT NULL, "
       "local_id TEXT, "
       "thread TEXT NOT NULL, "
       "user TEXT NOT NULL, "
       "type INTEGER NOT NULL, "
       "future_type INTEGER, "
       "content TEXT, "
       "time INTEGER NOT NULL);";
   return create_table(db, query, "messages");
 }
 
 bool create_messages_idx_thread_time(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "CREATE INDEX IF NOT EXISTS messages_idx_thread_time "
       "ON messages (thread, time);",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error creating (thread, time) index on messages table: "
                << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool create_messages_idx_target_message_type_time(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "ALTER TABLE messages "
       "  ADD COLUMN target_message TEXT "
       "  AS (IIF( "
       "    JSON_VALID(content), "
       "    JSON_EXTRACT(content, '$.targetMessageID'), "
       "    NULL "
       "  )); "
       "CREATE INDEX IF NOT EXISTS messages_idx_target_message_type_time "
       "  ON messages (target_message, type, time);",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream
       << "Error creating (target_message, type, time) index on messages table: "
       << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool update_messages_idx_target_message_type_time(sqlite3 *db) {
   char *error;
   int sidebarSourceTypeInt = static_cast<int>(MessageType::SIDEBAR_SOURCE);
   std::string sidebarSourceType = std::to_string(sidebarSourceTypeInt);
 
   auto query =
       "DROP INDEX IF EXISTS messages_idx_target_message_type_time;"
       "ALTER TABLE messages DROP COLUMN target_message;"
       "ALTER TABLE messages "
       "  ADD COLUMN target_message TEXT "
       "  AS (IIF("
       "    JSON_VALID(content),"
       "    COALESCE("
       "      JSON_EXTRACT(content, '$.targetMessageID'),"
       "      IIF("
       "        type = " +
       sidebarSourceType +
       "        , JSON_EXTRACT(content, '$.id'),"
       "        NULL"
       "      )"
       "    ),"
       "    NULL"
       "  ));"
       "CREATE INDEX IF NOT EXISTS messages_idx_target_message_type_time "
       "  ON messages (target_message, type, time);";
 
   sqlite3_exec(db, query.c_str(), nullptr, nullptr, &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream
       << "Error creating (target_message, type, time) index on messages table: "
       << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool create_media_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS media ( "
       "id TEXT UNIQUE PRIMARY KEY NOT NULL, "
       "container TEXT NOT NULL, "
       "thread TEXT NOT NULL, "
       "uri TEXT NOT NULL, "
       "type TEXT NOT NULL, "
       "extras TEXT NOT NULL);";
   return create_table(db, query, "media");
 }
 
 bool create_media_idx_container(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "CREATE INDEX IF NOT EXISTS media_idx_container "
       "ON media (container);",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error creating (container) index on media table: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool create_threads_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS threads ( "
       "id TEXT UNIQUE PRIMARY KEY NOT NULL, "
       "type INTEGER NOT NULL, "
       "name TEXT, "
       "description TEXT, "
       "color TEXT NOT NULL, "
       "creation_time BIGINT NOT NULL, "
       "parent_thread_id TEXT, "
       "containing_thread_id TEXT, "
       "community TEXT, "
       "members TEXT NOT NULL, "
       "roles TEXT NOT NULL, "
       "current_user TEXT NOT NULL, "
       "source_message_id TEXT, "
       "replies_count INTEGER NOT NULL);";
   return create_table(db, query, "threads");
 }
 
 bool update_threadID_for_pending_threads_in_drafts(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "UPDATE drafts SET key = "
       "REPLACE(REPLACE(REPLACE(REPLACE(key, 'type4/', ''),"
       "'type5/', ''),'type6/', ''),'type7/', '')"
       "WHERE key LIKE 'pending/%'",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error update pending threadIDs on drafts table: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool enable_write_ahead_logging_mode(sqlite3 *db) {
   char *error;
   sqlite3_exec(db, "PRAGMA journal_mode=wal;", nullptr, nullptr, &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error enabling write-ahead logging mode: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool create_metadata_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS metadata ( "
       "name TEXT UNIQUE PRIMARY KEY NOT NULL, "
       "data TEXT);";
   return create_table(db, query, "metadata");
 }
 
 bool add_not_null_constraint_to_drafts(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "CREATE TABLE IF NOT EXISTS temporary_drafts ("
       "key TEXT UNIQUE PRIMARY KEY NOT NULL, "
       "text TEXT NOT NULL);"
       "INSERT INTO temporary_drafts SELECT * FROM drafts "
       "WHERE key IS NOT NULL AND text IS NOT NULL;"
       "DROP TABLE drafts;"
       "ALTER TABLE temporary_drafts RENAME TO drafts;",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error adding NOT NULL constraint to drafts table: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool add_not_null_constraint_to_metadata(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "CREATE TABLE IF NOT EXISTS temporary_metadata ("
       "name TEXT UNIQUE PRIMARY KEY NOT NULL, "
       "data TEXT NOT NULL);"
       "INSERT INTO temporary_metadata SELECT * FROM metadata "
       "WHERE data IS NOT NULL;"
       "DROP TABLE metadata;"
       "ALTER TABLE temporary_metadata RENAME TO metadata;",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error adding NOT NULL constraint to metadata table: "
                << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool add_avatar_column_to_threads_table(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "ALTER TABLE threads ADD COLUMN avatar TEXT;",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error adding avatar column to threads table: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool add_pinned_count_column_to_threads(sqlite3 *db) {
   sqlite3_stmt *pinned_column_stmt;
   sqlite3_prepare_v2(
       db,
       "SELECT name AS col_name FROM pragma_table_xinfo ('threads') WHERE "
       "col_name='pinned_count';",
       -1,
       &pinned_column_stmt,
       nullptr);
   sqlite3_step(pinned_column_stmt);
 
   auto num_bytes = sqlite3_column_bytes(pinned_column_stmt, 0);
   sqlite3_finalize(pinned_column_stmt);
 
   if (num_bytes) {
     return true;
   }
 
   char *error;
   sqlite3_exec(
       db,
       "ALTER TABLE threads ADD COLUMN pinned_count INTEGER NOT NULL DEFAULT 0;",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error adding pinned_count column to threads table: "
                << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool create_message_store_threads_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS message_store_threads ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  start_reached INTEGER NOT NULL,"
       "  last_navigated_to BIGINT NOT NULL,"
       "  last_pruned BIGINT NOT NULL"
       ");";
   return create_table(db, query, "message_store_threads");
 }
 
 bool create_reports_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS reports ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  report TEXT NOT NULL"
       ");";
   return create_table(db, query, "reports");
 }
 
 bool create_persist_storage_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS persist_storage ("
       "  key TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  item TEXT NOT NULL"
       ");";
   return create_table(db, query, "persist_storage");
 }
 
 bool recreate_message_store_threads_table(sqlite3 *db) {
   char *errMsg = 0;
 
   // 1. Create table without `last_navigated_to` or `last_pruned`.
   std::string create_new_table_query =
       "CREATE TABLE IF NOT EXISTS temp_message_store_threads ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  start_reached INTEGER NOT NULL"
       ");";
 
   if (sqlite3_exec(db, create_new_table_query.c_str(), NULL, NULL, &errMsg) !=
       SQLITE_OK) {
     Logger::log(
         "Error creating temp_message_store_threads: " + std::string{errMsg});
     sqlite3_free(errMsg);
     return false;
   }
 
   // 2. Dump data from existing `message_store_threads` table into temp table.
   std::string copy_data_query =
       "INSERT INTO temp_message_store_threads (id, start_reached)"
       "SELECT id, start_reached FROM message_store_threads;";
 
   if (sqlite3_exec(db, copy_data_query.c_str(), NULL, NULL, &errMsg) !=
       SQLITE_OK) {
     Logger::log(
         "Error dumping data from existing message_store_threads to "
         "temp_message_store_threads: " +
         std::string{errMsg});
     sqlite3_free(errMsg);
     return false;
   }
 
   // 3. Drop the existing `message_store_threads` table.
   std::string drop_old_table_query = "DROP TABLE message_store_threads;";
 
   if (sqlite3_exec(db, drop_old_table_query.c_str(), NULL, NULL, &errMsg) !=
       SQLITE_OK) {
     Logger::log(
         "Error dropping message_store_threads table: " + std::string{errMsg});
     sqlite3_free(errMsg);
     return false;
   }
 
   // 4. Rename the temp table back to `message_store_threads`.
   std::string rename_table_query =
       "ALTER TABLE temp_message_store_threads RENAME TO message_store_threads;";
 
   if (sqlite3_exec(db, rename_table_query.c_str(), NULL, NULL, &errMsg) !=
       SQLITE_OK) {
     Logger::log(
         "Error renaming temp_message_store_threads to message_store_threads: " +
         std::string{errMsg});
     sqlite3_free(errMsg);
     return false;
   }
 
   return true;
 }
 
 bool create_users_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS users ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  user_info TEXT NOT NULL"
       ");";
   return create_table(db, query, "users");
 }
 
 bool create_keyservers_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS keyservers ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  keyserver_info TEXT NOT NULL"
       ");";
   return create_table(db, query, "keyservers");
 }
 
 bool enable_rollback_journal_mode(sqlite3 *db) {
   char *error;
   sqlite3_exec(db, "PRAGMA journal_mode=DELETE;", nullptr, nullptr, &error);
 
   if (!error) {
     return true;
   }
 
   std::stringstream error_message;
   error_message << "Error disabling write-ahead logging mode: " << error;
   Logger::log(error_message.str());
   sqlite3_free(error);
   return false;
 }
 
 bool create_communities_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS communities ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  community_info TEXT NOT NULL"
       ");";
   return create_table(db, query, "communities");
 }
 
 bool create_messages_to_device_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS messages_to_device ("
       "  message_id TEXT NOT NULL,"
       "  device_id TEXT NOT NULL,"
       "  user_id TEXT NOT NULL,"
       "  timestamp BIGINT NOT NULL,"
       "  plaintext TEXT NOT NULL,"
       "  ciphertext TEXT NOT NULL,"
       "  PRIMARY KEY (message_id, device_id)"
       ");"
 
       "CREATE INDEX IF NOT EXISTS messages_to_device_idx_id_timestamp"
       "  ON messages_to_device (device_id, timestamp);";
 
   return create_table(db, query, "messages_to_device");
 }
 
 bool create_integrity_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS integrity_store ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  thread_hash TEXT NOT NULL"
       ");";
   return create_table(db, query, "integrity_store");
 }
 
 bool create_synced_metadata_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS synced_metadata ("
       "  name TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  data TEXT NOT NULL"
       ");";
   return create_table(db, query, "synced_metadata");
 }
 
 bool create_keyservers_synced(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS keyservers_synced ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  keyserver_info TEXT NOT NULL"
       ");";
   bool success = create_table(db, query, "keyservers_synced");
   if (!success) {
     return false;
   }
 
   std::string copyData =
       "INSERT INTO keyservers_synced (id, keyserver_info)"
       "SELECT id, keyserver_info "
       "FROM keyservers;";
 
   char *error;
   sqlite3_exec(db, copyData.c_str(), nullptr, nullptr, &error);
   if (error) {
     return false;
   }
 
   return true;
 }
 
 bool create_aux_user_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS aux_users ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  aux_user_info TEXT NOT NULL"
       ");";
   return create_table(db, query, "aux_users");
 }
 
 bool add_version_column_to_olm_persist_sessions_table(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "ALTER TABLE olm_persist_sessions "
       "  RENAME COLUMN `target_user_id` TO `target_device_id`; "
       "ALTER TABLE olm_persist_sessions "
       "  ADD COLUMN version INTEGER NOT NULL DEFAULT 1;",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error updating olm_persist_sessions table: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool create_thread_activity_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS thread_activity ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  thread_activity_store_entry TEXT NOT NULL"
       ");";
   return create_table(db, query, "thread_activity");
 }
 
 bool create_received_messages_to_device(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS received_messages_to_device ("
       "  id INTEGER PRIMARY KEY,"
       "  message_id TEXT NOT NULL,"
       "  sender_device_id TEXT NOT NULL,"
       "  plaintext TEXT NOT NULL,"
       "  status TEXT NOT NULL"
       ");";
   return create_table(db, query, "received_messages_to_device");
 }
 
 bool recreate_outbound_p2p_messages_table(sqlite3 *db) {
   std::string query =
       "DROP TABLE IF EXISTS messages_to_device;"
       "CREATE TABLE IF NOT EXISTS outbound_p2p_messages ("
       "  message_id TEXT NOT NULL,"
       "  device_id TEXT NOT NULL,"
       "  user_id TEXT NOT NULL,"
       "  timestamp BIGINT NOT NULL,"
       "  plaintext TEXT NOT NULL,"
       "  ciphertext TEXT NOT NULL,"
       "  status TEXT NOT NULL,"
       "  PRIMARY KEY (message_id, device_id)"
       ");"
 
       "CREATE INDEX IF NOT EXISTS outbound_p2p_messages_idx_id_timestamp"
       "  ON outbound_p2p_messages (device_id, timestamp);";
 
   return create_table(db, query, "outbound_p2p_messages");
 }
 
 bool create_entries_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS entries ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  entry TEXT NOT NULL"
       ");";
   return create_table(db, query, "entries");
 }
 
 bool create_message_store_local_table(sqlite3 *db) {
   std::string query =
       "CREATE TABLE IF NOT EXISTS message_store_local ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  local_message_info TEXT NOT NULL"
       ");";
   return create_table(db, query, "message_store_local");
 }
 
 bool add_supports_auto_retry_column_to_p2p_messages_table(sqlite3 *db) {
   char *error;
   sqlite3_exec(
       db,
       "ALTER TABLE outbound_p2p_messages"
       "  ADD COLUMN supports_auto_retry INTEGER DEFAULT 0",
       nullptr,
       nullptr,
       &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error updating outbound_p2p_messages table: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 bool create_message_search_table(sqlite3 *db) {
   std::string query =
       "CREATE VIRTUAL TABLE IF NOT EXISTS message_search USING fts5("
       "  original_message_id UNINDEXED,"
       "  message_id UNINDEXED,"
       "  processed_content,"
       "  tokenize = porter"
       ");";
   return create_table(db, query, "message_search");
 }
 
 bool recreate_inbound_p2p_messages_table(sqlite3 *db) {
   std::string query =
       "DROP TABLE IF EXISTS received_messages_to_device;"
       "CREATE TABLE IF NOT EXISTS inbound_p2p_messages ("
       "  id INTEGER PRIMARY KEY,"
       "  message_id TEXT NOT NULL,"
       "  sender_device_id TEXT NOT NULL,"
       "  plaintext TEXT NOT NULL,"
       "  status TEXT NOT NULL,"
       "  sender_user_id TEXT NOT NULL"
       ");";
 
   return create_table(db, query, "inbound_p2p_messages");
 }
 
 bool create_schema(sqlite3 *db) {
   char *error;
   int sidebarSourceTypeInt = static_cast<int>(MessageType::SIDEBAR_SOURCE);
   std::string sidebarSourceType = std::to_string(sidebarSourceTypeInt);
   auto query =
       "CREATE TABLE IF NOT EXISTS drafts ("
       "  key TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  text TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS messages ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  local_id TEXT,"
       "  thread TEXT NOT NULL,"
       "  user TEXT NOT NULL,"
       "  type INTEGER NOT NULL,"
       "  future_type INTEGER,"
       "  content TEXT,"
       "  time INTEGER NOT NULL,"
       "  target_message TEXT AS ("
       "    IIF("
       "      JSON_VALID(content),"
       "      COALESCE("
       "        JSON_EXTRACT(content, '$.targetMessageID'),"
       "        IIF("
       "          type = " +
       sidebarSourceType +
       "          , JSON_EXTRACT(content, '$.id'),"
       "          NULL"
       "        )"
       "      ),"
       "      NULL"
       "    )"
       "  )"
       ");"
 
       "CREATE TABLE IF NOT EXISTS olm_persist_account ("
       "  id INTEGER UNIQUE PRIMARY KEY NOT NULL,"
       "  account_data TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS olm_persist_sessions ("
       "  target_device_id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  session_data TEXT NOT NULL,"
       "  version INTEGER NOT NULL DEFAULT 1"
       ");"
 
       "CREATE TABLE IF NOT EXISTS media ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  container TEXT NOT NULL,"
       "  thread TEXT NOT NULL,"
       "  uri TEXT NOT NULL,"
       "  type TEXT NOT NULL,"
       "  extras TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS threads ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  type INTEGER NOT NULL,"
       "  name TEXT,"
       "  description TEXT,"
       "  color TEXT NOT NULL,"
       "  creation_time BIGINT NOT NULL,"
       "  parent_thread_id TEXT,"
       "  containing_thread_id TEXT,"
       "  community TEXT,"
       "  members TEXT NOT NULL,"
       "  roles TEXT NOT NULL,"
       "  current_user TEXT NOT NULL,"
       "  source_message_id TEXT,"
       "  replies_count INTEGER NOT NULL,"
       "  avatar TEXT,"
       "  pinned_count INTEGER NOT NULL DEFAULT 0"
       ");"
 
       "CREATE TABLE IF NOT EXISTS metadata ("
       "  name TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  data TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS message_store_threads ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  start_reached INTEGER NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS reports ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  report TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS persist_storage ("
       "  key TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  item TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS users ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  user_info TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS keyservers ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  keyserver_info TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS keyservers_synced ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  keyserver_info TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS communities ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  community_info TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS outbound_p2p_messages ("
       "  message_id TEXT NOT NULL,"
       "  device_id TEXT NOT NULL,"
       "  user_id TEXT NOT NULL,"
       "  timestamp BIGINT NOT NULL,"
       "  plaintext TEXT NOT NULL,"
       "  ciphertext TEXT NOT NULL,"
       "  status TEXT NOT NULL,"
       "  supports_auto_retry INTEGER DEFAULT 0,"
       "  PRIMARY KEY (message_id, device_id)"
       ");"
 
       "CREATE TABLE IF NOT EXISTS integrity_store ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  thread_hash TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS synced_metadata ("
       "  name TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  data TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS aux_users ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  aux_user_info TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS thread_activity ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  thread_activity_store_entry TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS inbound_p2p_messages ("
       "  id INTEGER PRIMARY KEY,"
       "  message_id TEXT NOT NULL,"
       "  sender_device_id TEXT NOT NULL,"
       "  plaintext TEXT NOT NULL,"
       "  status TEXT NOT NULL,"
       "  sender_user_id TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS entries ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  entry TEXT NOT NULL"
       ");"
 
       "CREATE TABLE IF NOT EXISTS message_store_local ("
       "  id TEXT UNIQUE PRIMARY KEY NOT NULL,"
       "  local_message_info TEXT NOT NULL"
       ");"
 
       "CREATE VIRTUAL TABLE IF NOT EXISTS message_search USING fts5("
       "  original_message_id UNINDEXED,"
       "  message_id UNINDEXED,"
       "  processed_content,"
       "  tokenize = porter"
       ");"
 
       "CREATE INDEX IF NOT EXISTS media_idx_container"
       "  ON media (container);"
 
       "CREATE INDEX IF NOT EXISTS messages_idx_thread_time"
       "  ON messages (thread, time);"
 
       "CREATE INDEX IF NOT EXISTS messages_idx_target_message_type_time"
       "  ON messages (target_message, type, time);"
 
       "CREATE INDEX IF NOT EXISTS outbound_p2p_messages_idx_id_timestamp"
       "  ON outbound_p2p_messages (device_id, timestamp);";
 
   sqlite3_exec(db, query.c_str(), nullptr, nullptr, &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream stringStream;
   stringStream << "Error creating tables: " << error;
   Logger::log(stringStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 void set_encryption_key(
     sqlite3 *db,
     const std::string &encryptionKey = SQLiteQueryExecutor::encryptionKey) {
   std::string set_encryption_key_query =
       "PRAGMA key = \"x'" + encryptionKey + "'\";";
 
   char *error_set_key;
   sqlite3_exec(
       db, set_encryption_key_query.c_str(), nullptr, nullptr, &error_set_key);
 
   if (error_set_key) {
     std::ostringstream error_message;
     error_message << "Failed to set encryption key: " << error_set_key;
     throw std::system_error(
         ECANCELED, std::generic_category(), error_message.str());
   }
 }
 
 int get_database_version(sqlite3 *db) {
   sqlite3_stmt *user_version_stmt;
   sqlite3_prepare_v2(
       db, "PRAGMA user_version;", -1, &user_version_stmt, nullptr);
   sqlite3_step(user_version_stmt);
 
   int current_user_version = sqlite3_column_int(user_version_stmt, 0);
   sqlite3_finalize(user_version_stmt);
   return current_user_version;
 }
 
 bool set_database_version(sqlite3 *db, int db_version) {
   std::stringstream update_version;
   update_version << "PRAGMA user_version=" << db_version << ";";
   auto update_version_str = update_version.str();
 
   char *error;
   sqlite3_exec(db, update_version_str.c_str(), nullptr, nullptr, &error);
 
   if (!error) {
     return true;
   }
 
   std::ostringstream errorStream;
   errorStream << "Error setting database version to " << db_version << ": "
               << error;
   Logger::log(errorStream.str());
 
   sqlite3_free(error);
   return false;
 }
 
 // We don't want to run `PRAGMA key = ...;`
 // on main web database. The context is here:
 // https://linear.app/comm/issue/ENG-6398/issues-with-sqlcipher-on-web
 void default_on_db_open_callback(sqlite3 *db) {
 #ifndef EMSCRIPTEN
   set_encryption_key(db);
 #endif
 }
 
 // This is a temporary solution. In future we want to keep
 // a separate table for blob hashes. Tracked on Linear:
 // https://linear.app/comm/issue/ENG-6261/introduce-blob-hash-table
 std::string blob_hash_from_blob_service_uri(const std::string &media_uri) {
   static const std::string blob_service_prefix = "comm-blob-service://";
   return media_uri.substr(blob_service_prefix.size());
 }
 
 bool file_exists(const std::string &file_path) {
   std::ifstream file(file_path.c_str());
   return file.good();
 }
 
 void attempt_delete_file(
     const std::string &file_path,
     const char *error_message) {
   if (std::remove(file_path.c_str())) {
     throw std::system_error(errno, std::generic_category(), error_message);
   }
 }
 
 void attempt_rename_file(
     const std::string &old_path,
     const std::string &new_path,
     const char *error_message) {
   if (std::rename(old_path.c_str(), new_path.c_str())) {
     throw std::system_error(errno, std::generic_category(), error_message);
   }
 }
 
 bool is_database_queryable(
     sqlite3 *db,
     bool use_encryption_key,
     const std::string &path = SQLiteQueryExecutor::sqliteFilePath,
     const std::string &encryptionKey = SQLiteQueryExecutor::encryptionKey) {
   char *err_msg;
   sqlite3_open(path.c_str(), &db);
   // According to SQLCipher documentation running some SELECT is the only way to
   // check for key validity
   if (use_encryption_key) {
     set_encryption_key(db, encryptionKey);
   }
   sqlite3_exec(
       db, "SELECT COUNT(*) FROM sqlite_master;", nullptr, nullptr, &err_msg);
   sqlite3_close(db);
   return !err_msg;
 }
 
 void validate_encryption() {
   std::string temp_encrypted_db_path =
       SQLiteQueryExecutor::sqliteFilePath + "_temp_encrypted";
 
   bool temp_encrypted_exists = file_exists(temp_encrypted_db_path);
   bool default_location_exists =
       file_exists(SQLiteQueryExecutor::sqliteFilePath);
 
   if (temp_encrypted_exists && default_location_exists) {
     Logger::log(
         "Previous encryption attempt failed. Repeating encryption process from "
         "the beginning.");
     attempt_delete_file(
         temp_encrypted_db_path,
         "Failed to delete corrupted encrypted database.");
   } else if (temp_encrypted_exists && !default_location_exists) {
     Logger::log(
         "Moving temporary encrypted database to default location failed in "
         "previous encryption attempt. Repeating rename step.");
     attempt_rename_file(
         temp_encrypted_db_path,
         SQLiteQueryExecutor::sqliteFilePath,
         "Failed to move encrypted database to default location.");
     return;
   } else if (!default_location_exists) {
     Logger::log(
         "Database not present yet. It will be created encrypted under default "
         "path.");
     return;
   }
 
   sqlite3 *db;
   if (is_database_queryable(db, true)) {
     Logger::log(
         "Database exists under default path and it is correctly encrypted.");
     return;
   }
 
   if (!is_database_queryable(db, false)) {
     Logger::log(
         "Database exists but it is encrypted with key that was lost. "
         "Attempting database deletion. New encrypted one will be created.");
     attempt_delete_file(
         SQLiteQueryExecutor::sqliteFilePath.c_str(),
         "Failed to delete database encrypted with lost key.");
     return;
   } else {
     Logger::log(
         "Database exists but it is not encrypted. Attempting encryption "
         "process.");
   }
   sqlite3_open(SQLiteQueryExecutor::sqliteFilePath.c_str(), &db);
 
   std::string createEncryptedCopySQL = "ATTACH DATABASE '" +
       temp_encrypted_db_path +
       "' AS encrypted_comm "
       "KEY \"x'" +
       SQLiteQueryExecutor::encryptionKey +
       "'\";"
       "SELECT sqlcipher_export('encrypted_comm');"
       "DETACH DATABASE encrypted_comm;";
 
   char *encryption_error;
   sqlite3_exec(
       db, createEncryptedCopySQL.c_str(), nullptr, nullptr, &encryption_error);
 
   if (encryption_error) {
     throw std::system_error(
         ECANCELED,
         std::generic_category(),
         "Failed to create encrypted copy of the original database.");
   }
   sqlite3_close(db);
 
   attempt_delete_file(
       SQLiteQueryExecutor::sqliteFilePath,
       "Failed to delete unencrypted database.");
   attempt_rename_file(
       temp_encrypted_db_path,
       SQLiteQueryExecutor::sqliteFilePath,
       "Failed to move encrypted database to default location.");
   Logger::log("Encryption completed successfully.");
 }
 
 typedef bool ShouldBeInTransaction;
 typedef std::function<bool(sqlite3 *)> MigrateFunction;
 typedef std::pair<MigrateFunction, ShouldBeInTransaction> SQLiteMigration;
 std::vector<std::pair<unsigned int, SQLiteMigration>> migrations{
     {{1, {create_drafts_table, true}},
      {2, {rename_threadID_to_key, true}},
      {4, {create_persist_account_table, true}},
      {5, {create_persist_sessions_table, true}},
      {15, {create_media_table, true}},
      {16, {drop_messages_table, true}},
      {17, {recreate_messages_table, true}},
      {18, {create_messages_idx_thread_time, true}},
      {19, {create_media_idx_container, true}},
      {20, {create_threads_table, true}},
      {21, {update_threadID_for_pending_threads_in_drafts, true}},
      {22, {enable_write_ahead_logging_mode, false}},
      {23, {create_metadata_table, true}},
      {24, {add_not_null_constraint_to_drafts, true}},
      {25, {add_not_null_constraint_to_metadata, true}},
      {26, {add_avatar_column_to_threads_table, true}},
      {27, {add_pinned_count_column_to_threads, true}},
      {28, {create_message_store_threads_table, true}},
      {29, {create_reports_table, true}},
      {30, {create_persist_storage_table, true}},
      {31, {recreate_message_store_threads_table, true}},
      {32, {create_users_table, true}},
      {33, {create_keyservers_table, true}},
      {34, {enable_rollback_journal_mode, false}},
      {35, {create_communities_table, true}},
      {36, {create_messages_to_device_table, true}},
      {37, {create_integrity_table, true}},
      {38, {[](sqlite3 *) { return true; }, false}},
      {39, {create_synced_metadata_table, true}},
      {40, {create_keyservers_synced, true}},
      {41, {create_aux_user_table, true}},
      {42, {add_version_column_to_olm_persist_sessions_table, true}},
      {43, {create_thread_activity_table, true}},
      {44, {create_received_messages_to_device, true}},
      {45, {recreate_outbound_p2p_messages_table, true}},
      {46, {create_entries_table, true}},
      {47, {create_message_store_local_table, true}},
      {48, {create_messages_idx_target_message_type_time, true}},
      {49, {add_supports_auto_retry_column_to_p2p_messages_table, true}},
      {50, {create_message_search_table, true}},
      {51, {update_messages_idx_target_message_type_time, true}},
      {52, {recreate_inbound_p2p_messages_table, true}}}};
 
 enum class MigrationResult { SUCCESS, FAILURE, NOT_APPLIED };
 
 MigrationResult applyMigrationWithTransaction(
     sqlite3 *db,
     const MigrateFunction &migrate,
     int index) {
   sqlite3_exec(db, "BEGIN TRANSACTION;", nullptr, nullptr, nullptr);
   auto db_version = get_database_version(db);
   if (index <= db_version) {
     sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
     return MigrationResult::NOT_APPLIED;
   }
   auto rc = migrate(db);
   if (!rc) {
     sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
     return MigrationResult::FAILURE;
   }
   auto database_version_set = set_database_version(db, index);
   if (!database_version_set) {
     sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
     return MigrationResult::FAILURE;
   }
   sqlite3_exec(db, "END TRANSACTION;", nullptr, nullptr, nullptr);
   return MigrationResult::SUCCESS;
 }
 
 MigrationResult applyMigrationWithoutTransaction(
     sqlite3 *db,
     const MigrateFunction &migrate,
     int index) {
   auto db_version = get_database_version(db);
   if (index <= db_version) {
     return MigrationResult::NOT_APPLIED;
   }
   auto rc = migrate(db);
   if (!rc) {
     return MigrationResult::FAILURE;
   }
   sqlite3_exec(db, "BEGIN TRANSACTION;", nullptr, nullptr, nullptr);
   auto inner_db_version = get_database_version(db);
   if (index <= inner_db_version) {
     sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
     return MigrationResult::NOT_APPLIED;
   }
   auto database_version_set = set_database_version(db, index);
   if (!database_version_set) {
     sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
     return MigrationResult::FAILURE;
   }
   sqlite3_exec(db, "END TRANSACTION;", nullptr, nullptr, nullptr);
   return MigrationResult::SUCCESS;
 }
 
 bool set_up_database(sqlite3 *db) {
   sqlite3_exec(db, "BEGIN TRANSACTION;", nullptr, nullptr, nullptr);
   auto db_version = get_database_version(db);
   auto latest_version = migrations.back().first;
   if (db_version == latest_version) {
     sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
     return true;
   }
   if (db_version != 0 || !create_schema(db) ||
       !set_database_version(db, latest_version)) {
     sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
     return false;
   }
   sqlite3_exec(db, "END TRANSACTION;", nullptr, nullptr, nullptr);
   return true;
 }
 
 void SQLiteQueryExecutor::migrate() {
 // We don't want to run `PRAGMA key = ...;`
 // on main web database. The context is here:
 // https://linear.app/comm/issue/ENG-6398/issues-with-sqlcipher-on-web
 #ifndef EMSCRIPTEN
   validate_encryption();
 #endif
 
   sqlite3 *db;
   sqlite3_open(SQLiteQueryExecutor::sqliteFilePath.c_str(), &db);
   default_on_db_open_callback(db);
 
   std::stringstream db_path;
   db_path << "db path: " << SQLiteQueryExecutor::sqliteFilePath.c_str()
           << std::endl;
   Logger::log(db_path.str());
 
   auto db_version = get_database_version(db);
   std::stringstream version_msg;
   version_msg << "db version: " << db_version << std::endl;
   Logger::log(version_msg.str());
 
   if (db_version == 0) {
     auto db_created = set_up_database(db);
     if (!db_created) {
       sqlite3_close(db);
       Logger::log("Database structure creation error.");
       throw std::runtime_error("Database structure creation error");
     }
     Logger::log("Database structure created.");
 
     sqlite3_close(db);
     return;
   }
 
   for (const auto &[idx, migration] : migrations) {
     const auto &[applyMigration, shouldBeInTransaction] = migration;
 
     MigrationResult migrationResult;
     if (shouldBeInTransaction) {
       migrationResult = applyMigrationWithTransaction(db, applyMigration, idx);
     } else {
       migrationResult =
           applyMigrationWithoutTransaction(db, applyMigration, idx);
     }
 
     if (migrationResult == MigrationResult::NOT_APPLIED) {
       continue;
     }
 
     std::stringstream migration_msg;
     if (migrationResult == MigrationResult::FAILURE) {
       migration_msg << "migration " << idx << " failed." << std::endl;
       Logger::log(migration_msg.str());
       sqlite3_close(db);
       throw std::runtime_error(migration_msg.str());
     }
     if (migrationResult == MigrationResult::SUCCESS) {
       migration_msg << "migration " << idx << " succeeded." << std::endl;
       Logger::log(migration_msg.str());
     }
   }
 
   sqlite3_close(db);
 }
 
 SQLiteQueryExecutor::SQLiteQueryExecutor() {
   SQLiteQueryExecutor::migrate();
 #ifndef EMSCRIPTEN
   SQLiteQueryExecutor::initializeTablesForLogMonitoring();
 
   std::string currentBackupID = this->getMetadata("backupID");
   if (!StaffUtils::isStaffRelease() || !currentBackupID.size()) {
     return;
   }
   SQLiteQueryExecutor::connectionManager.setLogsMonitoring(true);
 #endif
 }
 
 SQLiteQueryExecutor::SQLiteQueryExecutor(std::string sqliteFilePath) {
   SQLiteQueryExecutor::sqliteFilePath = sqliteFilePath;
   SQLiteQueryExecutor::migrate();
 }
 
 sqlite3 *SQLiteQueryExecutor::getConnection() {
   if (SQLiteQueryExecutor::connectionManager.getConnection()) {
     return SQLiteQueryExecutor::connectionManager.getConnection();
   }
   SQLiteQueryExecutor::connectionManager.initializeConnection(
       SQLiteQueryExecutor::sqliteFilePath, default_on_db_open_callback);
   return SQLiteQueryExecutor::connectionManager.getConnection();
 }
 
 void SQLiteQueryExecutor::closeConnection() {
   SQLiteQueryExecutor::connectionManager.closeConnection();
 }
 
 SQLiteQueryExecutor::~SQLiteQueryExecutor() {
   SQLiteQueryExecutor::closeConnection();
 }
 
 std::string SQLiteQueryExecutor::getDraft(std::string key) const {
   static std::string getDraftByPrimaryKeySQL =
       "SELECT * "
       "FROM drafts "
       "WHERE key = ?;";
   std::unique_ptr<Draft> draft = getEntityByPrimaryKey<Draft>(
       SQLiteQueryExecutor::getConnection(), getDraftByPrimaryKeySQL, key);
   return (draft == nullptr) ? "" : draft->text;
 }
 
 std::unique_ptr<Thread>
 SQLiteQueryExecutor::getThread(std::string threadID) const {
   static std::string getThreadByPrimaryKeySQL =
       "SELECT * "
       "FROM threads "
       "WHERE id = ?;";
   return getEntityByPrimaryKey<Thread>(
       SQLiteQueryExecutor::getConnection(), getThreadByPrimaryKeySQL, threadID);
 }
 
 void SQLiteQueryExecutor::updateDraft(std::string key, std::string text) const {
   static std::string replaceDraftSQL =
       "REPLACE INTO drafts (key, text) "
       "VALUES (?, ?);";
   Draft draft = {key, text};
   replaceEntity<Draft>(
       SQLiteQueryExecutor::getConnection(), replaceDraftSQL, draft);
 }
 
 bool SQLiteQueryExecutor::moveDraft(std::string oldKey, std::string newKey)
     const {
   std::string draftText = this->getDraft(oldKey);
   if (!draftText.size()) {
     return false;
   }
   static std::string rekeyDraftSQL =
       "UPDATE OR REPLACE drafts "
       "SET key = ? "
       "WHERE key = ?;";
   rekeyAllEntities(
       SQLiteQueryExecutor::getConnection(), rekeyDraftSQL, oldKey, newKey);
   return true;
 }
 
 std::vector<Draft> SQLiteQueryExecutor::getAllDrafts() const {
   static std::string getAllDraftsSQL =
       "SELECT * "
       "FROM drafts;";
   return getAllEntities<Draft>(
       SQLiteQueryExecutor::getConnection(), getAllDraftsSQL);
 }
 
 void SQLiteQueryExecutor::removeAllDrafts() const {
   static std::string removeAllDraftsSQL = "DELETE FROM drafts;";
   removeAllEntities(SQLiteQueryExecutor::getConnection(), removeAllDraftsSQL);
 }
 
 void SQLiteQueryExecutor::removeDrafts(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeDraftsByKeysSQLStream;
   removeDraftsByKeysSQLStream << "DELETE FROM drafts "
                                  "WHERE key IN "
                               << getSQLStatementArray(ids.size()) << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeDraftsByKeysSQLStream.str(),
       ids);
 }
 
 void SQLiteQueryExecutor::removeAllMessages() const {
   static std::string removeAllMessagesSQL = "DELETE FROM messages;";
   removeAllEntities(SQLiteQueryExecutor::getConnection(), removeAllMessagesSQL);
 }
 
 std::vector<MessageEntity> SQLiteQueryExecutor::getAllMessages() const {
   static std::string getAllMessagesSQL =
       "SELECT * "
       "FROM messages "
       "LEFT JOIN media "
       "  ON messages.id = media.container "
       "ORDER BY messages.id;";
   SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       getAllMessagesSQL,
       "Failed to retrieve all messages.");
   return this->processMessagesResults(preparedSQL);
 }
 
 std::vector<MessageEntity> SQLiteQueryExecutor::processMessagesResults(
     SQLiteStatementWrapper &preparedSQL) const {
   std::string prevMsgIdx{};
   std::vector<MessageEntity> allMessages;
 
   for (int stepResult = sqlite3_step(preparedSQL); stepResult == SQLITE_ROW;
        stepResult = sqlite3_step(preparedSQL)) {
     Message message = Message::fromSQLResult(preparedSQL, 0);
     if (message.id == prevMsgIdx) {
       allMessages.back().second.push_back(Media::fromSQLResult(preparedSQL, 9));
     } else {
       prevMsgIdx = message.id;
       std::vector<Media> mediaForMsg;
       if (sqlite3_column_type(preparedSQL, 9) != SQLITE_NULL) {
         mediaForMsg.push_back(Media::fromSQLResult(preparedSQL, 9));
       }
       allMessages.push_back(std::make_pair(std::move(message), mediaForMsg));
     }
   }
   return allMessages;
 }
 
 void SQLiteQueryExecutor::removeMessages(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeMessagesByKeysSQLStream;
   removeMessagesByKeysSQLStream << "DELETE FROM messages "
                                    "WHERE id IN "
                                 << getSQLStatementArray(ids.size()) << ";";
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeMessagesByKeysSQLStream.str(),
       ids);
 }
 
 void SQLiteQueryExecutor::removeMessagesForThreads(
     const std::vector<std::string> &threadIDs) const {
   if (!threadIDs.size()) {
     return;
   }
 
   std::stringstream removeMessagesByKeysSQLStream;
   removeMessagesByKeysSQLStream << "DELETE FROM messages "
                                    "WHERE thread IN "
                                 << getSQLStatementArray(threadIDs.size())
                                 << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeMessagesByKeysSQLStream.str(),
       threadIDs);
 }
 
 void SQLiteQueryExecutor::replaceMessage(const Message &message) const {
   static std::string replaceMessageSQL =
       "REPLACE INTO messages "
       "(id, local_id, thread, user, type, future_type, content, time) "
       "VALUES (?, ?, ?, ?, ?, ?, ?, ?);";
 
   replaceEntity<Message>(
       SQLiteQueryExecutor::getConnection(), replaceMessageSQL, message);
 }
 
 void SQLiteQueryExecutor::updateMessageSearchIndex(
     std::string originalMessageID,
     std::string messageID,
     std::string processedContent) const {
 
   sqlite3 *db = SQLiteQueryExecutor::getConnection();
   int bindResult = 0;
   std::unique_ptr<SQLiteStatementWrapper> preparedSQL;
 
   static std::string insertMessageSearchResultSQL =
       "INSERT INTO message_search("
       "  original_message_id, message_id, processed_content) "
       "VALUES (?, ?, ?);";
   static std::string updateMessageSearchResultSQL =
       "UPDATE message_search "
       "SET message_id = ?, processed_content = ? "
       "WHERE original_message_id = ?;";
 
   if (originalMessageID == messageID) {
     preparedSQL = std::make_unique<SQLiteStatementWrapper>(
         db,
         insertMessageSearchResultSQL,
         "Failed to update message search entry.");
 
     bindStringToSQL(originalMessageID, *preparedSQL, 1);
     bindStringToSQL(messageID, *preparedSQL, 2);
     bindResult = bindStringToSQL(processedContent, *preparedSQL, 3);
   } else {
     preparedSQL = std::make_unique<SQLiteStatementWrapper>(
         db,
         updateMessageSearchResultSQL,
         "Failed to update message search entry.");
 
     bindStringToSQL(messageID, *preparedSQL, 1);
     bindStringToSQL(processedContent, *preparedSQL, 2);
     bindResult = bindStringToSQL(originalMessageID, *preparedSQL, 3);
   }
 
   if (bindResult != SQLITE_OK) {
     std::stringstream error_message;
     error_message << "Failed to bind key to SQL statement. Details: "
                   << sqlite3_errstr(bindResult) << std::endl;
     throw std::runtime_error(error_message.str());
   }
 
   sqlite3_step(*preparedSQL);
 }
 
 void SQLiteQueryExecutor::rekeyMessage(std::string from, std::string to) const {
   static std::string rekeyMessageSQL =
       "UPDATE OR REPLACE messages "
       "SET id = ? "
       "WHERE id = ?";
   rekeyAllEntities(
       SQLiteQueryExecutor::getConnection(), rekeyMessageSQL, from, to);
 }
 
 void SQLiteQueryExecutor::removeAllMedia() const {
   static std::string removeAllMediaSQL = "DELETE FROM media;";
   removeAllEntities(SQLiteQueryExecutor::getConnection(), removeAllMediaSQL);
 }
 
 void SQLiteQueryExecutor::removeMediaForMessages(
     const std::vector<std::string> &msgIDs) const {
   if (!msgIDs.size()) {
     return;
   }
 
   std::stringstream removeMediaByKeysSQLStream;
   removeMediaByKeysSQLStream << "DELETE FROM media "
                                 "WHERE container IN "
                              << getSQLStatementArray(msgIDs.size()) << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeMediaByKeysSQLStream.str(),
       msgIDs);
 }
 
 void SQLiteQueryExecutor::removeMediaForMessage(std::string msgID) const {
   static std::string removeMediaByKeySQL =
       "DELETE FROM media "
       "WHERE container IN (?);";
   std::vector<std::string> keys = {msgID};
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(), removeMediaByKeySQL, keys);
 }
 
 void SQLiteQueryExecutor::removeMediaForThreads(
     const std::vector<std::string> &threadIDs) const {
   if (!threadIDs.size()) {
     return;
   }
 
   std::stringstream removeMediaByKeysSQLStream;
   removeMediaByKeysSQLStream << "DELETE FROM media "
                                 "WHERE thread IN "
                              << getSQLStatementArray(threadIDs.size()) << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeMediaByKeysSQLStream.str(),
       threadIDs);
 }
 
 void SQLiteQueryExecutor::replaceMedia(const Media &media) const {
   static std::string replaceMediaSQL =
       "REPLACE INTO media "
       "(id, container, thread, uri, type, extras) "
       "VALUES (?, ?, ?, ?, ?, ?)";
   replaceEntity<Media>(
       SQLiteQueryExecutor::getConnection(), replaceMediaSQL, media);
 }
 
 void SQLiteQueryExecutor::rekeyMediaContainers(std::string from, std::string to)
     const {
   static std::string rekeyMediaContainersSQL =
       "UPDATE media SET container = ? WHERE container = ?;";
   rekeyAllEntities(
       SQLiteQueryExecutor::getConnection(), rekeyMediaContainersSQL, from, to);
 }
 
 void SQLiteQueryExecutor::replaceMessageStoreThreads(
     const std::vector<MessageStoreThread> &threads) const {
   static std::string replaceMessageStoreThreadSQL =
       "REPLACE INTO message_store_threads "
       "(id, start_reached) "
       "VALUES (?, ?);";
 
   for (auto &thread : threads) {
     replaceEntity<MessageStoreThread>(
         SQLiteQueryExecutor::getConnection(),
         replaceMessageStoreThreadSQL,
         thread);
   }
 }
 
 void SQLiteQueryExecutor::removeAllMessageStoreThreads() const {
   static std::string removeAllMessageStoreThreadsSQL =
       "DELETE FROM message_store_threads;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllMessageStoreThreadsSQL);
 }
 
 void SQLiteQueryExecutor::removeMessageStoreThreads(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeMessageStoreThreadsByKeysSQLStream;
   removeMessageStoreThreadsByKeysSQLStream
       << "DELETE FROM message_store_threads "
          "WHERE id IN "
       << getSQLStatementArray(ids.size()) << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeMessageStoreThreadsByKeysSQLStream.str(),
       ids);
 }
 
 std::vector<MessageStoreThread>
 SQLiteQueryExecutor::getAllMessageStoreThreads() const {
   static std::string getAllMessageStoreThreadsSQL =
       "SELECT * "
       "FROM message_store_threads;";
   return getAllEntities<MessageStoreThread>(
       SQLiteQueryExecutor::getConnection(), getAllMessageStoreThreadsSQL);
 }
 
 std::vector<Thread> SQLiteQueryExecutor::getAllThreads() const {
   static std::string getAllThreadsSQL =
       "SELECT * "
       "FROM threads;";
   return getAllEntities<Thread>(
       SQLiteQueryExecutor::getConnection(), getAllThreadsSQL);
 };
 
 void SQLiteQueryExecutor::removeThreads(std::vector<std::string> ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeThreadsByKeysSQLStream;
   removeThreadsByKeysSQLStream << "DELETE FROM threads "
                                   "WHERE id IN "
                                << getSQLStatementArray(ids.size()) << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeThreadsByKeysSQLStream.str(),
       ids);
 };
 
 void SQLiteQueryExecutor::replaceThread(const Thread &thread) const {
   static std::string replaceThreadSQL =
       "REPLACE INTO threads ("
       " id, type, name, description, color, creation_time, parent_thread_id,"
       " containing_thread_id, community, members, roles, current_user,"
       " source_message_id, replies_count, avatar, pinned_count) "
       "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
 
   replaceEntity<Thread>(
       SQLiteQueryExecutor::getConnection(), replaceThreadSQL, thread);
 };
 
 void SQLiteQueryExecutor::removeAllThreads() const {
   static std::string removeAllThreadsSQL = "DELETE FROM threads;";
   removeAllEntities(SQLiteQueryExecutor::getConnection(), removeAllThreadsSQL);
 };
 
 void SQLiteQueryExecutor::replaceReport(const Report &report) const {
   static std::string replaceReportSQL =
       "REPLACE INTO reports (id, report) "
       "VALUES (?, ?);";
 
   replaceEntity<Report>(
       SQLiteQueryExecutor::getConnection(), replaceReportSQL, report);
 }
 
 void SQLiteQueryExecutor::removeAllReports() const {
   static std::string removeAllReportsSQL = "DELETE FROM reports;";
   removeAllEntities(SQLiteQueryExecutor::getConnection(), removeAllReportsSQL);
 }
 
 void SQLiteQueryExecutor::removeReports(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeReportsByKeysSQLStream;
   removeReportsByKeysSQLStream << "DELETE FROM reports "
                                   "WHERE id IN "
                                << getSQLStatementArray(ids.size()) << ";";
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeReportsByKeysSQLStream.str(),
       ids);
 }
 
 std::vector<Report> SQLiteQueryExecutor::getAllReports() const {
   static std::string getAllReportsSQL =
       "SELECT * "
       "FROM reports;";
   return getAllEntities<Report>(
       SQLiteQueryExecutor::getConnection(), getAllReportsSQL);
 }
 
 void SQLiteQueryExecutor::setPersistStorageItem(
     std::string key,
     std::string item) const {
   static std::string replacePersistStorageItemSQL =
       "REPLACE INTO persist_storage (key, item) "
       "VALUES (?, ?);";
   PersistItem entry{
       key,
       item,
   };
   replaceEntity<PersistItem>(
       SQLiteQueryExecutor::getConnection(),
       replacePersistStorageItemSQL,
       entry);
 }
 
 void SQLiteQueryExecutor::removePersistStorageItem(std::string key) const {
   static std::string removePersistStorageItemByKeySQL =
       "DELETE FROM persist_storage "
       "WHERE key IN (?);";
   std::vector<std::string> keys = {key};
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removePersistStorageItemByKeySQL,
       keys);
 }
 
 std::string SQLiteQueryExecutor::getPersistStorageItem(std::string key) const {
   static std::string getPersistStorageItemByPrimaryKeySQL =
       "SELECT * "
       "FROM persist_storage "
       "WHERE key = ?;";
   std::unique_ptr<PersistItem> entry = getEntityByPrimaryKey<PersistItem>(
       SQLiteQueryExecutor::getConnection(),
       getPersistStorageItemByPrimaryKeySQL,
       key);
   return (entry == nullptr) ? "" : entry->item;
 }
 
 void SQLiteQueryExecutor::replaceUser(const UserInfo &userInfo) const {
   static std::string replaceUserSQL =
       "REPLACE INTO users (id, user_info) "
       "VALUES (?, ?);";
   replaceEntity<UserInfo>(
       SQLiteQueryExecutor::getConnection(), replaceUserSQL, userInfo);
 }
 
 void SQLiteQueryExecutor::removeAllUsers() const {
   static std::string removeAllUsersSQL = "DELETE FROM users;";
   removeAllEntities(SQLiteQueryExecutor::getConnection(), removeAllUsersSQL);
 }
 
 void SQLiteQueryExecutor::removeUsers(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeUsersByKeysSQLStream;
   removeUsersByKeysSQLStream << "DELETE FROM users "
                                 "WHERE id IN "
                              << getSQLStatementArray(ids.size()) << ";";
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeUsersByKeysSQLStream.str(),
       ids);
 }
 
 void SQLiteQueryExecutor::replaceKeyserver(
     const KeyserverInfo &keyserverInfo) const {
   static std::string replaceKeyserverSQL =
       "REPLACE INTO keyservers (id, keyserver_info) "
       "VALUES (:id, :keyserver_info);";
   replaceEntity<KeyserverInfo>(
       SQLiteQueryExecutor::getConnection(), replaceKeyserverSQL, keyserverInfo);
 
   static std::string replaceKeyserverSyncedSQL =
       "REPLACE INTO keyservers_synced (id, keyserver_info) "
       "VALUES (:id, :synced_keyserver_info);";
   replaceEntity<KeyserverInfo>(
       SQLiteQueryExecutor::getConnection(),
       replaceKeyserverSyncedSQL,
       keyserverInfo);
 }
 
 void SQLiteQueryExecutor::removeAllKeyservers() const {
   static std::string removeAllKeyserversSQL = "DELETE FROM keyservers;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllKeyserversSQL);
   static std::string removeAllKeyserversSyncedSQL =
       "DELETE FROM keyservers_synced;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllKeyserversSyncedSQL);
 }
 
 void SQLiteQueryExecutor::removeKeyservers(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   auto idArray = getSQLStatementArray(ids.size());
 
   std::stringstream removeKeyserversByKeysSQLStream;
   removeKeyserversByKeysSQLStream << "DELETE FROM keyservers "
                                      "WHERE id IN "
                                   << idArray << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeKeyserversByKeysSQLStream.str(),
       ids);
 
   std::stringstream removeKeyserversSyncedByKeysSQLStream;
   removeKeyserversSyncedByKeysSQLStream << "DELETE FROM keyservers_synced "
                                            "WHERE id IN "
                                         << idArray << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeKeyserversSyncedByKeysSQLStream.str(),
       ids);
 }
 
 std::vector<KeyserverInfo> SQLiteQueryExecutor::getAllKeyservers() const {
   static std::string getAllKeyserversSQL =
       "SELECT "
       "  synced.id, "
       "  COALESCE(keyservers.keyserver_info, ''), "
       "  synced.keyserver_info "
       "FROM keyservers_synced synced "
       "LEFT JOIN keyservers "
       "  ON synced.id = keyservers.id;";
   return getAllEntities<KeyserverInfo>(
       SQLiteQueryExecutor::getConnection(), getAllKeyserversSQL);
 }
 
 std::vector<UserInfo> SQLiteQueryExecutor::getAllUsers() const {
   static std::string getAllUsersSQL =
       "SELECT * "
       "FROM users;";
   return getAllEntities<UserInfo>(
       SQLiteQueryExecutor::getConnection(), getAllUsersSQL);
 }
 
 void SQLiteQueryExecutor::replaceCommunity(
     const CommunityInfo &communityInfo) const {
   static std::string replaceCommunitySQL =
       "REPLACE INTO communities (id, community_info) "
       "VALUES (?, ?);";
   replaceEntity<CommunityInfo>(
       SQLiteQueryExecutor::getConnection(), replaceCommunitySQL, communityInfo);
 }
 
 void SQLiteQueryExecutor::removeAllCommunities() const {
   static std::string removeAllCommunitiesSQL = "DELETE FROM communities;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllCommunitiesSQL);
 }
 
 void SQLiteQueryExecutor::removeCommunities(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeCommunitiesByKeysSQLStream;
   removeCommunitiesByKeysSQLStream << "DELETE FROM communities "
                                       "WHERE id IN "
                                    << getSQLStatementArray(ids.size()) << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeCommunitiesByKeysSQLStream.str(),
       ids);
 }
 
 std::vector<CommunityInfo> SQLiteQueryExecutor::getAllCommunities() const {
   static std::string getAllCommunitiesSQL =
       "SELECT * "
       "FROM communities;";
   return getAllEntities<CommunityInfo>(
       SQLiteQueryExecutor::getConnection(), getAllCommunitiesSQL);
 }
 
 void SQLiteQueryExecutor::replaceIntegrityThreadHashes(
     const std::vector<IntegrityThreadHash> &threadHashes) const {
   static std::string replaceIntegrityThreadHashSQL =
       "REPLACE INTO integrity_store (id, thread_hash) "
       "VALUES (?, ?);";
   for (const IntegrityThreadHash &integrityThreadHash : threadHashes) {
     replaceEntity<IntegrityThreadHash>(
         SQLiteQueryExecutor::getConnection(),
         replaceIntegrityThreadHashSQL,
         integrityThreadHash);
   }
 }
 
 void SQLiteQueryExecutor::removeAllIntegrityThreadHashes() const {
   static std::string removeAllIntegrityThreadHashesSQL =
       "DELETE FROM integrity_store;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllIntegrityThreadHashesSQL);
 }
 
 void SQLiteQueryExecutor::removeIntegrityThreadHashes(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeIntegrityThreadHashesByKeysSQLStream;
   removeIntegrityThreadHashesByKeysSQLStream << "DELETE FROM integrity_store "
                                                 "WHERE id IN "
                                              << getSQLStatementArray(ids.size())
                                              << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeIntegrityThreadHashesByKeysSQLStream.str(),
       ids);
 }
 
 std::vector<IntegrityThreadHash>
 SQLiteQueryExecutor::getAllIntegrityThreadHashes() const {
   static std::string getAllIntegrityThreadHashesSQL =
       "SELECT * "
       "FROM integrity_store;";
   return getAllEntities<IntegrityThreadHash>(
       SQLiteQueryExecutor::getConnection(), getAllIntegrityThreadHashesSQL);
 }
 
 void SQLiteQueryExecutor::replaceSyncedMetadataEntry(
     const SyncedMetadataEntry &syncedMetadataEntry) const {
   static std::string replaceSyncedMetadataEntrySQL =
       "REPLACE INTO synced_metadata (name, data) "
       "VALUES (?, ?);";
   replaceEntity<SyncedMetadataEntry>(
       SQLiteQueryExecutor::getConnection(),
       replaceSyncedMetadataEntrySQL,
       syncedMetadataEntry);
 }
 
 void SQLiteQueryExecutor::removeAllSyncedMetadata() const {
   static std::string removeAllSyncedMetadataSQL =
       "DELETE FROM synced_metadata;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllSyncedMetadataSQL);
 }
 
 void SQLiteQueryExecutor::removeSyncedMetadata(
     const std::vector<std::string> &names) const {
   if (!names.size()) {
     return;
   }
 
   std::stringstream removeSyncedMetadataByNamesSQLStream;
   removeSyncedMetadataByNamesSQLStream << "DELETE FROM synced_metadata "
                                           "WHERE name IN "
                                        << getSQLStatementArray(names.size())
                                        << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeSyncedMetadataByNamesSQLStream.str(),
       names);
 }
 
 std::vector<SyncedMetadataEntry>
 SQLiteQueryExecutor::getAllSyncedMetadata() const {
   static std::string getAllSyncedMetadataSQL =
       "SELECT * "
       "FROM synced_metadata;";
   return getAllEntities<SyncedMetadataEntry>(
       SQLiteQueryExecutor::getConnection(), getAllSyncedMetadataSQL);
 }
 
 std::optional<int>
 SQLiteQueryExecutor::getSyncedDatabaseVersion(sqlite3 *db) const {
   static std::string getDBVersionSyncedMetadataSQL =
       "SELECT * "
       "FROM synced_metadata "
       "WHERE name=\"db_version\";";
   std::vector<SyncedMetadataEntry> entries =
       getAllEntities<SyncedMetadataEntry>(db, getDBVersionSyncedMetadataSQL);
   for (auto &entry : entries) {
     return std::stoi(entry.data);
   }
   return std::nullopt;
 }
 
 void SQLiteQueryExecutor::replaceAuxUserInfo(
     const AuxUserInfo &userInfo) const {
   static std::string replaceAuxUserInfoSQL =
       "REPLACE INTO aux_users (id, aux_user_info) "
       "VALUES (?, ?);";
   replaceEntity<AuxUserInfo>(
       SQLiteQueryExecutor::getConnection(), replaceAuxUserInfoSQL, userInfo);
 }
 
 void SQLiteQueryExecutor::removeAllAuxUserInfos() const {
   static std::string removeAllAuxUserInfosSQL = "DELETE FROM aux_users;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllAuxUserInfosSQL);
 }
 
 void SQLiteQueryExecutor::removeAuxUserInfos(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeAuxUserInfosByKeysSQLStream;
   removeAuxUserInfosByKeysSQLStream << "DELETE FROM aux_users "
                                        "WHERE id IN "
                                     << getSQLStatementArray(ids.size()) << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeAuxUserInfosByKeysSQLStream.str(),
       ids);
 }
 
 std::vector<AuxUserInfo> SQLiteQueryExecutor::getAllAuxUserInfos() const {
   static std::string getAllAuxUserInfosSQL =
       "SELECT * "
       "FROM aux_users;";
   return getAllEntities<AuxUserInfo>(
       SQLiteQueryExecutor::getConnection(), getAllAuxUserInfosSQL);
 }
 
 void SQLiteQueryExecutor::replaceThreadActivityEntry(
     const ThreadActivityEntry &threadActivityEntry) const {
   static std::string replaceThreadActivityEntrySQL =
       "REPLACE INTO thread_activity (id, thread_activity_store_entry) "
       "VALUES (?, ?);";
   replaceEntity<ThreadActivityEntry>(
       SQLiteQueryExecutor::getConnection(),
       replaceThreadActivityEntrySQL,
       threadActivityEntry);
 }
 
 void SQLiteQueryExecutor::removeAllThreadActivityEntries() const {
   static std::string removeAllThreadActivityEntriesSQL =
       "DELETE FROM thread_activity;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllThreadActivityEntriesSQL);
 }
 
 void SQLiteQueryExecutor::removeThreadActivityEntries(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeThreadActivityEntriesByKeysSQLStream;
   removeThreadActivityEntriesByKeysSQLStream << "DELETE FROM thread_activity "
                                                 "WHERE id IN "
                                              << getSQLStatementArray(ids.size())
                                              << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeThreadActivityEntriesByKeysSQLStream.str(),
       ids);
 }
 
 std::vector<ThreadActivityEntry>
 SQLiteQueryExecutor::getAllThreadActivityEntries() const {
   static std::string getAllThreadActivityEntriesSQL =
       "SELECT * "
       "FROM thread_activity;";
   return getAllEntities<ThreadActivityEntry>(
       SQLiteQueryExecutor::getConnection(), getAllThreadActivityEntriesSQL);
 }
 
 void SQLiteQueryExecutor::replaceEntry(const EntryInfo &entryInfo) const {
   static std::string replaceEntrySQL =
       "REPLACE INTO entries (id, entry) "
       "VALUES (?, ?);";
   replaceEntity<EntryInfo>(
       SQLiteQueryExecutor::getConnection(), replaceEntrySQL, entryInfo);
 }
 
 void SQLiteQueryExecutor::removeAllEntries() const {
   static std::string removeAllEntriesSQL = "DELETE FROM entries;";
   removeAllEntities(SQLiteQueryExecutor::getConnection(), removeAllEntriesSQL);
 }
 
 void SQLiteQueryExecutor::removeEntries(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeEntriesByKeysSQLStream;
   removeEntriesByKeysSQLStream << "DELETE FROM entries "
                                   "WHERE id IN "
                                << getSQLStatementArray(ids.size()) << ";";
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeEntriesByKeysSQLStream.str(),
       ids);
 }
 
 std::vector<EntryInfo> SQLiteQueryExecutor::getAllEntries() const {
   static std::string getAllEntriesSQL =
       "SELECT * "
       "FROM entries;";
   return getAllEntities<EntryInfo>(
       SQLiteQueryExecutor::getConnection(), getAllEntriesSQL);
 }
 
 void SQLiteQueryExecutor::replaceMessageStoreLocalMessageInfo(
     const LocalMessageInfo &localMessageInfo) const {
   static std::string replaceLocalMessageInfoSQL =
       "REPLACE INTO message_store_local (id, local_message_info) "
       "VALUES (?, ?);";
   replaceEntity<LocalMessageInfo>(
       SQLiteQueryExecutor::getConnection(),
       replaceLocalMessageInfoSQL,
       localMessageInfo);
 }
 
 void SQLiteQueryExecutor::removeMessageStoreLocalMessageInfos(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeLocalMessageInfosByKeysSQLStream;
   removeLocalMessageInfosByKeysSQLStream << "DELETE FROM message_store_local "
                                             "WHERE id IN "
                                          << getSQLStatementArray(ids.size())
                                          << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeLocalMessageInfosByKeysSQLStream.str(),
       ids);
 }
 
 void SQLiteQueryExecutor::removeAllMessageStoreLocalMessageInfos() const {
   static std::string removeAllLocalMessageInfosSQL =
       "DELETE FROM message_store_local;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllLocalMessageInfosSQL);
 }
 
 std::vector<LocalMessageInfo>
 SQLiteQueryExecutor::getAllMessageStoreLocalMessageInfos() const {
   static std::string getAllLocalMessageInfosSQL =
       "SELECT * "
       "FROM message_store_local;";
   return getAllEntities<LocalMessageInfo>(
       SQLiteQueryExecutor::getConnection(), getAllLocalMessageInfosSQL);
 }
 
 void SQLiteQueryExecutor::beginTransaction() const {
   executeQuery(SQLiteQueryExecutor::getConnection(), "BEGIN TRANSACTION;");
 }
 
 void SQLiteQueryExecutor::commitTransaction() const {
   executeQuery(SQLiteQueryExecutor::getConnection(), "COMMIT;");
 }
 
 void SQLiteQueryExecutor::rollbackTransaction() const {
   executeQuery(SQLiteQueryExecutor::getConnection(), "ROLLBACK;");
 }
 
 int SQLiteQueryExecutor::getContentAccountID() const {
   return CONTENT_ACCOUNT_ID;
 }
 
 int SQLiteQueryExecutor::getNotifsAccountID() const {
   return NOTIFS_ACCOUNT_ID;
 }
 
 std::vector<OlmPersistSession>
 SQLiteQueryExecutor::getOlmPersistSessionsData() const {
   static std::string getAllOlmPersistSessionsSQL =
       "SELECT * "
       "FROM olm_persist_sessions;";
   return getAllEntities<OlmPersistSession>(
       SQLiteQueryExecutor::getConnection(), getAllOlmPersistSessionsSQL);
 }
 
 std::optional<std::string>
 SQLiteQueryExecutor::getOlmPersistAccountData(int accountID) const {
   static std::string getOlmPersistAccountSQL =
       "SELECT * "
       "FROM olm_persist_account "
       "WHERE id = ?;";
   std::unique_ptr<OlmPersistAccount> result =
       getEntityByIntegerPrimaryKey<OlmPersistAccount>(
           SQLiteQueryExecutor::getConnection(),
           getOlmPersistAccountSQL,
           accountID);
   if (result == nullptr) {
     return std::nullopt;
   }
   return result->account_data;
 }
 
 void SQLiteQueryExecutor::storeOlmPersistAccount(
     int accountID,
     const std::string &accountData) const {
   static std::string replaceOlmPersistAccountSQL =
       "REPLACE INTO olm_persist_account (id, account_data) "
       "VALUES (?, ?);";
 
   OlmPersistAccount persistAccount = {accountID, accountData};
 
   replaceEntity<OlmPersistAccount>(
       SQLiteQueryExecutor::getConnection(),
       replaceOlmPersistAccountSQL,
       persistAccount);
 }
 
 void SQLiteQueryExecutor::storeOlmPersistSession(
     const OlmPersistSession &session) const {
   static std::string replaceOlmPersistSessionSQL =
       "REPLACE INTO olm_persist_sessions "
       "(target_device_id, session_data, version) "
       "VALUES (?, ?, ?);";
 
   replaceEntity<OlmPersistSession>(
       SQLiteQueryExecutor::getConnection(),
       replaceOlmPersistSessionSQL,
       session);
 }
 
 void SQLiteQueryExecutor::storeOlmPersistData(
     int accountID,
     crypto::Persist persist) const {
 
   if (accountID != CONTENT_ACCOUNT_ID && persist.sessions.size() > 0) {
     throw std::runtime_error(
         "Attempt to store notifications sessions in SQLite. Notifications "
         "sessions must be stored in storage shared with NSE.");
   }
 
   std::string accountData =
       std::string(persist.account.begin(), persist.account.end());
   this->storeOlmPersistAccount(accountID, accountData);
 
   for (auto it = persist.sessions.begin(); it != persist.sessions.end(); it++) {
     OlmPersistSession persistSession = {
         it->first,
         std::string(it->second.buffer.begin(), it->second.buffer.end()),
         it->second.version};
 
     this->storeOlmPersistSession(persistSession);
   }
 }
 
 void SQLiteQueryExecutor::setNotifyToken(std::string token) const {
   this->setMetadata("notify_token", token);
 }
 
 void SQLiteQueryExecutor::clearNotifyToken() const {
   this->clearMetadata("notify_token");
 }
 
 void SQLiteQueryExecutor::stampSQLiteDBUserID(std::string userID) const {
   this->setMetadata("current_user_id", userID);
 }
 
 std::string SQLiteQueryExecutor::getSQLiteStampedUserID() const {
   return this->getMetadata("current_user_id");
 }
 
 void SQLiteQueryExecutor::setMetadata(std::string entryName, std::string data)
     const {
   std::string replaceMetadataSQL =
       "REPLACE INTO metadata (name, data) "
       "VALUES (?, ?);";
   Metadata entry{
       entryName,
       data,
   };
   replaceEntity<Metadata>(
       SQLiteQueryExecutor::getConnection(), replaceMetadataSQL, entry);
 }
 
 void SQLiteQueryExecutor::clearMetadata(std::string entryName) const {
   static std::string removeMetadataByKeySQL =
       "DELETE FROM metadata "
       "WHERE name IN (?);";
   std::vector<std::string> keys = {entryName};
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(), removeMetadataByKeySQL, keys);
 }
 
 std::string SQLiteQueryExecutor::getMetadata(std::string entryName) const {
   std::string getMetadataByPrimaryKeySQL =
       "SELECT * "
       "FROM metadata "
       "WHERE name = ?;";
   std::unique_ptr<Metadata> entry = getEntityByPrimaryKey<Metadata>(
       SQLiteQueryExecutor::getConnection(),
       getMetadataByPrimaryKeySQL,
       entryName);
   return (entry == nullptr) ? "" : entry->data;
 }
 
 void SQLiteQueryExecutor::addOutboundP2PMessages(
     const std::vector<OutboundP2PMessage> &messages) const {
   static std::string addMessage =
       "REPLACE INTO outbound_p2p_messages ("
       " message_id, device_id, user_id, timestamp,"
       " plaintext, ciphertext, status, supports_auto_retry) "
       "VALUES (?, ?, ?, ?, ?, ?, ?, ?);";
 
   for (const OutboundP2PMessage &clientMessage : messages) {
     SQLiteOutboundP2PMessage message =
         clientMessage.toSQLiteOutboundP2PMessage();
     replaceEntity<SQLiteOutboundP2PMessage>(
         SQLiteQueryExecutor::getConnection(), addMessage, message);
   }
 }
 
 std::vector<OutboundP2PMessage> SQLiteQueryExecutor::getOutboundP2PMessagesByID(
     const std::vector<std::string> &ids) const {
   std::stringstream getOutboundP2PMessageSQLStream;
   getOutboundP2PMessageSQLStream << "SELECT * "
                                     "FROM outbound_p2p_messages "
                                     "WHERE message_id IN "
                                  << getSQLStatementArray(ids.size()) << ";";
   std::string getOutboundP2PMessageSQL = getOutboundP2PMessageSQLStream.str();
 
   SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       getOutboundP2PMessageSQL,
       "Failed to get outbound messages by ID");
 
   std::vector<SQLiteOutboundP2PMessage> queryResult =
       getAllEntitiesByPrimaryKeys<SQLiteOutboundP2PMessage>(
           SQLiteQueryExecutor::getConnection(), getOutboundP2PMessageSQL, ids);
   std::vector<OutboundP2PMessage> result;
   for (auto &message : queryResult) {
     result.emplace_back(OutboundP2PMessage(message));
   }
   return result;
 }
 
 std::vector<OutboundP2PMessage>
 SQLiteQueryExecutor::getAllOutboundP2PMessages() const {
   std::string query =
       "SELECT * FROM outbound_p2p_messages "
       "ORDER BY timestamp;";
 
   SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       query,
       "Failed to get all messages to device");
 
   std::vector<OutboundP2PMessage> messages;
   for (int stepResult = sqlite3_step(preparedSQL); stepResult == SQLITE_ROW;
        stepResult = sqlite3_step(preparedSQL)) {
     messages.emplace_back(OutboundP2PMessage(
         SQLiteOutboundP2PMessage::fromSQLResult(preparedSQL, 0)));
   }
 
   return messages;
 }
 
-void SQLiteQueryExecutor::removeOutboundP2PMessagesOlderThan(
-    std::string lastConfirmedMessageID,
+void SQLiteQueryExecutor::removeOutboundP2PMessage(
+    std::string confirmedMessageID,
     std::string deviceID) const {
   std::string query =
       "DELETE FROM outbound_p2p_messages "
-      "WHERE timestamp <= ("
-      "  SELECT timestamp "
-      "  FROM outbound_p2p_messages"
-      "  WHERE message_id = ?"
-      ") "
-      "AND device_id IN (?);";
+      "WHERE message_id = ? AND device_id = ?;";
 
   comm::SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       query,
       "Failed to remove messages to device");
 
-  bindStringToSQL(lastConfirmedMessageID.c_str(), preparedSQL, 1);
+  bindStringToSQL(confirmedMessageID.c_str(), preparedSQL, 1);
   bindStringToSQL(deviceID.c_str(), preparedSQL, 2);
 
   sqlite3_step(preparedSQL);
 }
 
 void SQLiteQueryExecutor::removeAllOutboundP2PMessages(
     const std::string &deviceID) const {
   static std::string removeMessagesSQL =
       "DELETE FROM outbound_p2p_messages "
       "WHERE device_id IN (?);";
   std::vector<std::string> keys = {deviceID};
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(), removeMessagesSQL, keys);
 }
 
 void SQLiteQueryExecutor::setCiphertextForOutboundP2PMessage(
     std::string messageID,
     std::string deviceID,
     std::string ciphertext) const {
   static std::string query =
       "UPDATE outbound_p2p_messages "
       "SET ciphertext = ?, status = 'encrypted' "
       "WHERE message_id = ? AND device_id = ?;";
 
   comm::SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       query,
       "Failed to set ciphertext for OutboundP2PMessage");
 
   bindStringToSQL(ciphertext.c_str(), preparedSQL, 1);
   bindStringToSQL(messageID.c_str(), preparedSQL, 2);
   bindStringToSQL(deviceID.c_str(), preparedSQL, 3);
 
   sqlite3_step(preparedSQL);
 }
 
 void SQLiteQueryExecutor::markOutboundP2PMessageAsSent(
     std::string messageID,
     std::string deviceID) const {
   static std::string query =
       "UPDATE outbound_p2p_messages "
       "SET status = 'sent' "
       "WHERE message_id = ? AND device_id = ?;";
 
   comm::SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       query,
       "Failed to mark OutboundP2PMessage as sent");
 
   bindStringToSQL(messageID.c_str(), preparedSQL, 1);
   bindStringToSQL(deviceID.c_str(), preparedSQL, 2);
 
   sqlite3_step(preparedSQL);
 }
 
 std::vector<std::string> SQLiteQueryExecutor::resetOutboundP2PMessagesForDevice(
     std::string deviceID) const {
   // Query all messages that need to be resent - all message that supports
   // auto retry or already sent messages.
   std::string queryMessageIDsToResend =
       "SELECT message_id "
       "FROM outbound_p2p_messages "
       "WHERE device_id = ? AND ( "
       "  supports_auto_retry = 1 "
       "  OR (supports_auto_retry = 0 AND status = 'sent') "
       ");";
 
   SQLiteStatementWrapper preparedQueryMessageIDsSQL(
       SQLiteQueryExecutor::getConnection(),
       queryMessageIDsToResend,
       "Failed to get all messages to reset");
 
   bindStringToSQL(deviceID.c_str(), preparedQueryMessageIDsSQL, 1);
   std::vector<std::string> messageIDs;
   for (int stepResult = sqlite3_step(preparedQueryMessageIDsSQL);
        stepResult == SQLITE_ROW;
        stepResult = sqlite3_step(preparedQueryMessageIDsSQL)) {
     messageIDs.push_back(getStringFromSQLRow(preparedQueryMessageIDsSQL, 0));
   }
 
   // Setting ciphertext to an empty string to make sure this message will be
   // encrypted again with a new session, update the status, and set
   // supports_auto_retry to true.
   // Updating supports_auto_retry to true because those are already sent
   // messages (from the UI perspective), but the recipient failed to decrypt
   // so needs to be automatically resent.
   std::stringstream resetMessagesSQLStream;
   resetMessagesSQLStream
       << "UPDATE outbound_p2p_messages "
       << "SET supports_auto_retry = 1, status = 'persisted', ciphertext = '' "
       << "WHERE message_id IN " << getSQLStatementArray(messageIDs.size())
       << ";";
 
   SQLiteStatementWrapper preparedUpdateSQL(
       SQLiteQueryExecutor::getConnection(),
       resetMessagesSQLStream.str(),
       "Failed to reset messages.");
 
   for (int i = 0; i < messageIDs.size(); i++) {
     int bindResult = bindStringToSQL(messageIDs[i], preparedUpdateSQL, i + 1);
     if (bindResult != SQLITE_OK) {
       std::stringstream error_message;
       error_message << "Failed to bind key to SQL statement. Details: "
                     << sqlite3_errstr(bindResult) << std::endl;
       sqlite3_finalize(preparedUpdateSQL);
       throw std::runtime_error(error_message.str());
     }
   }
   sqlite3_step(preparedUpdateSQL);
 
   // This handles the case of messages that are encrypted (with a malformed
   // session) but not yet queued on Tunnelbroker. In this case, this message
   // is not considered to be sent (from the UI perspective),
   // and supports_auto_retry is not updated.
   std::string updateCiphertextQuery =
       "UPDATE outbound_p2p_messages "
       "SET ciphertext = '', status = 'persisted'"
       "WHERE device_id = ? "
       "  AND supports_auto_retry = 0 "
       "  AND status = 'encrypted';";
 
   SQLiteStatementWrapper preparedUpdateCiphertextSQL(
       SQLiteQueryExecutor::getConnection(),
       updateCiphertextQuery,
       "Failed to set ciphertext");
 
   bindStringToSQL(deviceID.c_str(), preparedUpdateCiphertextSQL, 1);
   sqlite3_step(preparedUpdateCiphertextSQL);
 
   return messageIDs;
 }
 
 void SQLiteQueryExecutor::addInboundP2PMessage(
     InboundP2PMessage message) const {
   static std::string addMessage =
       "REPLACE INTO inbound_p2p_messages ("
       "  message_id, sender_device_id, plaintext, status, sender_user_id)"
       "VALUES (?, ?, ?, ?, ?);";
 
   replaceEntity<InboundP2PMessage>(
       SQLiteQueryExecutor::getConnection(), addMessage, message);
 }
 
 std::vector<InboundP2PMessage>
 SQLiteQueryExecutor::getAllInboundP2PMessage() const {
   static std::string query =
       "SELECT message_id, sender_device_id, plaintext, status, sender_user_id "
       "FROM inbound_p2p_messages;";
   return getAllEntities<InboundP2PMessage>(
       SQLiteQueryExecutor::getConnection(), query);
 }
 
 void SQLiteQueryExecutor::removeInboundP2PMessages(
     const std::vector<std::string> &ids) const {
   if (!ids.size()) {
     return;
   }
 
   std::stringstream removeMessagesSQLStream;
   removeMessagesSQLStream << "DELETE FROM inbound_p2p_messages "
                              "WHERE message_id IN "
                           << getSQLStatementArray(ids.size()) << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(), removeMessagesSQLStream.str(), ids);
 }
 
 std::vector<MessageEntity>
 SQLiteQueryExecutor::getRelatedMessages(const std::string &messageID) const {
   static std::string getMessageSQL =
       "SELECT * "
       "FROM messages "
       "LEFT JOIN media "
       "  ON messages.id = media.container "
       "WHERE messages.id = ? OR messages.target_message = ? "
       "ORDER BY messages.time DESC";
   comm::SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       getMessageSQL,
       "Failed to get latest message edit");
   bindStringToSQL(messageID.c_str(), preparedSQL, 1);
   bindStringToSQL(messageID.c_str(), preparedSQL, 2);
   return this->processMessagesResults(preparedSQL);
 }
 
 std::vector<MessageEntity> SQLiteQueryExecutor::searchMessages(
     std::string query,
     std::string threadID,
     std::optional<std::string> timestampCursor,
     std::optional<std::string> messageIDCursor) const {
   std::stringstream searchMessagesSQL;
   searchMessagesSQL
       << "SELECT "
          "  m.id, m.local_id, m.thread, m.user, m.type, m.future_type, "
          "  m.content, m.time, media.id, media.container, media.thread, "
          "  media.uri, media.type, media.extras "
          "FROM message_search AS s "
          "LEFT JOIN messages AS m "
          "  ON m.id = s.original_message_id "
          "LEFT JOIN media "
          "  ON m.id = media.container "
          "LEFT JOIN messages AS m2 "
          "  ON m2.target_message = m.id "
          "  AND m2.type = ? AND m2.thread = ? "
          "WHERE s.processed_content MATCH ? "
          "  AND (m.thread = ? OR m2.id IS NOT NULL) ";
 
   bool usingCursor = timestampCursor.has_value() && messageIDCursor.has_value();
 
   if (usingCursor) {
     searchMessagesSQL << " AND (m.time < ? OR (m.time = ? AND m.id < ?)) ";
   }
   searchMessagesSQL << "ORDER BY m.time DESC, m.id DESC "
                     << "LIMIT 20;";
 
   comm::SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       searchMessagesSQL.str(),
       "Failed to get message search results");
 
   auto sidebarSourceType = static_cast<int>(MessageType::SIDEBAR_SOURCE);
 
   bindIntToSQL(sidebarSourceType, preparedSQL, 1);
   bindStringToSQL(threadID.c_str(), preparedSQL, 2);
   bindStringToSQL(query.c_str(), preparedSQL, 3);
   bindStringToSQL(threadID.c_str(), preparedSQL, 4);
 
   if (usingCursor) {
     int64_t timestamp = std::stoll(timestampCursor.value());
     bindInt64ToSQL(timestamp, preparedSQL, 5);
     bindInt64ToSQL(timestamp, preparedSQL, 6);
     bindStringToSQL(messageIDCursor.value(), preparedSQL, 7);
   }
 
   std::vector<MessageEntity> messages =
       this->processMessagesResults(preparedSQL);
   std::vector<std::string> messageIDs;
   for (const auto &message : messages) {
     messageIDs.push_back(message.first.id);
   }
   std::vector<MessageEntity> relatedMessages =
       this->getRelatedMessagesForSearch(messageIDs);
 
   for (auto &entity : relatedMessages) {
     messages.push_back(std::move(entity));
   }
   return messages;
 }
 
 std::vector<MessageEntity> SQLiteQueryExecutor::getRelatedMessagesForSearch(
     const std::vector<std::string> &messageIDs) const {
   std::stringstream selectRelatedMessagesSQLStream;
   selectRelatedMessagesSQLStream << "SELECT * "
                                     "FROM messages "
                                     "LEFT JOIN media "
                                     "  ON messages.id = media.container "
                                     "WHERE messages.target_message IN "
                                  << getSQLStatementArray(messageIDs.size())
                                  << "ORDER BY messages.time DESC";
 
   std::string selectRelatedMessagesSQL = selectRelatedMessagesSQLStream.str();
 
   SQLiteStatementWrapper preparedSQL(
       SQLiteQueryExecutor::getConnection(),
       selectRelatedMessagesSQL,
       "Failed to fetch related messages.");
 
   for (int i = 0; i < messageIDs.size(); i++) {
     int bindResult = bindStringToSQL(messageIDs[i], preparedSQL, i + 1);
     if (bindResult != SQLITE_OK) {
       std::stringstream error_message;
       error_message << "Failed to bind key to SQL statement. Details: "
                     << sqlite3_errstr(bindResult) << std::endl;
       sqlite3_finalize(preparedSQL);
       throw std::runtime_error(error_message.str());
     }
   }
 
   return this->processMessagesResults(preparedSQL);
 }
 
 #ifdef EMSCRIPTEN
 std::vector<WebThread> SQLiteQueryExecutor::getAllThreadsWeb() const {
   auto threads = this->getAllThreads();
   std::vector<WebThread> webThreads;
   webThreads.reserve(threads.size());
   for (const auto &thread : threads) {
     webThreads.emplace_back(thread);
   }
   return webThreads;
 };
 
 void SQLiteQueryExecutor::replaceThreadWeb(const WebThread &thread) const {
   this->replaceThread(thread.toThread());
 };
 
 std::vector<MessageWithMedias> SQLiteQueryExecutor::getAllMessagesWeb() const {
   auto allMessages = this->getAllMessages();
 
   std::vector<MessageWithMedias> allMessageWithMedias;
   for (auto &messageWithMedia : allMessages) {
     allMessageWithMedias.push_back(
         {std::move(messageWithMedia.first), messageWithMedia.second});
   }
 
   return allMessageWithMedias;
 }
 
 void SQLiteQueryExecutor::replaceMessageWeb(const WebMessage &message) const {
   this->replaceMessage(message.toMessage());
 };
 
 NullableString
 SQLiteQueryExecutor::getOlmPersistAccountDataWeb(int accountID) const {
   std::optional<std::string> accountData =
       this->getOlmPersistAccountData(accountID);
   if (!accountData.has_value()) {
     return NullableString();
   }
   return std::make_unique<std::string>(accountData.value());
 }
 
 std::vector<MessageWithMedias>
 SQLiteQueryExecutor::getRelatedMessagesWeb(const std::string &messageID) const {
   auto relatedMessages = this->getRelatedMessages(messageID);
 
   std::vector<MessageWithMedias> relatedMessagesWithMedias;
   for (auto &messageWithMedia : relatedMessages) {
     relatedMessagesWithMedias.push_back(
         {std::move(messageWithMedia.first), messageWithMedia.second});
   }
 
   return relatedMessagesWithMedias;
 }
 
 std::vector<MessageWithMedias> SQLiteQueryExecutor::searchMessagesWeb(
     std::string query,
     std::string threadID,
     std::optional<std::string> timestampCursor,
     std::optional<std::string> messageIDCursor) const {
   auto allMessages =
       this->searchMessages(query, threadID, timestampCursor, messageIDCursor);
 
   std::vector<MessageWithMedias> allMessagesWithMedias;
   for (auto &messageWithMedia : allMessages) {
     allMessagesWithMedias.push_back(
         {std::move(messageWithMedia.first), messageWithMedia.second});
   }
 
   return allMessagesWithMedias;
 }
 #else
 void SQLiteQueryExecutor::clearSensitiveData() {
   SQLiteQueryExecutor::closeConnection();
   if (file_exists(SQLiteQueryExecutor::sqliteFilePath) &&
       std::remove(SQLiteQueryExecutor::sqliteFilePath.c_str())) {
     std::ostringstream errorStream;
     errorStream << "Failed to delete database file. Details: "
                 << strerror(errno);
     throw std::system_error(errno, std::generic_category(), errorStream.str());
   }
   SQLiteQueryExecutor::generateFreshEncryptionKey();
   SQLiteQueryExecutor::migrate();
 }
 
 void SQLiteQueryExecutor::initialize(std::string &databasePath) {
   std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() {
     SQLiteQueryExecutor::sqliteFilePath = databasePath;
     folly::Optional<std::string> maybeEncryptionKey =
         CommSecureStore::get(SQLiteQueryExecutor::secureStoreEncryptionKeyID);
     folly::Optional<std::string> maybeBackupLogsEncryptionKey =
         CommSecureStore::get(
             SQLiteQueryExecutor::secureStoreBackupLogsEncryptionKeyID);
 
     if (file_exists(databasePath) && maybeEncryptionKey &&
         maybeBackupLogsEncryptionKey) {
       SQLiteQueryExecutor::encryptionKey = maybeEncryptionKey.value();
       SQLiteQueryExecutor::backupLogsEncryptionKey =
           maybeBackupLogsEncryptionKey.value();
       return;
     } else if (file_exists(databasePath) && maybeEncryptionKey) {
       SQLiteQueryExecutor::encryptionKey = maybeEncryptionKey.value();
       SQLiteQueryExecutor::generateFreshBackupLogsEncryptionKey();
       return;
     }
     SQLiteQueryExecutor::generateFreshEncryptionKey();
   });
 }
 
 void SQLiteQueryExecutor::initializeTablesForLogMonitoring() {
   sqlite3 *db;
   sqlite3_open(SQLiteQueryExecutor::sqliteFilePath.c_str(), &db);
   default_on_db_open_callback(db);
 
   std::vector<std::string> tablesToMonitor;
   {
     SQLiteStatementWrapper preparedSQL(
         db,
         "SELECT name FROM sqlite_master WHERE type='table';",
         "Failed to get all database tables");
 
     for (int stepResult = sqlite3_step(preparedSQL); stepResult == SQLITE_ROW;
          stepResult = sqlite3_step(preparedSQL)) {
       std::string table_name =
           reinterpret_cast<const char *>(sqlite3_column_text(preparedSQL, 0));
       if (SQLiteQueryExecutor::backedUpTablesBlocklist.find(table_name) ==
           SQLiteQueryExecutor::backedUpTablesBlocklist.end()) {
         tablesToMonitor.emplace_back(table_name);
       }
     }
     // Runs preparedSQL destructor which finalizes the sqlite statement
   }
   sqlite3_close(db);
 
   SQLiteQueryExecutor::connectionManager.tablesToMonitor = tablesToMonitor;
 }
 
 void SQLiteQueryExecutor::createMainCompaction(std::string backupID) const {
   std::string finalBackupPath =
       PlatformSpecificTools::getBackupFilePath(backupID, false);
   std::string finalAttachmentsPath =
       PlatformSpecificTools::getBackupFilePath(backupID, true);
 
   std::string tempBackupPath = finalBackupPath + "_tmp";
   std::string tempAttachmentsPath = finalAttachmentsPath + "_tmp";
 
   if (file_exists(tempBackupPath)) {
     Logger::log(
         "Attempting to delete temporary backup file from previous backup "
         "attempt.");
     attempt_delete_file(
         tempBackupPath,
         "Failed to delete temporary backup file from previous backup "
         "attempt.");
   }
 
   if (file_exists(tempAttachmentsPath)) {
     Logger::log(
         "Attempting to delete temporary attachments file from previous "
         "backup "
         "attempt.");
     attempt_delete_file(
         tempAttachmentsPath,
         "Failed to delete temporary attachments file from previous backup "
         "attempt.");
   }
 
   sqlite3 *backupDB;
   sqlite3_open(tempBackupPath.c_str(), &backupDB);
   set_encryption_key(backupDB);
 
   sqlite3_backup *backupObj = sqlite3_backup_init(
       backupDB, "main", SQLiteQueryExecutor::getConnection(), "main");
   if (!backupObj) {
     std::stringstream error_message;
     error_message << "Failed to init backup for main compaction. Details: "
                   << sqlite3_errmsg(backupDB) << std::endl;
     sqlite3_close(backupDB);
     throw std::runtime_error(error_message.str());
   }
 
   int backupResult = sqlite3_backup_step(backupObj, -1);
   sqlite3_backup_finish(backupObj);
   if (backupResult == SQLITE_BUSY || backupResult == SQLITE_LOCKED) {
     sqlite3_close(backupDB);
     throw std::runtime_error(
         "Programmer error. Database in transaction during backup attempt.");
   } else if (backupResult != SQLITE_DONE) {
     sqlite3_close(backupDB);
     std::stringstream error_message;
     error_message << "Failed to create database backup. Details: "
                   << sqlite3_errstr(backupResult);
     throw std::runtime_error(error_message.str());
   }
 
   if (!SQLiteQueryExecutor::backedUpTablesBlocklist.empty()) {
     std::string removeDeviceSpecificDataSQL = "";
     for (const auto &table_name :
          SQLiteQueryExecutor::backedUpTablesBlocklist) {
       removeDeviceSpecificDataSQL.append("DELETE FROM " + table_name + ";\n");
     }
     executeQuery(backupDB, removeDeviceSpecificDataSQL);
   }
 
   executeQuery(backupDB, "VACUUM;");
   sqlite3_close(backupDB);
 
   attempt_rename_file(
       tempBackupPath,
       finalBackupPath,
       "Failed to rename complete temporary backup file to final backup "
       "file.");
 
   std::ofstream tempAttachmentsFile(tempAttachmentsPath);
   if (!tempAttachmentsFile.is_open()) {
     throw std::runtime_error(
         "Unable to create attachments file for backup id: " + backupID);
   }
 
   std::string getAllBlobServiceMediaSQL =
       "SELECT * FROM media WHERE uri LIKE 'comm-blob-service://%';";
   std::vector<Media> blobServiceMedia = getAllEntities<Media>(
       SQLiteQueryExecutor::getConnection(), getAllBlobServiceMediaSQL);
 
   for (const auto &media : blobServiceMedia) {
     std::string blobServiceURI = media.uri;
     std::string blobHash = blob_hash_from_blob_service_uri(blobServiceURI);
     tempAttachmentsFile << blobHash << "\n";
   }
   tempAttachmentsFile.close();
 
   attempt_rename_file(
       tempAttachmentsPath,
       finalAttachmentsPath,
       "Failed to rename complete temporary attachments file to final "
       "attachments file.");
 
   this->setMetadata("backupID", backupID);
   this->clearMetadata("logID");
   if (StaffUtils::isStaffRelease()) {
     SQLiteQueryExecutor::connectionManager.setLogsMonitoring(true);
   }
 }
 
 void SQLiteQueryExecutor::generateFreshEncryptionKey() {
   std::string encryptionKey = comm::crypto::Tools::generateRandomHexString(
       SQLiteQueryExecutor::sqlcipherEncryptionKeySize);
   CommSecureStore::set(
       SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey);
   SQLiteQueryExecutor::encryptionKey = encryptionKey;
   SQLiteQueryExecutor::generateFreshBackupLogsEncryptionKey();
 }
 
 void SQLiteQueryExecutor::generateFreshBackupLogsEncryptionKey() {
   std::string backupLogsEncryptionKey =
       comm::crypto::Tools::generateRandomHexString(
           SQLiteQueryExecutor::backupLogsEncryptionKeySize);
   CommSecureStore::set(
       SQLiteQueryExecutor::secureStoreBackupLogsEncryptionKeyID,
       backupLogsEncryptionKey);
   SQLiteQueryExecutor::backupLogsEncryptionKey = backupLogsEncryptionKey;
 }
 
 void SQLiteQueryExecutor::captureBackupLogs() const {
   std::string backupID = this->getMetadata("backupID");
   if (!backupID.size()) {
     return;
   }
 
   std::string logID = this->getMetadata("logID");
   if (!logID.size()) {
     logID = "1";
   }
 
   bool newLogCreated = SQLiteQueryExecutor::connectionManager.captureLogs(
       backupID, logID, SQLiteQueryExecutor::backupLogsEncryptionKey);
   if (!newLogCreated) {
     return;
   }
   this->setMetadata("logID", std::to_string(std::stoi(logID) + 1));
 }
 #endif
 
 void SQLiteQueryExecutor::restoreFromMainCompaction(
     std::string mainCompactionPath,
     std::string mainCompactionEncryptionKey,
     std::string maxVersion) const {
 
   if (!file_exists(mainCompactionPath)) {
     throw std::runtime_error("Restore attempt but backup file does not exist.");
   }
 
   sqlite3 *backupDB;
   if (!is_database_queryable(
           backupDB, true, mainCompactionPath, mainCompactionEncryptionKey)) {
     throw std::runtime_error("Backup file or encryption key corrupted.");
   }
 
 // We don't want to run `PRAGMA key = ...;`
 // on main web database. The context is here:
 // https://linear.app/comm/issue/ENG-6398/issues-with-sqlcipher-on-web
 #ifdef EMSCRIPTEN
   std::string plaintextBackupPath = mainCompactionPath + "_plaintext";
   if (file_exists(plaintextBackupPath)) {
     attempt_delete_file(
         plaintextBackupPath,
         "Failed to delete plaintext backup file from previous backup "
         "attempt.");
   }
 
   std::string plaintextMigrationDBQuery = "PRAGMA key = \"x'" +
       mainCompactionEncryptionKey +
       "'\";"
       "ATTACH DATABASE '" +
       plaintextBackupPath +
       "' AS plaintext KEY '';"
       "SELECT sqlcipher_export('plaintext');"
       "DETACH DATABASE plaintext;";
 
   sqlite3_open(mainCompactionPath.c_str(), &backupDB);
 
   char *plaintextMigrationErr;
   sqlite3_exec(
       backupDB,
       plaintextMigrationDBQuery.c_str(),
       nullptr,
       nullptr,
       &plaintextMigrationErr);
   sqlite3_close(backupDB);
 
   if (plaintextMigrationErr) {
     std::stringstream error_message;
     error_message << "Failed to migrate backup SQLCipher file to plaintext "
                      "SQLite file. Details"
                   << plaintextMigrationErr << std::endl;
     std::string error_message_str = error_message.str();
     sqlite3_free(plaintextMigrationErr);
 
     throw std::runtime_error(error_message_str);
   }
 
   sqlite3_open(plaintextBackupPath.c_str(), &backupDB);
 #else
   sqlite3_open(mainCompactionPath.c_str(), &backupDB);
   set_encryption_key(backupDB, mainCompactionEncryptionKey);
 #endif
 
   int version = this->getSyncedDatabaseVersion(backupDB).value_or(-1);
   if (version > std::stoi(maxVersion)) {
     std::stringstream error_message;
     error_message << "Failed to restore a backup because it was created "
                   << "with version " << version
                   << " that is newer than the max supported version "
                   << maxVersion << std::endl;
     sqlite3_close(backupDB);
     throw std::runtime_error(error_message.str());
   }
 
   sqlite3_backup *backupObj = sqlite3_backup_init(
       SQLiteQueryExecutor::getConnection(), "main", backupDB, "main");
   if (!backupObj) {
     std::stringstream error_message;
     error_message << "Failed to init backup for main compaction. Details: "
                   << sqlite3_errmsg(SQLiteQueryExecutor::getConnection())
                   << std::endl;
     sqlite3_close(backupDB);
     throw std::runtime_error(error_message.str());
   }
 
   int backupResult = sqlite3_backup_step(backupObj, -1);
   sqlite3_backup_finish(backupObj);
   sqlite3_close(backupDB);
   if (backupResult == SQLITE_BUSY || backupResult == SQLITE_LOCKED) {
     throw std::runtime_error(
         "Programmer error. Database in transaction during restore attempt.");
   } else if (backupResult != SQLITE_DONE) {
     std::stringstream error_message;
     error_message << "Failed to restore database from backup. Details: "
                   << sqlite3_errstr(backupResult);
     throw std::runtime_error(error_message.str());
   }
 
 #ifdef EMSCRIPTEN
   attempt_delete_file(
       plaintextBackupPath,
       "Failed to delete plaintext compaction file after successful restore.");
 #endif
 
   attempt_delete_file(
       mainCompactionPath,
       "Failed to delete main compaction file after successful restore.");
 }
 
 void SQLiteQueryExecutor::restoreFromBackupLog(
     const std::vector<std::uint8_t> &backupLog) const {
   SQLiteQueryExecutor::connectionManager.restoreFromBackupLog(backupLog);
 }
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h b/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h
index 2d82b8bcf..4b7aa7b97 100644
--- a/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h
+++ b/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h
@@ -1,224 +1,224 @@
 #pragma once
 
 #include "../CryptoTools/Persist.h"
 #include "DatabaseQueryExecutor.h"
 #include "NativeSQLiteConnectionManager.h"
 #include "entities/AuxUserInfo.h"
 #include "entities/CommunityInfo.h"
 #include "entities/Draft.h"
 #include "entities/IntegrityThreadHash.h"
 #include "entities/KeyserverInfo.h"
 #include "entities/LocalMessageInfo.h"
 #include "entities/Media.h"
 #include "entities/Message.h"
 #include "entities/MessageSearchResult.h"
 #include "entities/SQLiteStatementWrapper.h"
 #include "entities/ThreadActivityEntry.h"
 #include "entities/UserInfo.h"
 
 #include <mutex>
 #include <string>
 #include <unordered_set>
 
 namespace comm {
 
 class SQLiteQueryExecutor : public DatabaseQueryExecutor {
   static void migrate();
   static sqlite3 *getConnection();
   static void closeConnection();
 
   static std::once_flag initialized;
   static int sqlcipherEncryptionKeySize;
   static std::string secureStoreEncryptionKeyID;
   static int backupLogsEncryptionKeySize;
   static std::string secureStoreBackupLogsEncryptionKeyID;
   static std::string backupLogsEncryptionKey;
 
 #ifndef EMSCRIPTEN
   static NativeSQLiteConnectionManager connectionManager;
   static std::unordered_set<std::string> backedUpTablesBlocklist;
   static void generateFreshEncryptionKey();
   static void generateFreshBackupLogsEncryptionKey();
   static void initializeTablesForLogMonitoring();
 #else
   static SQLiteConnectionManager connectionManager;
 #endif
 
   std::optional<int> getSyncedDatabaseVersion(sqlite3 *db) const;
   std::vector<MessageEntity>
   processMessagesResults(SQLiteStatementWrapper &preparedSQL) const;
 
 public:
   static std::string sqliteFilePath;
   static std::string encryptionKey;
 
   SQLiteQueryExecutor();
   ~SQLiteQueryExecutor();
   SQLiteQueryExecutor(std::string sqliteFilePath);
   std::unique_ptr<Thread> getThread(std::string threadID) const override;
   std::string getDraft(std::string key) const override;
   void updateDraft(std::string key, std::string text) const override;
   bool moveDraft(std::string oldKey, std::string newKey) const override;
   std::vector<Draft> getAllDrafts() const override;
   void removeAllDrafts() const override;
   void removeDrafts(const std::vector<std::string> &ids) const override;
   void removeAllMessages() const override;
   std::vector<MessageEntity> getAllMessages() const override;
   void removeMessages(const std::vector<std::string> &ids) const override;
   void removeMessagesForThreads(
       const std::vector<std::string> &threadIDs) const override;
   void replaceMessage(const Message &message) const override;
   void rekeyMessage(std::string from, std::string to) const override;
   void replaceMessageStoreThreads(
       const std::vector<MessageStoreThread> &threads) const override;
   void
   removeMessageStoreThreads(const std::vector<std::string> &ids) const override;
   void removeAllMessageStoreThreads() const override;
   std::vector<MessageStoreThread> getAllMessageStoreThreads() const override;
   void removeAllMedia() const override;
   void
   removeMediaForMessages(const std::vector<std::string> &msgIDs) const override;
   void removeMediaForMessage(std::string msgID) const override;
   void removeMediaForThreads(
       const std::vector<std::string> &threadIDs) const override;
   void replaceMedia(const Media &media) const override;
   void rekeyMediaContainers(std::string from, std::string to) const override;
   std::vector<Thread> getAllThreads() const override;
   void removeThreads(std::vector<std::string> ids) const override;
   void replaceThread(const Thread &thread) const override;
   void removeAllThreads() const override;
   void replaceReport(const Report &report) const override;
   void removeReports(const std::vector<std::string> &ids) const override;
   void removeAllReports() const override;
   std::vector<Report> getAllReports() const override;
   void setPersistStorageItem(std::string key, std::string item) const override;
   void removePersistStorageItem(std::string key) const override;
   std::string getPersistStorageItem(std::string key) const override;
   void replaceUser(const UserInfo &userInfo) const override;
   void removeUsers(const std::vector<std::string> &ids) const override;
   void removeAllUsers() const override;
   std::vector<UserInfo> getAllUsers() const override;
   void replaceKeyserver(const KeyserverInfo &keyserverInfo) const override;
   void removeKeyservers(const std::vector<std::string> &ids) const override;
   void removeAllKeyservers() const override;
   std::vector<KeyserverInfo> getAllKeyservers() const override;
   void replaceCommunity(const CommunityInfo &communityInfo) const override;
   void removeCommunities(const std::vector<std::string> &ids) const override;
   void removeAllCommunities() const override;
   std::vector<CommunityInfo> getAllCommunities() const override;
   void replaceIntegrityThreadHashes(
       const std::vector<IntegrityThreadHash> &threadHashes) const override;
   void removeIntegrityThreadHashes(
       const std::vector<std::string> &ids) const override;
   void removeAllIntegrityThreadHashes() const override;
   std::vector<IntegrityThreadHash> getAllIntegrityThreadHashes() const override;
   void replaceSyncedMetadataEntry(
       const SyncedMetadataEntry &syncedMetadataEntry) const override;
   void
   removeSyncedMetadata(const std::vector<std::string> &names) const override;
   void removeAllSyncedMetadata() const override;
   std::vector<SyncedMetadataEntry> getAllSyncedMetadata() const override;
   void replaceAuxUserInfo(const AuxUserInfo &userInfo) const override;
   void removeAuxUserInfos(const std::vector<std::string> &ids) const override;
   void removeAllAuxUserInfos() const override;
   virtual std::vector<AuxUserInfo> getAllAuxUserInfos() const override;
   void replaceThreadActivityEntry(
       const ThreadActivityEntry &threadActivityEntry) const override;
   void removeThreadActivityEntries(
       const std::vector<std::string> &ids) const override;
   void removeAllThreadActivityEntries() const override;
   std::vector<ThreadActivityEntry> getAllThreadActivityEntries() const override;
   void replaceEntry(const EntryInfo &entryInfo) const override;
   void removeEntries(const std::vector<std::string> &ids) const override;
   void removeAllEntries() const override;
   std::vector<EntryInfo> getAllEntries() const override;
   void replaceMessageStoreLocalMessageInfo(
       const LocalMessageInfo &localMessageInfo) const override;
   void removeMessageStoreLocalMessageInfos(
       const std::vector<std::string> &ids) const override;
   void removeAllMessageStoreLocalMessageInfos() const override;
   virtual std::vector<LocalMessageInfo>
   getAllMessageStoreLocalMessageInfos() const override;
   void beginTransaction() const override;
   void commitTransaction() const override;
   void rollbackTransaction() const override;
   int getContentAccountID() const override;
   int getNotifsAccountID() const override;
   std::vector<OlmPersistSession> getOlmPersistSessionsData() const override;
   std::optional<std::string>
   getOlmPersistAccountData(int accountID) const override;
   void storeOlmPersistSession(const OlmPersistSession &session) const override;
   void storeOlmPersistAccount(int accountID, const std::string &accountData)
       const override;
   void
   storeOlmPersistData(int accountID, crypto::Persist persist) const override;
   void setNotifyToken(std::string token) const override;
   void clearNotifyToken() const override;
   void stampSQLiteDBUserID(std::string userID) const override;
   std::string getSQLiteStampedUserID() const override;
   void setMetadata(std::string entryName, std::string data) const override;
   void clearMetadata(std::string entryName) const override;
   std::string getMetadata(std::string entryName) const override;
   void restoreFromMainCompaction(
       std::string mainCompactionPath,
       std::string mainCompactionEncryptionKey,
       std::string maxVersion) const override;
   void restoreFromBackupLog(
       const std::vector<std::uint8_t> &backupLog) const override;
   void addOutboundP2PMessages(
       const std::vector<OutboundP2PMessage> &messages) const override;
   std::vector<OutboundP2PMessage> getOutboundP2PMessagesByID(
       const std::vector<std::string> &ids) const override;
   std::vector<OutboundP2PMessage> getAllOutboundP2PMessages() const override;
-  void removeOutboundP2PMessagesOlderThan(
-      std::string lastConfirmedMessageID,
+  void removeOutboundP2PMessage(
+      std::string confirmedMessageID,
       std::string deviceID) const override;
   void removeAllOutboundP2PMessages(const std::string &deviceID) const override;
   void setCiphertextForOutboundP2PMessage(
       std::string messageID,
       std::string deviceID,
       std::string ciphertext) const override;
   void markOutboundP2PMessageAsSent(std::string messageID, std::string deviceID)
       const override;
   std::vector<std::string>
   resetOutboundP2PMessagesForDevice(std::string deviceID) const override;
   void addInboundP2PMessage(InboundP2PMessage message) const override;
   std::vector<InboundP2PMessage> getAllInboundP2PMessage() const override;
   void
   removeInboundP2PMessages(const std::vector<std::string> &ids) const override;
   std::vector<MessageEntity>
   getRelatedMessages(const std::string &messageID) const override;
   void updateMessageSearchIndex(
       std::string originalMessageID,
       std::string messageID,
       std::string processedContent) const override;
   std::vector<MessageEntity> searchMessages(
       std::string query,
       std::string threadID,
       std::optional<std::string> timestampCursor,
       std::optional<std::string> messageIDCursor) const override;
   std::vector<MessageEntity> getRelatedMessagesForSearch(
       const std::vector<std::string> &messageIDs) const override;
 
 #ifdef EMSCRIPTEN
   std::vector<WebThread> getAllThreadsWeb() const override;
   void replaceThreadWeb(const WebThread &thread) const override;
   std::vector<MessageWithMedias> getAllMessagesWeb() const override;
   void replaceMessageWeb(const WebMessage &message) const override;
   NullableString getOlmPersistAccountDataWeb(int accountID) const override;
   std::vector<MessageWithMedias>
   getRelatedMessagesWeb(const std::string &messageID) const override;
   std::vector<MessageWithMedias> searchMessagesWeb(
       std::string query,
       std::string threadID,
       std::optional<std::string> timestampCursor,
       std::optional<std::string> messageIDCursor) const override;
 #else
   static void clearSensitiveData();
   static void initialize(std::string &databasePath);
   void createMainCompaction(std::string backupID) const override;
   void captureBackupLogs() const override;
 #endif
 };
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp b/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
index 25ad1b430..1a6db3396 100644
--- a/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
+++ b/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
@@ -1,3100 +1,3100 @@
 #include "CommCoreModule.h"
 #include "../Notifications/BackgroundDataStorage/NotificationsCryptoModule.h"
 #include "BaseDataStore.h"
 #include "CommServicesAuthMetadataEmitter.h"
 #include "DatabaseManager.h"
 #include "InternalModules/GlobalDBSingleton.h"
 #include "InternalModules/RustPromiseManager.h"
 #include "NativeModuleUtils.h"
 #include "TerminateApp.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 #include <folly/dynamic.h>
 #include <folly/json.h>
 #include <future>
 
 #include "JSIRust.h"
 #include "lib.rs.h"
 #include <algorithm>
 #include <string>
 
 namespace comm {
 
 using namespace facebook::react;
 
 jsi::Value CommCoreModule::getDraft(jsi::Runtime &rt, jsi::String key) {
   std::string keyStr = key.utf8(rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string draftStr;
           try {
             draftStr = DatabaseManager::getQueryExecutor().getDraft(keyStr);
           } catch (std::system_error &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             jsi::String draft = jsi::String::createFromUtf8(innerRt, draftStr);
             promise->resolve(std::move(draft));
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::updateDraft(
     jsi::Runtime &rt,
     jsi::String key,
     jsi::String text) {
   std::string keyStr = key.utf8(rt);
   std::string textStr = text.utf8(rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=]() {
           std::string error;
           try {
             DatabaseManager::getQueryExecutor().updateDraft(keyStr, textStr);
           } catch (std::system_error &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(true);
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::moveDraft(
     jsi::Runtime &rt,
     jsi::String oldKey,
     jsi::String newKey) {
   std::string oldKeyStr = oldKey.utf8(rt);
   std::string newKeyStr = newKey.utf8(rt);
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=]() {
           std::string error;
           bool result = false;
           try {
             result = DatabaseManager::getQueryExecutor().moveDraft(
                 oldKeyStr, newKeyStr);
           } catch (std::system_error &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(result);
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::getClientDBStore(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::vector<Draft> draftsVector;
           std::vector<Thread> threadsVector;
           std::vector<MessageEntity> messagesVector;
           std::vector<MessageStoreThread> messageStoreThreadsVector;
           std::vector<Report> reportStoreVector;
           std::vector<UserInfo> userStoreVector;
           std::vector<KeyserverInfo> keyserverStoreVector;
           std::vector<CommunityInfo> communityStoreVector;
           std::vector<IntegrityThreadHash> integrityStoreVector;
           std::vector<SyncedMetadataEntry> syncedMetadataStoreVector;
           std::vector<AuxUserInfo> auxUserStoreVector;
           std::vector<ThreadActivityEntry> threadActivityStoreVector;
           std::vector<EntryInfo> entryStoreVector;
           std::vector<LocalMessageInfo> messageStoreLocalMessageInfosVector;
           try {
             draftsVector = DatabaseManager::getQueryExecutor().getAllDrafts();
             messagesVector =
                 DatabaseManager::getQueryExecutor().getAllMessages();
             threadsVector = DatabaseManager::getQueryExecutor().getAllThreads();
             messageStoreThreadsVector =
                 DatabaseManager::getQueryExecutor().getAllMessageStoreThreads();
             reportStoreVector =
                 DatabaseManager::getQueryExecutor().getAllReports();
             userStoreVector = DatabaseManager::getQueryExecutor().getAllUsers();
             keyserverStoreVector =
                 DatabaseManager::getQueryExecutor().getAllKeyservers();
             communityStoreVector =
                 DatabaseManager::getQueryExecutor().getAllCommunities();
             integrityStoreVector = DatabaseManager::getQueryExecutor()
                                        .getAllIntegrityThreadHashes();
             syncedMetadataStoreVector =
                 DatabaseManager::getQueryExecutor().getAllSyncedMetadata();
             auxUserStoreVector =
                 DatabaseManager::getQueryExecutor().getAllAuxUserInfos();
             threadActivityStoreVector = DatabaseManager::getQueryExecutor()
                                             .getAllThreadActivityEntries();
             entryStoreVector =
                 DatabaseManager::getQueryExecutor().getAllEntries();
             messageStoreLocalMessageInfosVector =
                 DatabaseManager::getQueryExecutor()
                     .getAllMessageStoreLocalMessageInfos();
           } catch (std::system_error &e) {
             error = e.what();
           }
           auto draftsVectorPtr =
               std::make_shared<std::vector<Draft>>(std::move(draftsVector));
           auto messagesVectorPtr = std::make_shared<std::vector<MessageEntity>>(
               std::move(messagesVector));
           auto threadsVectorPtr =
               std::make_shared<std::vector<Thread>>(std::move(threadsVector));
           auto messageStoreThreadsVectorPtr =
               std::make_shared<std::vector<MessageStoreThread>>(
                   std::move(messageStoreThreadsVector));
           auto reportStoreVectorPtr = std::make_shared<std::vector<Report>>(
               std::move(reportStoreVector));
           auto userStoreVectorPtr = std::make_shared<std::vector<UserInfo>>(
               std::move(userStoreVector));
           auto keyserveStoreVectorPtr =
               std::make_shared<std::vector<KeyserverInfo>>(
                   std::move(keyserverStoreVector));
           auto communityStoreVectorPtr =
               std::make_shared<std::vector<CommunityInfo>>(
                   std::move(communityStoreVector));
           auto integrityStoreVectorPtr =
               std::make_shared<std::vector<IntegrityThreadHash>>(
                   std::move(integrityStoreVector));
           auto syncedMetadataStoreVectorPtr =
               std::make_shared<std::vector<SyncedMetadataEntry>>(
                   std::move(syncedMetadataStoreVector));
           auto auxUserStoreVectorPtr =
               std::make_shared<std::vector<AuxUserInfo>>(
                   std::move(auxUserStoreVector));
           auto threadActivityStoreVectorPtr =
               std::make_shared<std::vector<ThreadActivityEntry>>(
                   std::move(threadActivityStoreVector));
           auto entryStoreVectorPtr = std::make_shared<std::vector<EntryInfo>>(
               std::move(entryStoreVector));
           auto messageStoreLocalMessageInfosVectorPtr =
               std::make_shared<std::vector<LocalMessageInfo>>(
                   std::move(messageStoreLocalMessageInfosVector));
           this->jsInvoker_->invokeAsync([&innerRt,
                                          draftsVectorPtr,
                                          messagesVectorPtr,
                                          threadsVectorPtr,
                                          messageStoreThreadsVectorPtr,
                                          reportStoreVectorPtr,
                                          userStoreVectorPtr,
                                          keyserveStoreVectorPtr,
                                          communityStoreVectorPtr,
                                          integrityStoreVectorPtr,
                                          syncedMetadataStoreVectorPtr,
                                          auxUserStoreVectorPtr,
                                          threadActivityStoreVectorPtr,
                                          entryStoreVectorPtr,
                                          messageStoreLocalMessageInfosVectorPtr,
                                          error,
                                          promise,
                                          draftStore = this->draftStore,
                                          threadStore = this->threadStore,
                                          messageStore = this->messageStore,
                                          reportStore = this->reportStore,
                                          userStore = this->userStore,
                                          keyserverStore = this->keyserverStore,
                                          communityStore = this->communityStore,
                                          integrityStore = this->integrityStore,
                                          syncedMetadataStore =
                                              this->syncedMetadataStore,
                                          auxUserStore = this->auxUserStore,
                                          threadActivityStore =
                                              this->threadActivityStore,
                                          entryStore = this->entryStore]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             jsi::Array jsiDrafts =
                 draftStore.parseDBDataStore(innerRt, draftsVectorPtr);
             jsi::Array jsiMessages =
                 messageStore.parseDBDataStore(innerRt, messagesVectorPtr);
             jsi::Array jsiThreads =
                 threadStore.parseDBDataStore(innerRt, threadsVectorPtr);
             jsi::Array jsiMessageStoreThreads =
                 messageStore.parseDBMessageStoreThreads(
                     innerRt, messageStoreThreadsVectorPtr);
             jsi::Array jsiReportStore =
                 reportStore.parseDBDataStore(innerRt, reportStoreVectorPtr);
             jsi::Array jsiUserStore =
                 userStore.parseDBDataStore(innerRt, userStoreVectorPtr);
             jsi::Array jsiKeyserverStore = keyserverStore.parseDBDataStore(
                 innerRt, keyserveStoreVectorPtr);
             jsi::Array jsiCommunityStore = communityStore.parseDBDataStore(
                 innerRt, communityStoreVectorPtr);
             jsi::Array jsiIntegrityStore = integrityStore.parseDBDataStore(
                 innerRt, integrityStoreVectorPtr);
             jsi::Array jsiSyncedMetadataStore =
                 syncedMetadataStore.parseDBDataStore(
                     innerRt, syncedMetadataStoreVectorPtr);
             jsi::Array jsiAuxUserStore =
                 auxUserStore.parseDBDataStore(innerRt, auxUserStoreVectorPtr);
             jsi::Array jsiThreadActivityStore =
                 threadActivityStore.parseDBDataStore(
                     innerRt, threadActivityStoreVectorPtr);
             jsi::Array jsiEntryStore =
                 entryStore.parseDBDataStore(innerRt, entryStoreVectorPtr);
             jsi::Array jsiMessageStoreLocalMessageInfos =
                 messageStore.parseDBMessageStoreLocalMessageInfos(
                     innerRt, messageStoreLocalMessageInfosVectorPtr);
 
             auto jsiClientDBStore = jsi::Object(innerRt);
             jsiClientDBStore.setProperty(innerRt, "messages", jsiMessages);
             jsiClientDBStore.setProperty(innerRt, "threads", jsiThreads);
             jsiClientDBStore.setProperty(innerRt, "drafts", jsiDrafts);
             jsiClientDBStore.setProperty(
                 innerRt, "messageStoreThreads", jsiMessageStoreThreads);
             jsiClientDBStore.setProperty(innerRt, "reports", jsiReportStore);
             jsiClientDBStore.setProperty(innerRt, "users", jsiUserStore);
             jsiClientDBStore.setProperty(
                 innerRt, "keyservers", jsiKeyserverStore);
             jsiClientDBStore.setProperty(
                 innerRt, "communities", jsiCommunityStore);
             jsiClientDBStore.setProperty(
                 innerRt, "integrityThreadHashes", jsiIntegrityStore);
             jsiClientDBStore.setProperty(
                 innerRt, "syncedMetadata", jsiSyncedMetadataStore);
             jsiClientDBStore.setProperty(
                 innerRt, "auxUserInfos", jsiAuxUserStore);
             jsiClientDBStore.setProperty(
                 innerRt, "threadActivityEntries", jsiThreadActivityStore);
             jsiClientDBStore.setProperty(innerRt, "entries", jsiEntryStore);
             jsiClientDBStore.setProperty(
                 innerRt,
                 "messageStoreLocalMessageInfos",
                 jsiMessageStoreLocalMessageInfos);
 
             promise->resolve(std::move(jsiClientDBStore));
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::removeAllDrafts(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=]() {
           std::string error;
           try {
             DatabaseManager::getQueryExecutor().removeAllDrafts();
           } catch (std::system_error &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(jsi::Value::undefined());
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Array CommCoreModule::getAllMessagesSync(jsi::Runtime &rt) {
   auto messagesVector =
       NativeModuleUtils::runSyncOrThrowJSError<std::vector<MessageEntity>>(
           rt, []() {
             return DatabaseManager::getQueryExecutor().getAllMessages();
           });
   auto messagesVectorPtr =
       std::make_shared<std::vector<MessageEntity>>(std::move(messagesVector));
   jsi::Array jsiMessages =
       this->messageStore.parseDBDataStore(rt, messagesVectorPtr);
   return jsiMessages;
 }
 
 void CommCoreModule::processMessageStoreOperationsSync(
     jsi::Runtime &rt,
     jsi::Array operations) {
   return this->messageStore.processStoreOperationsSync(
       rt, std::move(operations));
 }
 
 jsi::Array CommCoreModule::getAllThreadsSync(jsi::Runtime &rt) {
   auto threadsVector =
       NativeModuleUtils::runSyncOrThrowJSError<std::vector<Thread>>(rt, []() {
         return DatabaseManager::getQueryExecutor().getAllThreads();
       });
 
   auto threadsVectorPtr =
       std::make_shared<std::vector<Thread>>(std::move(threadsVector));
   jsi::Array jsiThreads =
       this->threadStore.parseDBDataStore(rt, threadsVectorPtr);
 
   return jsiThreads;
 }
 
 void CommCoreModule::processThreadStoreOperationsSync(
     jsi::Runtime &rt,
     jsi::Array operations) {
   this->threadStore.processStoreOperationsSync(rt, std::move(operations));
 }
 
 void CommCoreModule::processReportStoreOperationsSync(
     jsi::Runtime &rt,
     jsi::Array operations) {
   this->reportStore.processStoreOperationsSync(rt, std::move(operations));
 }
 
 template <typename T>
 void CommCoreModule::appendDBStoreOps(
     jsi::Runtime &rt,
     jsi::Object &operations,
     const char *key,
     T &store,
     std::shared_ptr<std::vector<std::unique_ptr<DBOperationBase>>>
         &destination) {
   auto opsObject = operations.getProperty(rt, key);
   if (opsObject.isObject()) {
     auto ops = store.createOperations(rt, opsObject.asObject(rt).asArray(rt));
     std::move(
         std::make_move_iterator(ops.begin()),
         std::make_move_iterator(ops.end()),
         std::back_inserter(*destination));
   }
 }
 
 jsi::Value CommCoreModule::processDBStoreOperations(
     jsi::Runtime &rt,
     jsi::Object operations) {
   std::string createOperationsError;
 
   auto storeOpsPtr =
       std::make_shared<std::vector<std::unique_ptr<DBOperationBase>>>();
   try {
     this->appendDBStoreOps(
         rt, operations, "draftStoreOperations", this->draftStore, storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "threadStoreOperations",
         this->threadStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "messageStoreOperations",
         this->messageStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "reportStoreOperations",
         this->reportStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt, operations, "userStoreOperations", this->userStore, storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "keyserverStoreOperations",
         this->keyserverStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "communityStoreOperations",
         this->communityStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "integrityStoreOperations",
         this->integrityStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "syncedMetadataStoreOperations",
         this->syncedMetadataStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "auxUserStoreOperations",
         this->auxUserStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "threadActivityStoreOperations",
         this->threadActivityStore,
         storeOpsPtr);
     this->appendDBStoreOps(
         rt, operations, "entryStoreOperations", this->entryStore, storeOpsPtr);
     this->appendDBStoreOps(
         rt,
         operations,
         "messageSearchStoreOperations",
         this->messageSearchStore,
         storeOpsPtr);
   } catch (std::runtime_error &e) {
     createOperationsError = e.what();
   }
 
   std::vector<OutboundP2PMessage> messages;
   try {
     auto messagesJSIObj = operations.getProperty(rt, "outboundP2PMessages");
 
     if (messagesJSIObj.isObject()) {
       auto messagesJSI = messagesJSIObj.asObject(rt).asArray(rt);
       for (size_t idx = 0; idx < messagesJSI.size(rt); idx++) {
         jsi::Object msgObj = messagesJSI.getValueAtIndex(rt, idx).asObject(rt);
 
         std::string messageID =
             msgObj.getProperty(rt, "messageID").asString(rt).utf8(rt);
         std::string deviceID =
             msgObj.getProperty(rt, "deviceID").asString(rt).utf8(rt);
         std::string userID =
             msgObj.getProperty(rt, "userID").asString(rt).utf8(rt);
         std::string timestamp =
             msgObj.getProperty(rt, "timestamp").asString(rt).utf8(rt);
         std::string plaintext =
             msgObj.getProperty(rt, "plaintext").asString(rt).utf8(rt);
         std::string ciphertext =
             msgObj.getProperty(rt, "ciphertext").asString(rt).utf8(rt);
         std::string status =
             msgObj.getProperty(rt, "status").asString(rt).utf8(rt);
         bool supports_auto_retry =
             msgObj.getProperty(rt, "supportsAutoRetry").asBool();
 
         OutboundP2PMessage outboundMessage{
             messageID,
             deviceID,
             userID,
             timestamp,
             plaintext,
             ciphertext,
             status,
             supports_auto_retry};
         messages.push_back(outboundMessage);
       }
     }
 
   } catch (std::runtime_error &e) {
     createOperationsError = e.what();
   }
 
   return facebook::react::createPromiseAsJSIValue(
       rt,
       [=](jsi::Runtime &innerRt,
           std::shared_ptr<facebook::react::Promise> promise) {
         taskType job = [=]() {
           std::string error = createOperationsError;
 
           if (!error.size()) {
             try {
               DatabaseManager::getQueryExecutor().beginTransaction();
               for (const auto &operation : *storeOpsPtr) {
                 operation->execute();
               }
               if (messages.size() > 0) {
                 DatabaseManager::getQueryExecutor().addOutboundP2PMessages(
                     messages);
               }
               DatabaseManager::getQueryExecutor().captureBackupLogs();
               DatabaseManager::getQueryExecutor().commitTransaction();
             } catch (std::system_error &e) {
               error = e.what();
               DatabaseManager::getQueryExecutor().rollbackTransaction();
             }
           }
 
           if (!error.size()) {
             ::triggerBackupFileUpload();
           }
 
           this->jsInvoker_->invokeAsync([=]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 void CommCoreModule::terminate(jsi::Runtime &rt) {
   TerminateApp::terminate();
 }
 
 const std::string
 getAccountDataKey(const std::string secureStoreAccountDataKey) {
   folly::Optional<std::string> storedSecretKey =
       CommSecureStore::get(secureStoreAccountDataKey);
   if (!storedSecretKey.hasValue()) {
     storedSecretKey = crypto::Tools::generateRandomString(64);
     CommSecureStore::set(secureStoreAccountDataKey, storedSecretKey.value());
   }
   return storedSecretKey.value();
 }
 
 void CommCoreModule::persistCryptoModules(
     bool persistContentModule,
     std::optional<std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
         maybeUpdatedNotifsCryptoModule) {
   std::string storedSecretKey = getAccountDataKey(secureStoreAccountDataKey);
 
   if (!persistContentModule && !maybeUpdatedNotifsCryptoModule.has_value()) {
     return;
   }
 
   crypto::Persist newContentPersist;
   if (persistContentModule) {
     newContentPersist = this->contentCryptoModule->storeAsB64(storedSecretKey);
   }
 
   std::promise<void> persistencePromise;
   std::future<void> persistenceFuture = persistencePromise.get_future();
   GlobalDBSingleton::instance.scheduleOrRunCancellable(
       [=, &persistencePromise]() {
         try {
           DatabaseManager::getQueryExecutor().beginTransaction();
           if (persistContentModule) {
             DatabaseManager::getQueryExecutor().storeOlmPersistData(
                 DatabaseManager::getQueryExecutor().getContentAccountID(),
                 newContentPersist);
           }
           if (maybeUpdatedNotifsCryptoModule.has_value()) {
             NotificationsCryptoModule::persistNotificationsAccount(
                 maybeUpdatedNotifsCryptoModule.value().first,
                 maybeUpdatedNotifsCryptoModule.value().second,
                 true);
           }
           DatabaseManager::getQueryExecutor().commitTransaction();
           persistencePromise.set_value();
         } catch (std::system_error &e) {
           DatabaseManager::getQueryExecutor().rollbackTransaction();
           persistencePromise.set_exception(std::make_exception_ptr(e));
         }
       });
   persistenceFuture.get();
 }
 
 jsi::Value CommCoreModule::initializeCryptoAccount(jsi::Runtime &rt) {
   folly::Optional<std::string> storedSecretKey =
       CommSecureStore::get(this->secureStoreAccountDataKey);
   if (!storedSecretKey.hasValue()) {
     storedSecretKey = crypto::Tools::generateRandomString(64);
     CommSecureStore::set(
         this->secureStoreAccountDataKey, storedSecretKey.value());
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=]() {
           crypto::Persist contentPersist;
           crypto::Persist notifsPersist;
           std::string error;
           try {
             std::optional<std::string> contentAccountData =
                 DatabaseManager::getQueryExecutor().getOlmPersistAccountData(
                     DatabaseManager::getQueryExecutor().getContentAccountID());
             if (contentAccountData.has_value()) {
               contentPersist.account = crypto::OlmBuffer(
                   contentAccountData->begin(), contentAccountData->end());
               // handle sessions data
               std::vector<OlmPersistSession> sessionsData =
                   DatabaseManager::getQueryExecutor()
                       .getOlmPersistSessionsData();
               for (OlmPersistSession &sessionsDataItem : sessionsData) {
                 crypto::OlmBuffer sessionDataBuffer(
                     sessionsDataItem.session_data.begin(),
                     sessionsDataItem.session_data.end());
                 crypto::SessionPersist sessionPersist{
                     sessionDataBuffer, sessionsDataItem.version};
                 contentPersist.sessions.insert(std::make_pair(
                     sessionsDataItem.target_device_id, sessionPersist));
               }
             }
 
             std::optional<std::string> notifsAccountData =
                 DatabaseManager::getQueryExecutor().getOlmPersistAccountData(
                     DatabaseManager::getQueryExecutor().getNotifsAccountID());
 
             if (notifsAccountData.has_value()) {
               notifsPersist.account = crypto::OlmBuffer(
                   notifsAccountData->begin(), notifsAccountData->end());
             }
 
           } catch (std::system_error &e) {
             error = e.what();
           }
 
           this->cryptoThread->scheduleTask([=]() {
             std::string error;
             this->contentCryptoModule.reset(new crypto::CryptoModule(
                 this->publicCryptoAccountID,
                 storedSecretKey.value(),
                 contentPersist));
 
             std::optional<
                 std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
                 maybeNotifsCryptoAccountToPersist;
 
             if (!NotificationsCryptoModule::
                     isNotificationsAccountInitialized()) {
               maybeNotifsCryptoAccountToPersist = {
                   std::make_shared<crypto::CryptoModule>(
                       this->notifsCryptoAccountID,
                       storedSecretKey.value(),
                       notifsPersist),
                   storedSecretKey.value()};
             }
 
             try {
               this->persistCryptoModules(
                   contentPersist.isEmpty(), maybeNotifsCryptoAccountToPersist);
             } catch (const std::exception &e) {
               error = e.what();
             }
 
             this->jsInvoker_->invokeAsync([=]() {
               if (error.size()) {
                 promise->reject(error);
                 return;
               }
             });
 
             this->jsInvoker_->invokeAsync(
                 [=]() { promise->resolve(jsi::Value::undefined()); });
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::getUserPublicKey(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string primaryKeysResult;
           std::string notificationsKeysResult;
           if (this->contentCryptoModule == nullptr ||
               !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
             error = "user has not been initialized";
           } else {
             primaryKeysResult = this->contentCryptoModule->getIdentityKeys();
             notificationsKeysResult =
                 NotificationsCryptoModule::getIdentityKeys();
           }
 
           std::string notificationsCurve25519Cpp, notificationsEd25519Cpp,
               blobPayloadCpp, signatureCpp, primaryCurve25519Cpp,
               primaryEd25519Cpp;
 
           if (!error.size()) {
             folly::dynamic parsedPrimary;
             try {
               parsedPrimary = folly::parseJson(primaryKeysResult);
             } catch (const folly::json::parse_error &e) {
               error =
                   "parsing identity keys failed with: " + std::string(e.what());
             }
             if (!error.size()) {
               primaryCurve25519Cpp = parsedPrimary["curve25519"].asString();
               primaryEd25519Cpp = parsedPrimary["ed25519"].asString();
 
               folly::dynamic parsedNotifications;
               try {
                 parsedNotifications = folly::parseJson(notificationsKeysResult);
               } catch (const folly::json::parse_error &e) {
                 error = "parsing notifications keys failed with: " +
                     std::string(e.what());
               }
               if (!error.size()) {
                 notificationsCurve25519Cpp =
                     parsedNotifications["curve25519"].asString();
                 notificationsEd25519Cpp =
                     parsedNotifications["ed25519"].asString();
 
                 folly::dynamic blobPayloadJSON = folly::dynamic::object(
                     "primaryIdentityPublicKeys",
                     folly::dynamic::object("ed25519", primaryEd25519Cpp)(
                         "curve25519", primaryCurve25519Cpp))(
                     "notificationIdentityPublicKeys",
                     folly::dynamic::object("ed25519", notificationsEd25519Cpp)(
                         "curve25519", notificationsCurve25519Cpp));
 
                 blobPayloadCpp = folly::toJson(blobPayloadJSON);
                 signatureCpp =
                     this->contentCryptoModule->signMessage(blobPayloadCpp);
               }
             }
           }
 
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
 
             auto primaryCurve25519{
                 jsi::String::createFromUtf8(innerRt, primaryCurve25519Cpp)};
             auto primaryEd25519{
                 jsi::String::createFromUtf8(innerRt, primaryEd25519Cpp)};
             auto jsiPrimaryIdentityPublicKeys = jsi::Object(innerRt);
             jsiPrimaryIdentityPublicKeys.setProperty(
                 innerRt, "ed25519", primaryEd25519);
             jsiPrimaryIdentityPublicKeys.setProperty(
                 innerRt, "curve25519", primaryCurve25519);
 
             auto notificationsCurve25519{jsi::String::createFromUtf8(
                 innerRt, notificationsCurve25519Cpp)};
             auto notificationsEd25519{
                 jsi::String::createFromUtf8(innerRt, notificationsEd25519Cpp)};
             auto jsiNotificationIdentityPublicKeys = jsi::Object(innerRt);
             jsiNotificationIdentityPublicKeys.setProperty(
                 innerRt, "ed25519", notificationsEd25519);
             jsiNotificationIdentityPublicKeys.setProperty(
                 innerRt, "curve25519", notificationsCurve25519);
 
             auto blobPayload{
                 jsi::String::createFromUtf8(innerRt, blobPayloadCpp)};
             auto signature{jsi::String::createFromUtf8(innerRt, signatureCpp)};
 
             auto jsiClientPublicKeys = jsi::Object(innerRt);
             jsiClientPublicKeys.setProperty(
                 innerRt,
                 "primaryIdentityPublicKeys",
                 jsiPrimaryIdentityPublicKeys);
             jsiClientPublicKeys.setProperty(
                 innerRt,
                 "notificationIdentityPublicKeys",
                 jsiNotificationIdentityPublicKeys);
             jsiClientPublicKeys.setProperty(
                 innerRt, "blobPayload", blobPayload);
             jsiClientPublicKeys.setProperty(innerRt, "signature", signature);
             promise->resolve(std::move(jsiClientPublicKeys));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Object parseOLMOneTimeKeys(jsi::Runtime &rt, std::string oneTimeKeysBlob) {
   folly::dynamic parsedOneTimeKeys = folly::parseJson(oneTimeKeysBlob);
 
   auto jsiOneTimeKeysInner = jsi::Object(rt);
 
   for (auto &kvPair : parsedOneTimeKeys["curve25519"].items()) {
     jsiOneTimeKeysInner.setProperty(
         rt,
         kvPair.first.asString().c_str(),
         jsi::String::createFromUtf8(rt, kvPair.second.asString()));
   }
 
   auto jsiOneTimeKeys = jsi::Object(rt);
   jsiOneTimeKeys.setProperty(rt, "curve25519", jsiOneTimeKeysInner);
 
   return jsiOneTimeKeys;
 }
 
 std::string parseOLMPrekey(std::string prekeyBlob) {
   folly::dynamic parsedPrekey;
   try {
     parsedPrekey = folly::parseJson(prekeyBlob);
   } catch (const folly::json::parse_error &e) {
     throw std::runtime_error(
         "parsing prekey failed with: " + std::string(e.what()));
   }
 
   folly::dynamic innerObject = parsedPrekey["curve25519"];
   if (!innerObject.isObject()) {
     throw std::runtime_error("parsing prekey failed: inner object malformed");
   }
 
   if (innerObject.values().begin() == innerObject.values().end()) {
     throw std::runtime_error("parsing prekey failed: prekey missing");
   }
 
   return parsedPrekey["curve25519"].values().begin()->asString();
 }
 
 jsi::Object parseOneTimeKeysResult(
     jsi::Runtime &rt,
     std::string contentOneTimeKeysBlob,
     std::string notifOneTimeKeysBlob) {
   auto contentOneTimeKeys = parseOLMOneTimeKeys(rt, contentOneTimeKeysBlob);
   auto notifOneTimeKeys = parseOLMOneTimeKeys(rt, notifOneTimeKeysBlob);
   auto jsiOneTimeKeysResult = jsi::Object(rt);
   jsiOneTimeKeysResult.setProperty(
       rt, "contentOneTimeKeys", contentOneTimeKeys);
   jsiOneTimeKeysResult.setProperty(
       rt, "notificationsOneTimeKeys", notifOneTimeKeys);
 
   return jsiOneTimeKeysResult;
 }
 
 jsi::Object parseEncryptedData(
     jsi::Runtime &rt,
     const crypto::EncryptedData &encryptedData) {
   auto encryptedDataJSI = jsi::Object(rt);
   auto message =
       std::string{encryptedData.message.begin(), encryptedData.message.end()};
   auto messageJSI = jsi::String::createFromUtf8(rt, message);
   encryptedDataJSI.setProperty(rt, "message", messageJSI);
   encryptedDataJSI.setProperty(
       rt, "messageType", static_cast<int>(encryptedData.messageType));
   if (encryptedData.sessionVersion.has_value()) {
     encryptedDataJSI.setProperty(
         rt,
         "sessionVersion",
         static_cast<int>(encryptedData.sessionVersion.value()));
   }
   return encryptedDataJSI;
 }
 
 jsi::Value
 CommCoreModule::getOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string contentResult;
           std::string notifResult;
           if (this->contentCryptoModule == nullptr ||
               !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
             this->jsInvoker_->invokeAsync([=, &innerRt]() {
               promise->reject("user has not been initialized");
             });
             return;
           }
           try {
             contentResult =
                 this->contentCryptoModule->getOneTimeKeysForPublishing(
                     oneTimeKeysAmount);
             std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>
                 notifsCryptoModuleWithPicklingKey =
                     NotificationsCryptoModule::fetchNotificationsAccount()
                         .value();
             notifResult = notifsCryptoModuleWithPicklingKey.first
                               ->getOneTimeKeysForPublishing(oneTimeKeysAmount);
             this->persistCryptoModules(true, notifsCryptoModuleWithPicklingKey);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(
                 parseOneTimeKeysResult(innerRt, contentResult, notifResult));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::validateAndUploadPrekeys(
     jsi::Runtime &rt,
     jsi::String authUserID,
     jsi::String authDeviceID,
     jsi::String authAccessToken) {
   auto authUserIDRust = jsiStringToRustString(authUserID, rt);
   auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
   auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::optional<std::string> maybeContentPrekeyToUpload;
           std::optional<std::string> maybeNotifsPrekeyToUpload;
 
           if (this->contentCryptoModule == nullptr ||
               !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
             this->jsInvoker_->invokeAsync([=, &innerRt]() {
               promise->reject("user has not been initialized");
             });
             return;
           }
 
           std::optional<
               std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
               notifsCryptoModuleWithPicklingKey;
           try {
             notifsCryptoModuleWithPicklingKey =
                 NotificationsCryptoModule::fetchNotificationsAccount();
             maybeContentPrekeyToUpload =
                 this->contentCryptoModule->validatePrekey();
             maybeNotifsPrekeyToUpload =
                 notifsCryptoModuleWithPicklingKey.value()
                     .first->validatePrekey();
             this->persistCryptoModules(true, notifsCryptoModuleWithPicklingKey);
 
             if (!maybeContentPrekeyToUpload.has_value()) {
               maybeContentPrekeyToUpload =
                   this->contentCryptoModule->getUnpublishedPrekey();
             }
             if (!maybeNotifsPrekeyToUpload.has_value()) {
               maybeNotifsPrekeyToUpload =
                   notifsCryptoModuleWithPicklingKey.value()
                       .first->getUnpublishedPrekey();
             }
           } catch (const std::exception &e) {
             error = e.what();
           }
 
           if (error.size()) {
             this->jsInvoker_->invokeAsync(
                 [=, &innerRt]() { promise->reject(error); });
             return;
           }
 
           if (!maybeContentPrekeyToUpload.has_value() &&
               !maybeNotifsPrekeyToUpload.has_value()) {
             this->jsInvoker_->invokeAsync(
                 [=]() { promise->resolve(jsi::Value::undefined()); });
             return;
           }
 
           std::string contentPrekeyToUpload;
           if (maybeContentPrekeyToUpload.has_value()) {
             contentPrekeyToUpload = maybeContentPrekeyToUpload.value();
           } else {
             contentPrekeyToUpload = this->contentCryptoModule->getPrekey();
           }
 
           std::string notifsPrekeyToUpload;
           if (maybeNotifsPrekeyToUpload.has_value()) {
             notifsPrekeyToUpload = maybeNotifsPrekeyToUpload.value();
           } else {
             notifsPrekeyToUpload =
                 notifsCryptoModuleWithPicklingKey.value().first->getPrekey();
           }
 
           std::string prekeyUploadError;
 
           try {
             std::string contentPrekeySignature =
                 this->contentCryptoModule->getPrekeySignature();
             std::string notifsPrekeySignature =
                 notifsCryptoModuleWithPicklingKey.value()
                     .first->getPrekeySignature();
 
             try {
               std::promise<folly::dynamic> prekeyPromise;
               std::future<folly::dynamic> prekeyFuture =
                   prekeyPromise.get_future();
               RustPromiseManager::CPPPromiseInfo promiseInfo = {
                   std::move(prekeyPromise)};
               auto currentID = RustPromiseManager::instance.addPromise(
                   std::move(promiseInfo));
               auto contentPrekeyToUploadRust =
                   rust::String(parseOLMPrekey(contentPrekeyToUpload));
               auto prekeySignatureRust = rust::string(contentPrekeySignature);
               auto notifsPrekeyToUploadRust =
                   rust::String(parseOLMPrekey(notifsPrekeyToUpload));
               auto notificationsPrekeySignatureRust =
                   rust::string(notifsPrekeySignature);
               ::identityRefreshUserPrekeys(
                   authUserIDRust,
                   authDeviceIDRust,
                   authAccessTokenRust,
                   contentPrekeyToUploadRust,
                   prekeySignatureRust,
                   notifsPrekeyToUploadRust,
                   notificationsPrekeySignatureRust,
                   currentID);
               prekeyFuture.get();
             } catch (const std::exception &e) {
               prekeyUploadError = e.what();
             }
 
             if (!prekeyUploadError.size()) {
               this->contentCryptoModule->markPrekeyAsPublished();
               notifsCryptoModuleWithPicklingKey.value()
                   .first->markPrekeyAsPublished();
               this->persistCryptoModules(
                   true, notifsCryptoModuleWithPicklingKey);
             }
           } catch (std::exception &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([=]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             if (prekeyUploadError.size()) {
               promise->reject(prekeyUploadError);
               return;
             }
             promise->resolve(jsi::Value::undefined());
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::validateAndGetPrekeys(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string contentPrekey, notifPrekey, contentPrekeySignature,
               notifPrekeySignature;
           std::optional<std::string> contentPrekeyBlob;
           std::optional<std::string> notifPrekeyBlob;
 
           if (this->contentCryptoModule == nullptr ||
               !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
             this->jsInvoker_->invokeAsync([=, &innerRt]() {
               promise->reject("user has not been initialized");
             });
             return;
           }
 
           std::optional<
               std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
               notifsCryptoModuleWithPicklingKey;
           try {
             notifsCryptoModuleWithPicklingKey =
                 NotificationsCryptoModule::fetchNotificationsAccount();
             contentPrekeyBlob = this->contentCryptoModule->validatePrekey();
             if (!contentPrekeyBlob) {
               contentPrekeyBlob =
                   this->contentCryptoModule->getUnpublishedPrekey();
             }
             if (!contentPrekeyBlob) {
               contentPrekeyBlob = this->contentCryptoModule->getPrekey();
             }
 
             notifPrekeyBlob = notifsCryptoModuleWithPicklingKey.value()
                                   .first->validatePrekey();
             if (!notifPrekeyBlob) {
               notifPrekeyBlob = notifsCryptoModuleWithPicklingKey.value()
                                     .first->getUnpublishedPrekey();
             }
             if (!notifPrekeyBlob) {
               notifPrekeyBlob =
                   notifsCryptoModuleWithPicklingKey.value().first->getPrekey();
             }
             this->persistCryptoModules(true, notifsCryptoModuleWithPicklingKey);
 
             contentPrekeySignature =
                 this->contentCryptoModule->getPrekeySignature();
             notifPrekeySignature = notifsCryptoModuleWithPicklingKey.value()
                                        .first->getPrekeySignature();
 
             contentPrekey = parseOLMPrekey(contentPrekeyBlob.value());
             notifPrekey = parseOLMPrekey(notifPrekeyBlob.value());
           } catch (const std::exception &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             auto contentPrekeyJSI =
                 jsi::String::createFromUtf8(innerRt, contentPrekey);
             auto contentPrekeySignatureJSI =
                 jsi::String::createFromUtf8(innerRt, contentPrekeySignature);
             auto notifPrekeyJSI =
                 jsi::String::createFromUtf8(innerRt, notifPrekey);
             auto notifPrekeySignatureJSI =
                 jsi::String::createFromUtf8(innerRt, notifPrekeySignature);
 
             auto signedPrekeysJSI = jsi::Object(innerRt);
             signedPrekeysJSI.setProperty(
                 innerRt, "contentPrekey", contentPrekeyJSI);
             signedPrekeysJSI.setProperty(
                 innerRt, "contentPrekeySignature", contentPrekeySignatureJSI);
             signedPrekeysJSI.setProperty(
                 innerRt, "notifPrekey", notifPrekeyJSI);
             signedPrekeysJSI.setProperty(
                 innerRt, "notifPrekeySignature", notifPrekeySignatureJSI);
 
             promise->resolve(std::move(signedPrekeysJSI));
           });
         };
 
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::initializeNotificationsSession(
     jsi::Runtime &rt,
     jsi::String identityKeys,
     jsi::String prekey,
     jsi::String prekeySignature,
     std::optional<jsi::String> oneTimeKey,
     jsi::String keyserverID) {
   auto identityKeysCpp{identityKeys.utf8(rt)};
   auto prekeyCpp{prekey.utf8(rt)};
   auto prekeySignatureCpp{prekeySignature.utf8(rt)};
   auto keyserverIDCpp{keyserverID.utf8(rt)};
 
   std::optional<std::string> oneTimeKeyCpp;
   if (oneTimeKey) {
     oneTimeKeyCpp = oneTimeKey->utf8(rt);
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           crypto::EncryptedData result;
           std::optional<
               std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
               notifsCryptoModuleWithPicklingKey;
           try {
             notifsCryptoModuleWithPicklingKey =
                 NotificationsCryptoModule::fetchNotificationsAccount();
             std::optional<crypto::OlmBuffer> oneTimeKeyBuffer;
             if (oneTimeKeyCpp) {
               oneTimeKeyBuffer = crypto::OlmBuffer(
                   oneTimeKeyCpp->begin(), oneTimeKeyCpp->end());
             }
 
             notifsCryptoModuleWithPicklingKey.value()
                 .first->initializeOutboundForSendingSession(
                     keyserverIDCpp,
                     std::vector<uint8_t>(
                         identityKeysCpp.begin(), identityKeysCpp.end()),
                     std::vector<uint8_t>(prekeyCpp.begin(), prekeyCpp.end()),
                     std::vector<uint8_t>(
                         prekeySignatureCpp.begin(), prekeySignatureCpp.end()),
                     oneTimeKeyBuffer);
 
             result = notifsCryptoModuleWithPicklingKey.value().first->encrypt(
                 keyserverIDCpp,
                 NotificationsCryptoModule::initialEncryptedMessageContent);
 
             std::shared_ptr<crypto::Session> keyserverNotificationsSession =
                 notifsCryptoModuleWithPicklingKey.value()
                     .first->getSessionByDeviceId(keyserverIDCpp);
 
             NotificationsCryptoModule::persistNotificationsSession(
                 keyserverIDCpp, keyserverNotificationsSession);
 
             // Session is removed from the account since it is persisted
             // at different location that the account after serialization
             notifsCryptoModuleWithPicklingKey.value()
                 .first->removeSessionByDeviceId(keyserverIDCpp);
             this->persistCryptoModules(
                 false, notifsCryptoModuleWithPicklingKey);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(jsi::String::createFromUtf8(
                 innerRt,
                 std::string{result.message.begin(), result.message.end()}));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::isNotificationsSessionInitialized(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           bool result;
           try {
             result =
                 NotificationsCryptoModule::isNotificationsSessionInitialized(
                     "Comm");
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(result);
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::isDeviceNotificationsSessionInitialized(
     jsi::Runtime &rt,
     jsi::String deviceID) {
   auto deviceIDCpp{deviceID.utf8(rt)};
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           if (this->contentCryptoModule == nullptr ||
               !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
             this->jsInvoker_->invokeAsync([=, &innerRt]() {
               promise->reject("user has not been initialized");
             });
             return;
           }
 
           std::string error;
           bool result;
           try {
             result = NotificationsCryptoModule::
                 isDeviceNotificationsSessionInitialized(deviceIDCpp);
           } catch (const std::exception &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(result);
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::isNotificationsSessionInitializedWithDevices(
     jsi::Runtime &rt,
     jsi::Array deviceIDs) {
   std::vector<std::string> deviceIDsCpp;
   for (auto idx = 0; idx < deviceIDs.size(rt); idx++) {
     std::string deviceIDCpp =
         deviceIDs.getValueAtIndex(rt, idx).asString(rt).utf8(rt);
     deviceIDsCpp.push_back(deviceIDCpp);
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           if (this->contentCryptoModule == nullptr ||
               !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
             this->jsInvoker_->invokeAsync([=, &innerRt]() {
               promise->reject("user has not been initialized");
             });
             return;
           }
 
           std::string error;
           std::vector<std::pair<std::string, bool>> result;
 
           try {
             result = NotificationsCryptoModule::
                 isNotificationsSessionInitializedWithDevices(deviceIDsCpp);
           } catch (const std::exception &e) {
             error = e.what();
           }
 
           auto resultPtr =
               std::make_shared<std::vector<std::pair<std::string, bool>>>(
                   std::move(result));
 
           this->jsInvoker_->invokeAsync(
               [&innerRt, resultPtr, error, promise]() {
                 if (error.size()) {
                   promise->reject(error);
                   return;
                 }
 
                 jsi::Object jsiResult = jsi::Object(innerRt);
                 for (const auto &deviceResult : *resultPtr) {
                   jsiResult.setProperty(
                       innerRt, deviceResult.first.c_str(), deviceResult.second);
                 }
                 promise->resolve(std::move(jsiResult));
               });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::updateKeyserverDataInNotifStorage(
     jsi::Runtime &rt,
     jsi::Array keyserversData) {
 
   std::vector<std::pair<std::string, int>> keyserversDataCpp;
   for (auto idx = 0; idx < keyserversData.size(rt); idx++) {
     auto data = keyserversData.getValueAtIndex(rt, idx).asObject(rt);
     std::string keyserverID = data.getProperty(rt, "id").asString(rt).utf8(rt);
     std::string keyserverUnreadCountKey =
         "KEYSERVER." + keyserverID + ".UNREAD_COUNT";
     int unreadCount = data.getProperty(rt, "unreadCount").asNumber();
     keyserversDataCpp.push_back({keyserverUnreadCountKey, unreadCount});
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           for (const auto &keyserverData : keyserversDataCpp) {
             CommMMKV::setInt(keyserverData.first, keyserverData.second);
           }
         } catch (const std::exception &e) {
           error = e.what();
         }
 
         this->jsInvoker_->invokeAsync([=, &innerRt]() {
           if (error.size()) {
             promise->reject(error);
             return;
           }
           promise->resolve(jsi::Value::undefined());
         });
       });
 }
 
 jsi::Value CommCoreModule::removeKeyserverDataFromNotifStorage(
     jsi::Runtime &rt,
     jsi::Array keyserverIDsToDelete) {
   std::vector<std::string> keyserverIDsToDeleteCpp{};
   for (auto idx = 0; idx < keyserverIDsToDelete.size(rt); idx++) {
     std::string keyserverID =
         keyserverIDsToDelete.getValueAtIndex(rt, idx).asString(rt).utf8(rt);
     std::string keyserverUnreadCountKey =
         "KEYSERVER." + keyserverID + ".UNREAD_COUNT";
     keyserverIDsToDeleteCpp.push_back(keyserverUnreadCountKey);
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           CommMMKV::removeKeys(keyserverIDsToDeleteCpp);
         } catch (const std::exception &e) {
           error = e.what();
         }
 
         this->jsInvoker_->invokeAsync([=, &innerRt]() {
           if (error.size()) {
             promise->reject(error);
             return;
           }
           promise->resolve(jsi::Value::undefined());
         });
       });
 }
 
 jsi::Value CommCoreModule::getKeyserverDataFromNotifStorage(
     jsi::Runtime &rt,
     jsi::Array keyserverIDs) {
   std::vector<std::string> keyserverIDsCpp{};
   for (auto idx = 0; idx < keyserverIDs.size(rt); idx++) {
     std::string keyserverID =
         keyserverIDs.getValueAtIndex(rt, idx).asString(rt).utf8(rt);
     keyserverIDsCpp.push_back(keyserverID);
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         std::vector<std::pair<std::string, int>> keyserversDataVector{};
 
         try {
           for (const auto &keyserverID : keyserverIDsCpp) {
             std::string keyserverUnreadCountKey =
                 "KEYSERVER." + keyserverID + ".UNREAD_COUNT";
             std::optional<int> unreadCount =
                 CommMMKV::getInt(keyserverUnreadCountKey, -1);
 
             if (!unreadCount.has_value()) {
               continue;
             }
 
             keyserversDataVector.push_back({keyserverID, unreadCount.value()});
           }
         } catch (const std::exception &e) {
           error = e.what();
         }
 
         auto keyserversDataVectorPtr =
             std::make_shared<std::vector<std::pair<std::string, int>>>(
                 std::move(keyserversDataVector));
 
         this->jsInvoker_->invokeAsync(
             [&innerRt, keyserversDataVectorPtr, error, promise]() {
               if (error.size()) {
                 promise->reject(error);
                 return;
               }
 
               size_t numKeyserversData = keyserversDataVectorPtr->size();
               jsi::Array jsiKeyserversData =
                   jsi::Array(innerRt, numKeyserversData);
               size_t writeIdx = 0;
 
               for (const auto &keyserverData : *keyserversDataVectorPtr) {
                 jsi::Object jsiKeyserverData = jsi::Object(innerRt);
                 jsiKeyserverData.setProperty(
                     innerRt, "id", keyserverData.first);
                 jsiKeyserverData.setProperty(
                     innerRt, "unreadCount", keyserverData.second);
                 jsiKeyserversData.setValueAtIndex(
                     innerRt, writeIdx++, jsiKeyserverData);
               }
 
               promise->resolve(std::move(jsiKeyserversData));
             });
       });
 }
 
 jsi::Value CommCoreModule::initializeContentOutboundSession(
     jsi::Runtime &rt,
     jsi::String identityKeys,
     jsi::String prekey,
     jsi::String prekeySignature,
     std::optional<jsi::String> oneTimeKey,
     jsi::String deviceID) {
   auto identityKeysCpp{identityKeys.utf8(rt)};
   auto prekeyCpp{prekey.utf8(rt)};
   auto prekeySignatureCpp{prekeySignature.utf8(rt)};
   auto deviceIDCpp{deviceID.utf8(rt)};
 
   std::optional<std::string> oneTimeKeyCpp;
   if (oneTimeKey) {
     oneTimeKeyCpp = oneTimeKey->utf8(rt);
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           crypto::EncryptedData initialEncryptedData;
           int sessionVersion;
           try {
             std::optional<crypto::OlmBuffer> oneTimeKeyBuffer;
             if (oneTimeKeyCpp) {
               oneTimeKeyBuffer = crypto::OlmBuffer(
                   oneTimeKeyCpp->begin(), oneTimeKeyCpp->end());
             }
             sessionVersion =
                 this->contentCryptoModule->initializeOutboundForSendingSession(
                     deviceIDCpp,
                     std::vector<uint8_t>(
                         identityKeysCpp.begin(), identityKeysCpp.end()),
                     std::vector<uint8_t>(prekeyCpp.begin(), prekeyCpp.end()),
                     std::vector<uint8_t>(
                         prekeySignatureCpp.begin(), prekeySignatureCpp.end()),
                     oneTimeKeyBuffer);
 
             const std::string initMessage = "{\"type\": \"init\"}";
             initialEncryptedData =
                 contentCryptoModule->encrypt(deviceIDCpp, initMessage);
 
             this->persistCryptoModules(true, std::nullopt);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             auto initialEncryptedDataJSI =
                 parseEncryptedData(innerRt, initialEncryptedData);
             auto outboundSessionCreationResultJSI = jsi::Object(innerRt);
             outboundSessionCreationResultJSI.setProperty(
                 innerRt, "encryptedData", initialEncryptedDataJSI);
             outboundSessionCreationResultJSI.setProperty(
                 innerRt, "sessionVersion", sessionVersion);
 
             promise->resolve(std::move(outboundSessionCreationResultJSI));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::initializeContentInboundSession(
     jsi::Runtime &rt,
     jsi::String identityKeys,
     jsi::Object encryptedDataJSI,
     jsi::String deviceID,
     double sessionVersion,
     bool overwrite) {
   auto identityKeysCpp{identityKeys.utf8(rt)};
   size_t messageType =
       std::lround(encryptedDataJSI.getProperty(rt, "messageType").asNumber());
   std::string encryptedMessageCpp =
       encryptedDataJSI.getProperty(rt, "message").asString(rt).utf8(rt);
   auto deviceIDCpp{deviceID.utf8(rt)};
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string decryptedMessage;
           try {
             this->contentCryptoModule->initializeInboundForReceivingSession(
                 deviceIDCpp,
                 std::vector<uint8_t>(
                     encryptedMessageCpp.begin(), encryptedMessageCpp.end()),
                 std::vector<uint8_t>(
                     identityKeysCpp.begin(), identityKeysCpp.end()),
                 static_cast<int>(sessionVersion),
                 overwrite);
             crypto::EncryptedData encryptedData{
                 std::vector<uint8_t>(
                     encryptedMessageCpp.begin(), encryptedMessageCpp.end()),
                 messageType};
             decryptedMessage =
                 this->contentCryptoModule->decrypt(deviceIDCpp, encryptedData);
             this->persistCryptoModules(true, std::nullopt);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(
                 jsi::String::createFromUtf8(innerRt, decryptedMessage));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::isContentSessionInitialized(
     jsi::Runtime &rt,
     jsi::String deviceID) {
   auto deviceIDCpp{deviceID.utf8(rt)};
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           bool result;
 
           if (this->contentCryptoModule == nullptr ||
               !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
             this->jsInvoker_->invokeAsync([=, &innerRt]() {
               promise->reject("user has not been initialized");
             });
             return;
           }
 
           try {
             result = this->contentCryptoModule->hasSessionFor(deviceIDCpp);
           } catch (const std::exception &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(result);
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::initializeNotificationsOutboundSession(
     jsi::Runtime &rt,
     jsi::String identityKeys,
     jsi::String prekey,
     jsi::String prekeySignature,
     std::optional<jsi::String> oneTimeKey,
     jsi::String deviceID) {
   auto identityKeysCpp{identityKeys.utf8(rt)};
   auto prekeyCpp{prekey.utf8(rt)};
   auto prekeySignatureCpp{prekeySignature.utf8(rt)};
   auto deviceIDCpp{deviceID.utf8(rt)};
 
   std::optional<std::string> oneTimeKeyCpp;
   if (oneTimeKey) {
     oneTimeKeyCpp = oneTimeKey->utf8(rt);
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           crypto::EncryptedData result;
           std::optional<
               std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
               notifsCryptoModuleWithPicklingKey;
           try {
             notifsCryptoModuleWithPicklingKey =
                 NotificationsCryptoModule::fetchNotificationsAccount();
             std::optional<crypto::OlmBuffer> oneTimeKeyBuffer;
             if (oneTimeKeyCpp) {
               oneTimeKeyBuffer = crypto::OlmBuffer(
                   oneTimeKeyCpp->begin(), oneTimeKeyCpp->end());
             }
             notifsCryptoModuleWithPicklingKey.value()
                 .first->initializeOutboundForSendingSession(
                     deviceIDCpp,
                     std::vector<uint8_t>(
                         identityKeysCpp.begin(), identityKeysCpp.end()),
                     std::vector<uint8_t>(prekeyCpp.begin(), prekeyCpp.end()),
                     std::vector<uint8_t>(
                         prekeySignatureCpp.begin(), prekeySignatureCpp.end()),
                     oneTimeKeyBuffer);
 
             result = notifsCryptoModuleWithPicklingKey.value().first->encrypt(
                 deviceIDCpp,
                 NotificationsCryptoModule::initialEncryptedMessageContent);
 
             std::shared_ptr<crypto::Session> peerNotificationsSession =
                 notifsCryptoModuleWithPicklingKey.value()
                     .first->getSessionByDeviceId(deviceIDCpp);
 
             NotificationsCryptoModule::persistDeviceNotificationsSession(
                 deviceIDCpp, peerNotificationsSession);
 
             // Session is removed from the account since it is persisted
             // at different location that the account after serialization
             notifsCryptoModuleWithPicklingKey.value()
                 .first->removeSessionByDeviceId(deviceIDCpp);
             this->persistCryptoModules(
                 false, notifsCryptoModuleWithPicklingKey);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             auto initialEncryptedDataJSI = parseEncryptedData(innerRt, result);
             promise->resolve(std::move(initialEncryptedDataJSI));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::encrypt(
     jsi::Runtime &rt,
     jsi::String message,
     jsi::String deviceID) {
   auto messageCpp{message.utf8(rt)};
   auto deviceIDCpp{deviceID.utf8(rt)};
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           crypto::EncryptedData encryptedMessage;
           try {
             encryptedMessage =
                 contentCryptoModule->encrypt(deviceIDCpp, messageCpp);
             this->persistCryptoModules(true, std::nullopt);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             auto encryptedDataJSI =
                 parseEncryptedData(innerRt, encryptedMessage);
             promise->resolve(std::move(encryptedDataJSI));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::encryptNotification(
     jsi::Runtime &rt,
     jsi::String payload,
     jsi::String deviceID) {
   auto payloadCpp{payload.utf8(rt)};
   auto deviceIDCpp{deviceID.utf8(rt)};
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           crypto::EncryptedData result;
           try {
             result =
                 NotificationsCryptoModule::encrypt(deviceIDCpp, payloadCpp);
           } catch (const std::exception &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             auto encryptedDataJSI = parseEncryptedData(innerRt, result);
             promise->resolve(std::move(encryptedDataJSI));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::encryptAndPersist(
     jsi::Runtime &rt,
     jsi::String message,
     jsi::String deviceID,
     jsi::String messageID) {
   auto messageCpp{message.utf8(rt)};
   auto deviceIDCpp{deviceID.utf8(rt)};
   auto messageIDCpp{messageID.utf8(rt)};
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           crypto::EncryptedData encryptedMessage;
           try {
             encryptedMessage =
                 contentCryptoModule->encrypt(deviceIDCpp, messageCpp);
 
             std::string storedSecretKey =
                 getAccountDataKey(secureStoreAccountDataKey);
             crypto::Persist newContentPersist =
                 this->contentCryptoModule->storeAsB64(storedSecretKey);
 
             std::promise<void> persistencePromise;
             std::future<void> persistenceFuture =
                 persistencePromise.get_future();
             GlobalDBSingleton::instance.scheduleOrRunCancellable(
                 [=, &persistencePromise]() {
                   try {
 
                     folly::dynamic jsonObject = folly::dynamic::object;
                     std::string messageStr(
                         encryptedMessage.message.begin(),
                         encryptedMessage.message.end());
                     jsonObject["message"] = messageStr;
                     jsonObject["messageType"] = encryptedMessage.messageType;
                     std::string ciphertext = folly::toJson(jsonObject);
 
                     DatabaseManager::getQueryExecutor().beginTransaction();
                     DatabaseManager::getQueryExecutor()
                         .setCiphertextForOutboundP2PMessage(
                             messageIDCpp, deviceIDCpp, ciphertext);
                     DatabaseManager::getQueryExecutor().storeOlmPersistData(
                         DatabaseManager::getQueryExecutor()
                             .getContentAccountID(),
                         newContentPersist);
                     DatabaseManager::getQueryExecutor().commitTransaction();
                     persistencePromise.set_value();
                   } catch (std::system_error &e) {
                     DatabaseManager::getQueryExecutor().rollbackTransaction();
                     persistencePromise.set_exception(
                         std::make_exception_ptr(e));
                   }
                 });
             persistenceFuture.get();
 
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             auto encryptedDataJSI =
                 parseEncryptedData(innerRt, encryptedMessage);
             promise->resolve(std::move(encryptedDataJSI));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::decrypt(
     jsi::Runtime &rt,
     jsi::Object encryptedDataJSI,
     jsi::String deviceID) {
   size_t messageType =
       std::lround(encryptedDataJSI.getProperty(rt, "messageType").asNumber());
   std::string message =
       encryptedDataJSI.getProperty(rt, "message").asString(rt).utf8(rt);
   auto deviceIDCpp{deviceID.utf8(rt)};
 
   std::optional<int> sessionVersion;
   if (encryptedDataJSI.hasProperty(rt, "sessionVersion")) {
     sessionVersion = std::lround(
         encryptedDataJSI.getProperty(rt, "sessionVersion").asNumber());
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string decryptedMessage;
           try {
             crypto::EncryptedData encryptedData{
                 std::vector<uint8_t>(message.begin(), message.end()),
                 messageType,
                 sessionVersion};
             decryptedMessage =
                 this->contentCryptoModule->decrypt(deviceIDCpp, encryptedData);
             this->persistCryptoModules(true, std::nullopt);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(
                 jsi::String::createFromUtf8(innerRt, decryptedMessage));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::decryptAndPersist(
     jsi::Runtime &rt,
     jsi::Object encryptedDataJSI,
     jsi::String deviceID,
     jsi::String userID,
     jsi::String messageID) {
   size_t messageType =
       std::lround(encryptedDataJSI.getProperty(rt, "messageType").asNumber());
   std::string message =
       encryptedDataJSI.getProperty(rt, "message").asString(rt).utf8(rt);
 
   std::optional<int> sessionVersion;
   if (encryptedDataJSI.hasProperty(rt, "sessionVersion")) {
     sessionVersion = std::lround(
         encryptedDataJSI.getProperty(rt, "sessionVersion").asNumber());
   }
 
   auto deviceIDCpp{deviceID.utf8(rt)};
   auto messageIDCpp{messageID.utf8(rt)};
   auto userIDCpp{userID.utf8(rt)};
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string decryptedMessage;
           try {
             crypto::EncryptedData encryptedData{
                 std::vector<uint8_t>(message.begin(), message.end()),
                 messageType,
                 sessionVersion};
             decryptedMessage =
                 this->contentCryptoModule->decrypt(deviceIDCpp, encryptedData);
 
             std::string storedSecretKey =
                 getAccountDataKey(secureStoreAccountDataKey);
             crypto::Persist newContentPersist =
                 this->contentCryptoModule->storeAsB64(storedSecretKey);
 
             std::promise<void> persistencePromise;
             std::future<void> persistenceFuture =
                 persistencePromise.get_future();
             GlobalDBSingleton::instance.scheduleOrRunCancellable(
                 [=, &persistencePromise]() {
                   try {
                     InboundP2PMessage message{
                         messageIDCpp,
                         deviceIDCpp,
                         decryptedMessage,
                         "decrypted",
                         userIDCpp};
 
                     DatabaseManager::getQueryExecutor().beginTransaction();
                     DatabaseManager::getQueryExecutor().addInboundP2PMessage(
                         message);
                     DatabaseManager::getQueryExecutor().storeOlmPersistData(
                         DatabaseManager::getQueryExecutor()
                             .getContentAccountID(),
                         newContentPersist);
                     DatabaseManager::getQueryExecutor().commitTransaction();
                     persistencePromise.set_value();
                   } catch (std::system_error &e) {
                     DatabaseManager::getQueryExecutor().rollbackTransaction();
                     persistencePromise.set_exception(
                         std::make_exception_ptr(e));
                   }
                 });
             persistenceFuture.get();
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(
                 jsi::String::createFromUtf8(innerRt, decryptedMessage));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::signMessage(jsi::Runtime &rt, jsi::String message) {
   std::string messageStr = message.utf8(rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string signature;
           try {
             signature = this->contentCryptoModule->signMessage(messageStr);
           } catch (const std::exception &e) {
             error = "signing message failed with: " + std::string(e.what());
           }
 
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
 
             auto jsiSignature{jsi::String::createFromUtf8(innerRt, signature)};
             promise->resolve(std::move(jsiSignature));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::verifySignature(
     jsi::Runtime &rt,
     jsi::String publicKey,
     jsi::String message,
     jsi::String signature) {
   std::string keyStr = publicKey.utf8(rt);
   std::string messageStr = message.utf8(rt);
   std::string signatureStr = signature.utf8(rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           try {
             crypto::CryptoModule::verifySignature(
                 keyStr, messageStr, signatureStr);
           } catch (const std::exception &e) {
             error = "verifying signature failed with: " + std::string(e.what());
           }
 
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(jsi::Value::undefined());
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 CommCoreModule::CommCoreModule(
     std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
     : facebook::react::CommCoreModuleSchemaCxxSpecJSI(jsInvoker),
       cryptoThread(std::make_unique<WorkerThread>("crypto")),
       draftStore(jsInvoker),
       threadStore(jsInvoker),
       messageStore(jsInvoker),
       reportStore(jsInvoker),
       userStore(jsInvoker),
       keyserverStore(jsInvoker),
       communityStore(jsInvoker),
       integrityStore(jsInvoker),
       syncedMetadataStore(jsInvoker),
       auxUserStore(jsInvoker),
       threadActivityStore(jsInvoker),
       entryStore(jsInvoker),
       messageSearchStore(jsInvoker) {
   GlobalDBSingleton::instance.enableMultithreading();
 }
 
 double CommCoreModule::getCodeVersion(jsi::Runtime &rt) {
   return this->codeVersion;
 }
 
 jsi::Value CommCoreModule::setNotifyToken(jsi::Runtime &rt, jsi::String token) {
   auto notifyToken{token.utf8(rt)};
   return createPromiseAsJSIValue(
       rt,
       [this,
        notifyToken](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [this, notifyToken, promise]() {
           std::string error;
           try {
             DatabaseManager::getQueryExecutor().setNotifyToken(notifyToken);
           } catch (std::system_error &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([error, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::clearNotifyToken(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [this, promise]() {
           std::string error;
           try {
             DatabaseManager::getQueryExecutor().clearNotifyToken();
           } catch (std::system_error &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([error, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 };
 
 jsi::Value
 CommCoreModule::stampSQLiteDBUserID(jsi::Runtime &rt, jsi::String userID) {
   auto currentUserID{userID.utf8(rt)};
   return createPromiseAsJSIValue(
       rt,
       [this,
        currentUserID](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [this, promise, currentUserID]() {
           std::string error;
           try {
             DatabaseManager::getQueryExecutor().stampSQLiteDBUserID(
                 currentUserID);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([error, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::getSQLiteStampedUserID(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [this, &innerRt, promise]() {
           std::string error;
           std::string result;
           try {
             result =
                 DatabaseManager::getQueryExecutor().getSQLiteStampedUserID();
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([&innerRt, error, result, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::String::createFromUtf8(innerRt, result));
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::clearSensitiveData(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         GlobalDBSingleton::instance.setTasksCancelled(true);
         taskType job = [this, promise]() {
           std::string error;
           try {
             this->innerClearCommServicesAuthMetadata();
             DatabaseManager::clearSensitiveData();
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([error, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
           GlobalDBSingleton::instance.scheduleOrRun(
               []() { GlobalDBSingleton::instance.setTasksCancelled(false); });
         };
         GlobalDBSingleton::instance.scheduleOrRun(job);
       });
 }
 
 bool CommCoreModule::checkIfDatabaseNeedsDeletion(jsi::Runtime &rt) {
   return DatabaseManager::checkIfDatabaseNeedsDeletion();
 }
 
 void CommCoreModule::reportDBOperationsFailure(jsi::Runtime &rt) {
   DatabaseManager::reportDBOperationsFailure();
 }
 
 jsi::Value CommCoreModule::computeBackupKey(
     jsi::Runtime &rt,
     jsi::String password,
     jsi::String backupID) {
   std::string passwordStr = password.utf8(rt);
   std::string backupIDStr = backupID.utf8(rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::array<::std::uint8_t, 32> backupKey;
           try {
             backupKey = compute_backup_key(passwordStr, backupIDStr);
           } catch (const std::exception &e) {
             error = std::string{"Failed to compute backup key: "} + e.what();
           }
 
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             auto size = backupKey.size();
             auto arrayBuffer =
                 innerRt.global()
                     .getPropertyAsFunction(innerRt, "ArrayBuffer")
                     .callAsConstructor(innerRt, {static_cast<double>(size)})
                     .asObject(innerRt)
                     .getArrayBuffer(innerRt);
             auto bufferPtr = arrayBuffer.data(innerRt);
             memcpy(bufferPtr, backupKey.data(), size);
             promise->resolve(std::move(arrayBuffer));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::generateRandomString(jsi::Runtime &rt, double size) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string randomString;
           try {
             randomString =
                 crypto::Tools::generateRandomString(static_cast<size_t>(size));
           } catch (const std::exception &e) {
             error = "Failed to generate random string for size " +
                 std::to_string(size) + ": " + e.what();
           }
 
           this->jsInvoker_->invokeAsync(
               [&innerRt, error, randomString, promise]() {
                 if (error.size()) {
                   promise->reject(error);
                 } else {
                   jsi::String jsiRandomString =
                       jsi::String::createFromUtf8(innerRt, randomString);
                   promise->resolve(std::move(jsiRandomString));
                 }
               });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::setCommServicesAuthMetadata(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken) {
   auto userIDStr{userID.utf8(rt)};
   auto deviceIDStr{deviceID.utf8(rt)};
   auto accessTokenStr{accessToken.utf8(rt)};
   return createPromiseAsJSIValue(
       rt,
       [this, userIDStr, deviceIDStr, accessTokenStr](
           jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           this->innerSetCommServicesAuthMetadata(
               userIDStr, deviceIDStr, accessTokenStr);
         } catch (const std::exception &e) {
           error = e.what();
         }
         this->jsInvoker_->invokeAsync([error, promise]() {
           if (error.size()) {
             promise->reject(error);
           } else {
             promise->resolve(jsi::Value::undefined());
           }
         });
       });
 }
 
 void CommCoreModule::innerSetCommServicesAuthMetadata(
     std::string userID,
     std::string deviceID,
     std::string accessToken) {
   CommSecureStore::set(CommSecureStore::userID, userID);
   CommSecureStore::set(CommSecureStore::deviceID, deviceID);
   CommSecureStore::set(CommSecureStore::commServicesAccessToken, accessToken);
   CommServicesAuthMetadataEmitter::sendAuthMetadataToJS(accessToken, userID);
 }
 
 jsi::Value CommCoreModule::getCommServicesAuthMetadata(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         std::string userID;
         std::string deviceID;
         std::string accessToken;
         try {
           folly::Optional<std::string> userIDOpt =
               CommSecureStore::get(CommSecureStore::userID);
           if (userIDOpt.hasValue()) {
             userID = userIDOpt.value();
           }
           folly::Optional<std::string> deviceIDOpt =
               CommSecureStore::get(CommSecureStore::deviceID);
           if (deviceIDOpt.hasValue()) {
             deviceID = deviceIDOpt.value();
           }
           folly::Optional<std::string> accessTokenOpt =
               CommSecureStore::get(CommSecureStore::commServicesAccessToken);
           if (accessTokenOpt.hasValue()) {
             accessToken = accessTokenOpt.value();
           }
         } catch (const std::exception &e) {
           error = e.what();
         }
         this->jsInvoker_->invokeAsync(
             [&innerRt, error, userID, deviceID, accessToken, promise]() {
               if (error.size()) {
                 promise->reject(error);
               } else {
                 auto authMetadata = jsi::Object(innerRt);
                 if (!userID.empty()) {
                   authMetadata.setProperty(
                       innerRt,
                       "userID",
                       jsi::String::createFromUtf8(innerRt, userID));
                 }
                 if (!deviceID.empty()) {
                   authMetadata.setProperty(
                       innerRt,
                       "deviceID",
                       jsi::String::createFromUtf8(innerRt, deviceID));
                 }
                 if (!accessToken.empty()) {
                   authMetadata.setProperty(
                       innerRt,
                       "accessToken",
                       jsi::String::createFromUtf8(innerRt, accessToken));
                 }
                 promise->resolve(std::move(authMetadata));
               }
             });
       });
 }
 
 jsi::Value CommCoreModule::clearCommServicesAuthMetadata(jsi::Runtime &rt) {
   return this->setCommServicesAuthMetadata(
       rt,
       jsi::String::createFromUtf8(rt, ""),
       jsi::String::createFromUtf8(rt, ""),
       jsi::String::createFromUtf8(rt, ""));
 }
 
 void CommCoreModule::innerClearCommServicesAuthMetadata() {
   return this->innerSetCommServicesAuthMetadata("", "", "");
 }
 
 jsi::Value CommCoreModule::setCommServicesAccessToken(
     jsi::Runtime &rt,
     jsi::String accessToken) {
   auto accessTokenStr{accessToken.utf8(rt)};
   return createPromiseAsJSIValue(
       rt,
       [this, accessTokenStr](
           jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           CommSecureStore::set(
               CommSecureStore::commServicesAccessToken, accessTokenStr);
         } catch (const std::exception &e) {
           error = e.what();
         }
         this->jsInvoker_->invokeAsync([error, promise]() {
           if (error.size()) {
             promise->reject(error);
           } else {
             promise->resolve(jsi::Value::undefined());
           }
         });
       });
 }
 
 jsi::Value CommCoreModule::clearCommServicesAccessToken(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           CommSecureStore::set(CommSecureStore::commServicesAccessToken, "");
         } catch (const std::exception &e) {
           error = e.what();
         }
         this->jsInvoker_->invokeAsync([error, promise]() {
           if (error.size()) {
             promise->reject(error);
           } else {
             promise->resolve(jsi::Value::undefined());
           }
         });
       });
 }
 
 void CommCoreModule::startBackupHandler(jsi::Runtime &rt) {
   try {
     ::startBackupHandler();
   } catch (const std::exception &e) {
     throw jsi::JSError(rt, e.what());
   }
 }
 
 void CommCoreModule::stopBackupHandler(jsi::Runtime &rt) {
   try {
     ::stopBackupHandler();
   } catch (const std::exception &e) {
     throw jsi::JSError(rt, e.what());
   }
 }
 
 jsi::Value CommCoreModule::createNewBackupInternal(
     jsi::Runtime &rt,
     std::string backupSecret,
     std::string backupMessage) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         this->cryptoThread->scheduleTask([=, &innerRt]() {
           std::string error;
 
           std::string backupID;
           try {
             backupID = crypto::Tools::generateRandomString(32);
           } catch (const std::exception &e) {
             error = "Failed to generate backupID";
           }
 
           std::string pickleKey;
           std::string pickledAccount;
           if (!error.size()) {
             try {
               pickleKey = crypto::Tools::generateRandomString(64);
               crypto::Persist persist =
                   this->contentCryptoModule->storeAsB64(pickleKey);
               pickledAccount =
                   std::string(persist.account.begin(), persist.account.end());
             } catch (const std::exception &e) {
               error = "Failed to pickle crypto account";
             }
           }
 
           if (!error.size()) {
             auto currentID = RustPromiseManager::instance.addPromise(
                 {promise, this->jsInvoker_, innerRt});
             ::createBackup(
                 rust::string(backupID),
                 rust::string(backupSecret),
                 rust::string(pickleKey),
                 rust::string(pickledAccount),
                 rust::string(backupMessage),
                 currentID);
           } else {
             this->jsInvoker_->invokeAsync(
                 [=, &innerRt]() { promise->reject(error); });
           }
         });
       });
 }
 
 jsi::Value
 CommCoreModule::createNewBackup(jsi::Runtime &rt, jsi::String backupSecret) {
   std::string backupSecretStr = backupSecret.utf8(rt);
   return createNewBackupInternal(rt, backupSecretStr, "");
 }
 
 jsi::Value CommCoreModule::createNewSIWEBackup(
     jsi::Runtime &rt,
     jsi::String backupSecret,
     jsi::String siweBackupMsg) {
   std::string backupSecretStr = backupSecret.utf8(rt);
   std::string siweBackupMsgStr = siweBackupMsg.utf8(rt);
   return createNewBackupInternal(rt, backupSecretStr, siweBackupMsgStr);
 }
 
 jsi::Value CommCoreModule::restoreBackupInternal(
     jsi::Runtime &rt,
     std::string backupSecret,
     std::string backupID,
     std::string maxVersion) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         auto currentID = RustPromiseManager::instance.addPromise(
             {promise, this->jsInvoker_, innerRt});
         ::restoreBackup(
             rust::string(backupSecret),
             rust::string(backupID),
             rust::string(maxVersion),
             currentID);
       });
 }
 
 jsi::Value CommCoreModule::restoreBackup(
     jsi::Runtime &rt,
     jsi::String backupSecret,
     jsi::String maxVersion) {
   std::string backupSecretStr = backupSecret.utf8(rt);
   std::string maxVersionStr = maxVersion.utf8(rt);
   return restoreBackupInternal(rt, backupSecretStr, "", maxVersionStr);
 }
 
 jsi::Value CommCoreModule::restoreSIWEBackup(
     jsi::Runtime &rt,
     jsi::String backupSecret,
     jsi::String backupID,
     jsi::String maxVersion) {
   std::string backupSecretStr = backupSecret.utf8(rt);
   std::string backupIDStr = backupID.utf8(rt);
   std::string maxVersionStr = maxVersion.utf8(rt);
   return restoreBackupInternal(rt, backupSecretStr, backupIDStr, maxVersionStr);
 }
 
 jsi::Value CommCoreModule::restoreBackupData(
     jsi::Runtime &rt,
     jsi::String backupID,
     jsi::String backupDataKey,
     jsi::String backupLogDataKey,
     jsi::String maxVersion) {
   std::string backupIDStr = backupID.utf8(rt);
   std::string backupDataKeyStr = backupDataKey.utf8(rt);
   std::string backupLogDataKeyStr = backupLogDataKey.utf8(rt);
   std::string maxVersionStr = maxVersion.utf8(rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         auto currentID = RustPromiseManager::instance.addPromise(
             {promise, this->jsInvoker_, innerRt});
         ::restoreBackupData(
             rust::string(backupIDStr),
             rust::string(backupDataKeyStr),
             rust::string(backupLogDataKeyStr),
             rust::string(maxVersionStr),
             currentID);
       });
 }
 
 jsi::Value
 CommCoreModule::retrieveBackupKeys(jsi::Runtime &rt, jsi::String backupSecret) {
   std::string backupSecretStr = backupSecret.utf8(rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         auto currentID = RustPromiseManager::instance.addPromise(
             {promise, this->jsInvoker_, innerRt});
         ::retrieveBackupKeys(rust::string(backupSecretStr), currentID);
       });
 }
 
 jsi::Value CommCoreModule::retrieveLatestSIWEBackupData(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         auto currentID = RustPromiseManager::instance.addPromise(
             {promise, this->jsInvoker_, innerRt});
         ::retrieveLatestSIWEBackupData(currentID);
       });
 }
 
 jsi::Value CommCoreModule::setSIWEBackupSecrets(
     jsi::Runtime &rt,
     jsi::Object siweBackupSecrets) {
   std::string message =
       siweBackupSecrets.getProperty(rt, "message").asString(rt).utf8(rt);
   std::string signature =
       siweBackupSecrets.getProperty(rt, "signature").asString(rt).utf8(rt);
   folly::dynamic backupSecretsJSON =
       folly::dynamic::object("message", message)("signature", signature);
   std::string backupSecrets = folly::toJson(backupSecretsJSON);
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [this, promise, backupSecrets]() {
           std::string error;
           try {
             DatabaseManager::getQueryExecutor().setMetadata(
                 "siweBackupSecrets", backupSecrets);
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([error, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::getSIWEBackupSecrets(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [this, &innerRt, promise]() {
           std::string error;
           std::string backupSecrets;
           try {
             backupSecrets = DatabaseManager::getQueryExecutor().getMetadata(
                 "siweBackupSecrets");
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync(
               [&innerRt, error, backupSecrets, promise]() {
                 if (error.size()) {
                   promise->reject(error);
                 } else if (!backupSecrets.size()) {
                   promise->resolve(jsi::Value::undefined());
                 } else {
                   folly::dynamic backupSecretsJSON =
                       folly::parseJson(backupSecrets);
                   std::string message = backupSecretsJSON["message"].asString();
                   std::string signature =
                       backupSecretsJSON["signature"].asString();
 
                   auto siweBackupSecrets = jsi::Object(innerRt);
                   siweBackupSecrets.setProperty(
                       innerRt,
                       "message",
                       jsi::String::createFromUtf8(innerRt, message));
                   siweBackupSecrets.setProperty(
                       innerRt,
                       "signature",
                       jsi::String::createFromUtf8(innerRt, signature));
                   promise->resolve(std::move(siweBackupSecrets));
                 }
               });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::getAllInboundP2PMessages(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::vector<InboundP2PMessage> messages;
 
           try {
             messages =
                 DatabaseManager::getQueryExecutor().getAllInboundP2PMessage();
 
           } catch (std::system_error &e) {
             error = e.what();
           }
           auto messagesPtr = std::make_shared<std::vector<InboundP2PMessage>>(
               std::move(messages));
 
           this->jsInvoker_->invokeAsync(
               [&innerRt, messagesPtr, error, promise]() {
                 if (error.size()) {
                   promise->reject(error);
                   return;
                 }
 
                 jsi::Array jsiMessages =
                     jsi::Array(innerRt, messagesPtr->size());
                 size_t writeIdx = 0;
                 for (const InboundP2PMessage &msg : *messagesPtr) {
                   jsi::Object jsiMsg = jsi::Object(innerRt);
                   jsiMsg.setProperty(innerRt, "messageID", msg.message_id);
                   jsiMsg.setProperty(
                       innerRt, "senderDeviceID", msg.sender_device_id);
                   jsiMsg.setProperty(innerRt, "plaintext", msg.plaintext);
                   jsiMsg.setProperty(innerRt, "status", msg.status);
                   jsiMsg.setProperty(
                       innerRt, "senderUserID", msg.sender_user_id);
                   jsiMessages.setValueAtIndex(innerRt, writeIdx++, jsiMsg);
                 }
 
                 promise->resolve(std::move(jsiMessages));
               });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value
 CommCoreModule::removeInboundP2PMessages(jsi::Runtime &rt, jsi::Array ids) {
   std::vector<std::string> msgIDsCPP{};
   for (auto idx = 0; idx < ids.size(rt); idx++) {
     std::string msgID = ids.getValueAtIndex(rt, idx).asString(rt).utf8(rt);
     msgIDsCPP.push_back(msgID);
   }
 
   return createPromiseAsJSIValue(
       rt,
       [this,
        msgIDsCPP](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [this, promise, msgIDsCPP]() {
           std::string error;
           try {
             DatabaseManager::getQueryExecutor().removeInboundP2PMessages(
                 msgIDsCPP);
           } catch (std::system_error &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([error, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value
 CommCoreModule::getOutboundP2PMessagesByID(jsi::Runtime &rt, jsi::Array ids) {
   std::vector<std::string> msgIDsCPP{};
   for (auto idx = 0; idx < ids.size(rt); idx++) {
     std::string msgID = ids.getValueAtIndex(rt, idx).asString(rt).utf8(rt);
     msgIDsCPP.push_back(msgID);
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::vector<OutboundP2PMessage> messages;
 
           try {
             messages =
                 DatabaseManager::getQueryExecutor().getOutboundP2PMessagesByID(
                     msgIDsCPP);
 
           } catch (std::system_error &e) {
             error = e.what();
           }
           auto messagesPtr = std::make_shared<std::vector<OutboundP2PMessage>>(
               std::move(messages));
 
           this->jsInvoker_->invokeAsync(
               [&innerRt, messagesPtr, error, promise]() {
                 if (error.size()) {
                   promise->reject(error);
                   return;
                 }
 
                 jsi::Array jsiMessages =
                     jsi::Array(innerRt, messagesPtr->size());
                 size_t writeIdx = 0;
                 for (const OutboundP2PMessage &msg : *messagesPtr) {
                   jsi::Object jsiMsg = jsi::Object(innerRt);
                   jsiMsg.setProperty(innerRt, "messageID", msg.message_id);
                   jsiMsg.setProperty(innerRt, "deviceID", msg.device_id);
                   jsiMsg.setProperty(innerRt, "userID", msg.user_id);
                   jsiMsg.setProperty(innerRt, "timestamp", msg.timestamp);
                   jsiMsg.setProperty(innerRt, "plaintext", msg.plaintext);
                   jsiMsg.setProperty(innerRt, "ciphertext", msg.ciphertext);
                   jsiMsg.setProperty(innerRt, "status", msg.status);
                   jsiMsg.setProperty(
                       innerRt, "supportsAutoRetry", msg.supports_auto_retry);
                   jsiMessages.setValueAtIndex(innerRt, writeIdx++, jsiMsg);
                 }
 
                 promise->resolve(std::move(jsiMessages));
               });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::getAllOutboundP2PMessages(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::vector<OutboundP2PMessage> messages;
 
           try {
             messages =
                 DatabaseManager::getQueryExecutor().getAllOutboundP2PMessages();
 
           } catch (std::system_error &e) {
             error = e.what();
           }
           auto messagesPtr = std::make_shared<std::vector<OutboundP2PMessage>>(
               std::move(messages));
 
           this->jsInvoker_->invokeAsync(
               [&innerRt, messagesPtr, error, promise]() {
                 if (error.size()) {
                   promise->reject(error);
                   return;
                 }
 
                 jsi::Array jsiMessages =
                     jsi::Array(innerRt, messagesPtr->size());
                 size_t writeIdx = 0;
                 for (const OutboundP2PMessage &msg : *messagesPtr) {
                   jsi::Object jsiMsg = jsi::Object(innerRt);
                   jsiMsg.setProperty(innerRt, "messageID", msg.message_id);
                   jsiMsg.setProperty(innerRt, "deviceID", msg.device_id);
                   jsiMsg.setProperty(innerRt, "userID", msg.user_id);
                   jsiMsg.setProperty(innerRt, "timestamp", msg.timestamp);
                   jsiMsg.setProperty(innerRt, "plaintext", msg.plaintext);
                   jsiMsg.setProperty(innerRt, "ciphertext", msg.ciphertext);
                   jsiMsg.setProperty(innerRt, "status", msg.status);
                   jsiMsg.setProperty(
                       innerRt, "supportsAutoRetry", msg.supports_auto_retry);
                   jsiMessages.setValueAtIndex(innerRt, writeIdx++, jsiMsg);
                 }
 
                 promise->resolve(std::move(jsiMessages));
               });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::markOutboundP2PMessageAsSent(
     jsi::Runtime &rt,
     jsi::String messageID,
     jsi::String deviceID) {
   auto messageIDCpp{messageID.utf8(rt)};
   auto deviceIDCpp{deviceID.utf8(rt)};
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=]() {
           std::string error;
           try {
             DatabaseManager::getQueryExecutor().markOutboundP2PMessageAsSent(
                 messageIDCpp, deviceIDCpp);
           } catch (std::system_error &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([error, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
-jsi::Value CommCoreModule::removeOutboundP2PMessagesOlderThan(
+jsi::Value CommCoreModule::removeOutboundP2PMessage(
     jsi::Runtime &rt,
     jsi::String messageID,
     jsi::String deviceID) {
   auto messageIDCpp{messageID.utf8(rt)};
   auto deviceIDCpp{deviceID.utf8(rt)};
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=]() {
           std::string error;
           try {
-            DatabaseManager::getQueryExecutor()
-                .removeOutboundP2PMessagesOlderThan(messageIDCpp, deviceIDCpp);
+            DatabaseManager::getQueryExecutor().removeOutboundP2PMessage(
+                messageIDCpp, deviceIDCpp);
           } catch (std::system_error &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([error, promise]() {
             if (error.size()) {
               promise->reject(error);
             } else {
               promise->resolve(jsi::Value::undefined());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::resetOutboundP2PMessagesForDevice(
     jsi::Runtime &rt,
     jsi::String deviceID) {
   std::string deviceIDCpp{deviceID.utf8(rt)};
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::vector<std::string> messageIDs;
 
           try {
             DatabaseManager::getQueryExecutor().beginTransaction();
             messageIDs = DatabaseManager::getQueryExecutor()
                              .resetOutboundP2PMessagesForDevice(deviceIDCpp);
             DatabaseManager::getQueryExecutor().commitTransaction();
           } catch (std::system_error &e) {
             error = e.what();
             DatabaseManager::getQueryExecutor().rollbackTransaction();
           }
 
           auto messageIDsPtr =
               std::make_shared<std::vector<std::string>>(std::move(messageIDs));
 
           this->jsInvoker_->invokeAsync(
               [&innerRt, messageIDsPtr, error, promise]() {
                 if (error.size()) {
                   promise->reject(error);
                   return;
                 }
 
                 jsi::Array jsiMessageIDs =
                     jsi::Array(innerRt, messageIDsPtr->size());
                 size_t writeIdx = 0;
                 for (const std::string &id : *messageIDsPtr) {
                   jsi::String jsiString =
                       jsi::String::createFromUtf8(innerRt, id);
                   jsiMessageIDs.setValueAtIndex(innerRt, writeIdx++, jsiString);
                 }
 
                 promise->resolve(std::move(jsiMessageIDs));
               });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::getSyncedDatabaseVersion(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::vector<SyncedMetadataEntry> syncedMetadataStoreVector;
           try {
             syncedMetadataStoreVector =
                 DatabaseManager::getQueryExecutor().getAllSyncedMetadata();
           } catch (std::system_error &e) {
             error = e.what();
           }
           std::string version;
           for (auto &entry : syncedMetadataStoreVector) {
             if (entry.name == "db_version") {
               version = entry.data;
             }
           }
 
           this->jsInvoker_->invokeAsync([&innerRt, error, promise, version]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             jsi::String jsiVersion =
                 jsi::String::createFromUtf8(innerRt, version);
             promise->resolve(std::move(jsiVersion));
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::markPrekeysAsPublished(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
 
           if (this->contentCryptoModule == nullptr ||
               !NotificationsCryptoModule::isNotificationsAccountInitialized()) {
             this->jsInvoker_->invokeAsync([=, &innerRt]() {
               promise->reject("user has not been initialized");
             });
             return;
           }
 
           std::optional<
               std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
               notifsCryptoModuleWithPicklingKey;
           try {
             notifsCryptoModuleWithPicklingKey =
                 NotificationsCryptoModule::fetchNotificationsAccount();
             this->contentCryptoModule->markPrekeyAsPublished();
             notifsCryptoModuleWithPicklingKey.value()
                 .first->markPrekeyAsPublished();
             this->persistCryptoModules(true, notifsCryptoModuleWithPicklingKey);
           } catch (std::exception &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([=]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(jsi::Value::undefined());
           });
         };
 
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value
 CommCoreModule::getRelatedMessages(jsi::Runtime &rt, jsi::String messageID) {
   std::string messageIDStr = messageID.utf8(rt);
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::shared_ptr<std::vector<MessageEntity>> messages;
           try {
             messages = std::make_shared<std::vector<MessageEntity>>(
                 DatabaseManager::getQueryExecutor().getRelatedMessages(
                     messageIDStr));
           } catch (std::system_error &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([&innerRt,
                                          error,
                                          promise,
                                          messages,
                                          messageStore = this->messageStore]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
 
             jsi::Array jsiMessages =
                 messageStore.parseDBDataStore(innerRt, messages);
             promise->resolve(std::move(jsiMessages));
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::searchMessages(
     jsi::Runtime &rt,
     jsi::String query,
     jsi::String threadID,
     std::optional<jsi::String> timestampCursor,
     std::optional<jsi::String> messageIDCursor) {
   std::string queryStr = query.utf8(rt);
   std::string threadIDStr = threadID.utf8(rt);
 
   std::optional<std::string> timestampCursorCpp;
   if (timestampCursor) {
     timestampCursorCpp = timestampCursor->utf8(rt);
   }
 
   std::optional<std::string> messageIDCursorCpp;
   if (messageIDCursor) {
     messageIDCursorCpp = messageIDCursor->utf8(rt);
   }
 
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::shared_ptr<std::vector<MessageEntity>> messages;
           try {
             messages = std::make_shared<std::vector<MessageEntity>>(
                 DatabaseManager::getQueryExecutor().searchMessages(
                     queryStr,
                     threadIDStr,
                     timestampCursorCpp,
                     messageIDCursorCpp));
           } catch (std::system_error &e) {
             error = e.what();
           }
 
           this->jsInvoker_->invokeAsync([&innerRt,
                                          error,
                                          promise,
                                          messages,
                                          messageStore = this->messageStore]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
 
             jsi::Array jsiMessages =
                 messageStore.parseDBDataStore(innerRt, messages);
             promise->resolve(std::move(jsiMessages));
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 };
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/CommCoreModule.h b/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
index 370e5344c..71cba813a 100644
--- a/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
+++ b/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
@@ -1,278 +1,278 @@
 #pragma once
 
 #include "../CryptoTools/CryptoModule.h"
 #include "../DatabaseManagers/entities/Message.h"
 #include "../Tools/CommMMKV.h"
 #include "../Tools/CommSecureStore.h"
 #include "../Tools/WorkerThread.h"
 #include "../_generated/commJSI.h"
 #include "PersistentStorageUtilities/DataStores/AuxUserStore.h"
 #include "PersistentStorageUtilities/DataStores/CommunityStore.h"
 #include "PersistentStorageUtilities/DataStores/DraftStore.h"
 #include "PersistentStorageUtilities/DataStores/EntryStore.h"
 #include "PersistentStorageUtilities/DataStores/IntegrityStore.h"
 #include "PersistentStorageUtilities/DataStores/KeyserverStore.h"
 #include "PersistentStorageUtilities/DataStores/MessageSearchStore.h"
 #include "PersistentStorageUtilities/DataStores/MessageStore.h"
 #include "PersistentStorageUtilities/DataStores/ReportStore.h"
 #include "PersistentStorageUtilities/DataStores/SyncedMetadataStore.h"
 #include "PersistentStorageUtilities/DataStores/ThreadActivityStore.h"
 #include "PersistentStorageUtilities/DataStores/ThreadStore.h"
 #include "PersistentStorageUtilities/DataStores/UserStore.h"
 #include <ReactCommon/TurboModuleUtils.h>
 #include <jsi/jsi.h>
 #include <memory>
 #include <string>
 
 namespace comm {
 
 namespace jsi = facebook::jsi;
 
 class CommCoreModule : public facebook::react::CommCoreModuleSchemaCxxSpecJSI {
   const int codeVersion{384};
   std::unique_ptr<WorkerThread> cryptoThread;
 
   const std::string secureStoreAccountDataKey = "cryptoAccountDataKey";
   const std::string publicCryptoAccountID = "publicCryptoAccountID";
   std::unique_ptr<crypto::CryptoModule> contentCryptoModule;
   const std::string notifsCryptoAccountID = "notifsCryptoAccountID";
 
   DraftStore draftStore;
   ThreadStore threadStore;
   MessageStore messageStore;
   ReportStore reportStore;
   UserStore userStore;
   KeyserverStore keyserverStore;
   CommunityStore communityStore;
   IntegrityStore integrityStore;
   SyncedMetadataStore syncedMetadataStore;
   AuxUserStore auxUserStore;
   ThreadActivityStore threadActivityStore;
   EntryStore entryStore;
   MessageSearchStore messageSearchStore;
 
   void persistCryptoModules(
       bool persistContentModule,
       std::optional<
           std::pair<std::shared_ptr<crypto::CryptoModule>, std::string>>
           maybeUpdatedNotifsCryptoModule);
   jsi::Value createNewBackupInternal(
       jsi::Runtime &rt,
       std::string backupSecret,
       std::string backupMessage);
   jsi::Value restoreBackupInternal(
       jsi::Runtime &rt,
       std::string backupSecret,
       std::string backupID,
       std::string maxVersion);
 
   virtual jsi::Value getDraft(jsi::Runtime &rt, jsi::String key) override;
   virtual jsi::Value
   updateDraft(jsi::Runtime &rt, jsi::String key, jsi::String text) override;
   virtual jsi::Value
   moveDraft(jsi::Runtime &rt, jsi::String oldKey, jsi::String newKey) override;
   virtual jsi::Value getClientDBStore(jsi::Runtime &rt) override;
   virtual jsi::Value removeAllDrafts(jsi::Runtime &rt) override;
   virtual jsi::Array getAllMessagesSync(jsi::Runtime &rt) override;
   virtual void processReportStoreOperationsSync(
       jsi::Runtime &rt,
       jsi::Array operations) override;
   virtual void processMessageStoreOperationsSync(
       jsi::Runtime &rt,
       jsi::Array operations) override;
   virtual jsi::Array getAllThreadsSync(jsi::Runtime &rt) override;
   virtual void processThreadStoreOperationsSync(
       jsi::Runtime &rt,
       jsi::Array operations) override;
   virtual jsi::Value
   processDBStoreOperations(jsi::Runtime &rt, jsi::Object operations) override;
   template <typename T>
   void appendDBStoreOps(
       jsi::Runtime &rt,
       jsi::Object &operations,
       const char *key,
       T &store,
       std::shared_ptr<std::vector<std::unique_ptr<DBOperationBase>>>
           &destination);
   virtual jsi::Value initializeCryptoAccount(jsi::Runtime &rt) override;
   virtual jsi::Value getUserPublicKey(jsi::Runtime &rt) override;
   virtual jsi::Value
   getOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) override;
   virtual jsi::Value validateAndUploadPrekeys(
       jsi::Runtime &rt,
       jsi::String authUserID,
       jsi::String authDeviceID,
       jsi::String authAccessToken) override;
   virtual jsi::Value validateAndGetPrekeys(jsi::Runtime &rt) override;
   virtual jsi::Value initializeNotificationsSession(
       jsi::Runtime &rt,
       jsi::String identityKeys,
       jsi::String prekey,
       jsi::String prekeySignature,
       std::optional<jsi::String> oneTimeKey,
       jsi::String keyserverID) override;
   virtual jsi::Value
   isNotificationsSessionInitialized(jsi::Runtime &rt) override;
   virtual jsi::Value isDeviceNotificationsSessionInitialized(
       jsi::Runtime &rt,
       jsi::String deviceID) override;
   virtual jsi::Value isNotificationsSessionInitializedWithDevices(
       jsi::Runtime &rt,
       jsi::Array deviceIDs) override;
   virtual jsi::Value updateKeyserverDataInNotifStorage(
       jsi::Runtime &rt,
       jsi::Array keyserversData) override;
   virtual jsi::Value removeKeyserverDataFromNotifStorage(
       jsi::Runtime &rt,
       jsi::Array keyserverIDsToDelete) override;
   virtual jsi::Value getKeyserverDataFromNotifStorage(
       jsi::Runtime &rt,
       jsi::Array keyserverIDs) override;
   virtual jsi::Value initializeContentOutboundSession(
       jsi::Runtime &rt,
       jsi::String identityKeys,
       jsi::String prekey,
       jsi::String prekeySignature,
       std::optional<jsi::String> oneTimeKey,
       jsi::String deviceID) override;
   virtual jsi::Value initializeContentInboundSession(
       jsi::Runtime &rt,
       jsi::String identityKeys,
       jsi::Object encryptedDataJSI,
       jsi::String deviceID,
       double sessionVersion,
       bool overwrite) override;
   virtual jsi::Value
   isContentSessionInitialized(jsi::Runtime &rt, jsi::String deviceID) override;
   virtual jsi::Value initializeNotificationsOutboundSession(
       jsi::Runtime &rt,
       jsi::String identityKeys,
       jsi::String prekey,
       jsi::String prekeySignature,
       std::optional<jsi::String> oneTimeKey,
       jsi::String deviceID) override;
   virtual jsi::Value
   encrypt(jsi::Runtime &rt, jsi::String message, jsi::String deviceID) override;
   virtual jsi::Value encryptNotification(
       jsi::Runtime &rt,
       jsi::String payload,
       jsi::String deviceID) override;
   virtual jsi::Value encryptAndPersist(
       jsi::Runtime &rt,
       jsi::String message,
       jsi::String deviceID,
       jsi::String messageID) override;
   virtual jsi::Value decrypt(
       jsi::Runtime &rt,
       jsi::Object encryptedDataJSI,
       jsi::String deviceID) override;
   virtual jsi::Value decryptAndPersist(
       jsi::Runtime &rt,
       jsi::Object encryptedDataJSI,
       jsi::String deviceID,
       jsi::String userID,
       jsi::String messageID) override;
   virtual jsi::Value
   signMessage(jsi::Runtime &rt, jsi::String message) override;
   virtual jsi::Value verifySignature(
       jsi::Runtime &rt,
       jsi::String publicKey,
       jsi::String message,
       jsi::String signature) override;
   virtual void terminate(jsi::Runtime &rt) override;
   virtual double getCodeVersion(jsi::Runtime &rt) override;
   virtual jsi::Value
   setNotifyToken(jsi::Runtime &rt, jsi::String token) override;
   virtual jsi::Value clearNotifyToken(jsi::Runtime &rt) override;
   virtual jsi::Value
   stampSQLiteDBUserID(jsi::Runtime &rt, jsi::String userID) override;
   virtual jsi::Value getSQLiteStampedUserID(jsi::Runtime &rt) override;
   virtual jsi::Value clearSensitiveData(jsi::Runtime &rt) override;
   virtual bool checkIfDatabaseNeedsDeletion(jsi::Runtime &rt) override;
   virtual void reportDBOperationsFailure(jsi::Runtime &rt) override;
   virtual jsi::Value computeBackupKey(
       jsi::Runtime &rt,
       jsi::String password,
       jsi::String backupID) override;
   virtual jsi::Value
   generateRandomString(jsi::Runtime &rt, double size) override;
   virtual jsi::Value setCommServicesAuthMetadata(
       jsi::Runtime &rt,
       jsi::String userID,
       jsi::String deviceID,
       jsi::String accessToken) override;
   virtual void innerSetCommServicesAuthMetadata(
       std::string userID,
       std::string deviceID,
       std::string accessToken);
   virtual jsi::Value getCommServicesAuthMetadata(jsi::Runtime &rt) override;
   virtual jsi::Value clearCommServicesAuthMetadata(jsi::Runtime &rt) override;
   virtual void innerClearCommServicesAuthMetadata();
   virtual jsi::Value setCommServicesAccessToken(
       jsi::Runtime &rt,
       jsi::String accessToken) override;
   virtual jsi::Value clearCommServicesAccessToken(jsi::Runtime &rt) override;
   virtual void startBackupHandler(jsi::Runtime &rt) override;
   virtual void stopBackupHandler(jsi::Runtime &rt) override;
   virtual jsi::Value
   createNewBackup(jsi::Runtime &rt, jsi::String backupSecret) override;
   virtual jsi::Value createNewSIWEBackup(
       jsi::Runtime &rt,
       jsi::String backupSecret,
       jsi::String siweBackupMsg) override;
   virtual jsi::Value restoreBackup(
       jsi::Runtime &rt,
       jsi::String backupSecret,
       jsi::String maxVersion) override;
   virtual jsi::Value restoreSIWEBackup(
       jsi::Runtime &rt,
       jsi::String backupSecret,
       jsi::String backupID,
       jsi::String maxVersion) override;
   virtual jsi::Value restoreBackupData(
       jsi::Runtime &rt,
       jsi::String backupID,
       jsi::String backupDataKey,
       jsi::String backupLogDataKey,
       jsi::String maxVersion) override;
   virtual jsi::Value
   retrieveBackupKeys(jsi::Runtime &rt, jsi::String backupSecret) override;
   virtual jsi::Value setSIWEBackupSecrets(
       jsi::Runtime &rt,
       jsi::Object siweBackupSecrets) override;
   virtual jsi::Value retrieveLatestSIWEBackupData(jsi::Runtime &rt) override;
   virtual jsi::Value getSIWEBackupSecrets(jsi::Runtime &rt) override;
   virtual jsi::Value getAllInboundP2PMessages(jsi::Runtime &rt) override;
   virtual jsi::Value
   removeInboundP2PMessages(jsi::Runtime &rt, jsi::Array ids) override;
   virtual jsi::Value
   getOutboundP2PMessagesByID(jsi::Runtime &rt, jsi::Array ids) override;
   virtual jsi::Value getAllOutboundP2PMessages(jsi::Runtime &rt) override;
   virtual jsi::Value markOutboundP2PMessageAsSent(
       jsi::Runtime &rt,
       jsi::String messageID,
       jsi::String deviceID) override;
-  virtual jsi::Value removeOutboundP2PMessagesOlderThan(
+  virtual jsi::Value removeOutboundP2PMessage(
       jsi::Runtime &rt,
       jsi::String messageID,
       jsi::String deviceID) override;
   virtual jsi::Value resetOutboundP2PMessagesForDevice(
       jsi::Runtime &rt,
       jsi::String deviceID) override;
 
   virtual jsi::Value getSyncedDatabaseVersion(jsi::Runtime &rt) override;
   virtual jsi::Value markPrekeysAsPublished(jsi::Runtime &rt) override;
   virtual jsi::Value
   getRelatedMessages(jsi::Runtime &rt, jsi::String messageID) override;
   virtual jsi::Value searchMessages(
       jsi::Runtime &rt,
       jsi::String query,
       jsi::String threadID,
       std::optional<jsi::String> timestampCursor,
       std::optional<jsi::String> messageIDCursor) override;
 
 public:
   CommCoreModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
 };
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/_generated/commJSI-generated.cpp b/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
index 66a5047af..a939b4efe 100644
--- a/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
+++ b/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
@@ -1,317 +1,317 @@
 /**
  * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
  *
  * Do not edit this file as changes may cause incorrect behavior and will be lost
  * once the code is regenerated.
  *
  * @generated by codegen project: GenerateModuleH.js
  */
 
 #include "commJSI.h"
 
 namespace facebook {
 namespace react {
 
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getDraft(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getDraft(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_updateDraft(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->updateDraft(rt, args[0].asString(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_moveDraft(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->moveDraft(rt, args[0].asString(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getClientDBStore(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getClientDBStore(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeAllDrafts(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->removeAllDrafts(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllMessagesSync(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getAllMessagesSync(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processMessageStoreOperationsSync(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processMessageStoreOperationsSync(rt, args[0].asObject(rt).asArray(rt));
   return jsi::Value::undefined();
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllThreadsSync(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getAllThreadsSync(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processReportStoreOperationsSync(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processReportStoreOperationsSync(rt, args[0].asObject(rt).asArray(rt));
   return jsi::Value::undefined();
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processThreadStoreOperationsSync(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processThreadStoreOperationsSync(rt, args[0].asObject(rt).asArray(rt));
   return jsi::Value::undefined();
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processDBStoreOperations(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processDBStoreOperations(rt, args[0].asObject(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeCryptoAccount(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->initializeCryptoAccount(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getUserPublicKey(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getUserPublicKey(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getOneTimeKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getOneTimeKeys(rt, args[0].asNumber());
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_validateAndGetPrekeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->validateAndGetPrekeys(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_validateAndUploadPrekeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->validateAndUploadPrekeys(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeNotificationsSession(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->initializeNotificationsSession(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].isNull() || args[3].isUndefined() ? std::nullopt : std::make_optional(args[3].asString(rt)), args[4].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isNotificationsSessionInitialized(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->isNotificationsSessionInitialized(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isDeviceNotificationsSessionInitialized(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->isDeviceNotificationsSessionInitialized(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isNotificationsSessionInitializedWithDevices(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->isNotificationsSessionInitializedWithDevices(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_updateKeyserverDataInNotifStorage(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->updateKeyserverDataInNotifStorage(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeKeyserverDataFromNotifStorage(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->removeKeyserverDataFromNotifStorage(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getKeyserverDataFromNotifStorage(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getKeyserverDataFromNotifStorage(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeContentOutboundSession(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->initializeContentOutboundSession(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].isNull() || args[3].isUndefined() ? std::nullopt : std::make_optional(args[3].asString(rt)), args[4].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeContentInboundSession(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->initializeContentInboundSession(rt, args[0].asString(rt), args[1].asObject(rt), args[2].asString(rt), args[3].asNumber(), args[4].asBool());
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isContentSessionInitialized(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->isContentSessionInitialized(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeNotificationsOutboundSession(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->initializeNotificationsOutboundSession(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].isNull() || args[3].isUndefined() ? std::nullopt : std::make_optional(args[3].asString(rt)), args[4].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_encrypt(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->encrypt(rt, args[0].asString(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_encryptNotification(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->encryptNotification(rt, args[0].asString(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_encryptAndPersist(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->encryptAndPersist(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_decrypt(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->decrypt(rt, args[0].asObject(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_decryptAndPersist(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->decryptAndPersist(rt, args[0].asObject(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_signMessage(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->signMessage(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_verifySignature(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->verifySignature(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getCodeVersion(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getCodeVersion(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_terminate(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->terminate(rt);
   return jsi::Value::undefined();
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setNotifyToken(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->setNotifyToken(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearNotifyToken(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->clearNotifyToken(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_stampSQLiteDBUserID(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->stampSQLiteDBUserID(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getSQLiteStampedUserID(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getSQLiteStampedUserID(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearSensitiveData(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->clearSensitiveData(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_checkIfDatabaseNeedsDeletion(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->checkIfDatabaseNeedsDeletion(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_reportDBOperationsFailure(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->reportDBOperationsFailure(rt);
   return jsi::Value::undefined();
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_computeBackupKey(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->computeBackupKey(rt, args[0].asString(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_generateRandomString(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->generateRandomString(rt, args[0].asNumber());
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setCommServicesAuthMetadata(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->setCommServicesAuthMetadata(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getCommServicesAuthMetadata(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getCommServicesAuthMetadata(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearCommServicesAuthMetadata(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->clearCommServicesAuthMetadata(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setCommServicesAccessToken(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->setCommServicesAccessToken(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearCommServicesAccessToken(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->clearCommServicesAccessToken(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_startBackupHandler(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->startBackupHandler(rt);
   return jsi::Value::undefined();
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_stopBackupHandler(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->stopBackupHandler(rt);
   return jsi::Value::undefined();
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_createNewBackup(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->createNewBackup(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_createNewSIWEBackup(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->createNewSIWEBackup(rt, args[0].asString(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_restoreBackup(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->restoreBackup(rt, args[0].asString(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_restoreSIWEBackup(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->restoreSIWEBackup(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_restoreBackupData(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->restoreBackupData(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_retrieveBackupKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->retrieveBackupKeys(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_retrieveLatestSIWEBackupData(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->retrieveLatestSIWEBackupData(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setSIWEBackupSecrets(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->setSIWEBackupSecrets(rt, args[0].asObject(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getSIWEBackupSecrets(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getSIWEBackupSecrets(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllInboundP2PMessages(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getAllInboundP2PMessages(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeInboundP2PMessages(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->removeInboundP2PMessages(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getOutboundP2PMessagesByID(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getOutboundP2PMessagesByID(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllOutboundP2PMessages(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getAllOutboundP2PMessages(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_markOutboundP2PMessageAsSent(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->markOutboundP2PMessageAsSent(rt, args[0].asString(rt), args[1].asString(rt));
 }
-static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeOutboundP2PMessagesOlderThan(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
-  return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->removeOutboundP2PMessagesOlderThan(rt, args[0].asString(rt), args[1].asString(rt));
+static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeOutboundP2PMessage(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->removeOutboundP2PMessage(rt, args[0].asString(rt), args[1].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_resetOutboundP2PMessagesForDevice(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->resetOutboundP2PMessagesForDevice(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getSyncedDatabaseVersion(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getSyncedDatabaseVersion(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_markPrekeysAsPublished(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->markPrekeysAsPublished(rt);
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getRelatedMessages(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getRelatedMessages(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_searchMessages(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->searchMessages(rt, args[0].asString(rt), args[1].asString(rt), args[2].isNull() || args[2].isUndefined() ? std::nullopt : std::make_optional(args[2].asString(rt)), args[3].isNull() || args[3].isUndefined() ? std::nullopt : std::make_optional(args[3].asString(rt)));
 }
 
 CommCoreModuleSchemaCxxSpecJSI::CommCoreModuleSchemaCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
   : TurboModule("CommTurboModule", jsInvoker) {
   methodMap_["getDraft"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getDraft};
   methodMap_["updateDraft"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_updateDraft};
   methodMap_["moveDraft"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_moveDraft};
   methodMap_["getClientDBStore"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getClientDBStore};
   methodMap_["removeAllDrafts"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeAllDrafts};
   methodMap_["getAllMessagesSync"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllMessagesSync};
   methodMap_["processMessageStoreOperationsSync"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processMessageStoreOperationsSync};
   methodMap_["getAllThreadsSync"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllThreadsSync};
   methodMap_["processReportStoreOperationsSync"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processReportStoreOperationsSync};
   methodMap_["processThreadStoreOperationsSync"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processThreadStoreOperationsSync};
   methodMap_["processDBStoreOperations"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processDBStoreOperations};
   methodMap_["initializeCryptoAccount"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeCryptoAccount};
   methodMap_["getUserPublicKey"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getUserPublicKey};
   methodMap_["getOneTimeKeys"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getOneTimeKeys};
   methodMap_["validateAndGetPrekeys"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_validateAndGetPrekeys};
   methodMap_["validateAndUploadPrekeys"] = MethodMetadata {3, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_validateAndUploadPrekeys};
   methodMap_["initializeNotificationsSession"] = MethodMetadata {5, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeNotificationsSession};
   methodMap_["isNotificationsSessionInitialized"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isNotificationsSessionInitialized};
   methodMap_["isDeviceNotificationsSessionInitialized"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isDeviceNotificationsSessionInitialized};
   methodMap_["isNotificationsSessionInitializedWithDevices"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isNotificationsSessionInitializedWithDevices};
   methodMap_["updateKeyserverDataInNotifStorage"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_updateKeyserverDataInNotifStorage};
   methodMap_["removeKeyserverDataFromNotifStorage"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeKeyserverDataFromNotifStorage};
   methodMap_["getKeyserverDataFromNotifStorage"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getKeyserverDataFromNotifStorage};
   methodMap_["initializeContentOutboundSession"] = MethodMetadata {5, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeContentOutboundSession};
   methodMap_["initializeContentInboundSession"] = MethodMetadata {5, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeContentInboundSession};
   methodMap_["isContentSessionInitialized"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isContentSessionInitialized};
   methodMap_["initializeNotificationsOutboundSession"] = MethodMetadata {5, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeNotificationsOutboundSession};
   methodMap_["encrypt"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_encrypt};
   methodMap_["encryptNotification"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_encryptNotification};
   methodMap_["encryptAndPersist"] = MethodMetadata {3, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_encryptAndPersist};
   methodMap_["decrypt"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_decrypt};
   methodMap_["decryptAndPersist"] = MethodMetadata {4, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_decryptAndPersist};
   methodMap_["signMessage"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_signMessage};
   methodMap_["verifySignature"] = MethodMetadata {3, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_verifySignature};
   methodMap_["getCodeVersion"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getCodeVersion};
   methodMap_["terminate"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_terminate};
   methodMap_["setNotifyToken"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setNotifyToken};
   methodMap_["clearNotifyToken"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearNotifyToken};
   methodMap_["stampSQLiteDBUserID"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_stampSQLiteDBUserID};
   methodMap_["getSQLiteStampedUserID"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getSQLiteStampedUserID};
   methodMap_["clearSensitiveData"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearSensitiveData};
   methodMap_["checkIfDatabaseNeedsDeletion"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_checkIfDatabaseNeedsDeletion};
   methodMap_["reportDBOperationsFailure"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_reportDBOperationsFailure};
   methodMap_["computeBackupKey"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_computeBackupKey};
   methodMap_["generateRandomString"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_generateRandomString};
   methodMap_["setCommServicesAuthMetadata"] = MethodMetadata {3, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setCommServicesAuthMetadata};
   methodMap_["getCommServicesAuthMetadata"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getCommServicesAuthMetadata};
   methodMap_["clearCommServicesAuthMetadata"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearCommServicesAuthMetadata};
   methodMap_["setCommServicesAccessToken"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setCommServicesAccessToken};
   methodMap_["clearCommServicesAccessToken"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearCommServicesAccessToken};
   methodMap_["startBackupHandler"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_startBackupHandler};
   methodMap_["stopBackupHandler"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_stopBackupHandler};
   methodMap_["createNewBackup"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_createNewBackup};
   methodMap_["createNewSIWEBackup"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_createNewSIWEBackup};
   methodMap_["restoreBackup"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_restoreBackup};
   methodMap_["restoreSIWEBackup"] = MethodMetadata {3, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_restoreSIWEBackup};
   methodMap_["restoreBackupData"] = MethodMetadata {4, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_restoreBackupData};
   methodMap_["retrieveBackupKeys"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_retrieveBackupKeys};
   methodMap_["retrieveLatestSIWEBackupData"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_retrieveLatestSIWEBackupData};
   methodMap_["setSIWEBackupSecrets"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setSIWEBackupSecrets};
   methodMap_["getSIWEBackupSecrets"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getSIWEBackupSecrets};
   methodMap_["getAllInboundP2PMessages"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllInboundP2PMessages};
   methodMap_["removeInboundP2PMessages"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeInboundP2PMessages};
   methodMap_["getOutboundP2PMessagesByID"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getOutboundP2PMessagesByID};
   methodMap_["getAllOutboundP2PMessages"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllOutboundP2PMessages};
   methodMap_["markOutboundP2PMessageAsSent"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_markOutboundP2PMessageAsSent};
-  methodMap_["removeOutboundP2PMessagesOlderThan"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeOutboundP2PMessagesOlderThan};
+  methodMap_["removeOutboundP2PMessage"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_removeOutboundP2PMessage};
   methodMap_["resetOutboundP2PMessagesForDevice"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_resetOutboundP2PMessagesForDevice};
   methodMap_["getSyncedDatabaseVersion"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getSyncedDatabaseVersion};
   methodMap_["markPrekeysAsPublished"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_markPrekeysAsPublished};
   methodMap_["getRelatedMessages"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getRelatedMessages};
   methodMap_["searchMessages"] = MethodMetadata {4, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_searchMessages};
 }
 
 
 } // namespace react
 } // namespace facebook
diff --git a/native/cpp/CommonCpp/_generated/commJSI.h b/native/cpp/CommonCpp/_generated/commJSI.h
index f12cb6f70..d8c6d9dcb 100644
--- a/native/cpp/CommonCpp/_generated/commJSI.h
+++ b/native/cpp/CommonCpp/_generated/commJSI.h
@@ -1,701 +1,701 @@
 /**
  * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
  *
  * Do not edit this file as changes may cause incorrect behavior and will be lost
  * once the code is regenerated.
  *
  * @generated by codegen project: GenerateModuleH.js
  */
 
 #pragma once
 
 #include <ReactCommon/TurboModule.h>
 #include <react/bridging/Bridging.h>
 
 namespace facebook {
 namespace react {
 
 class JSI_EXPORT CommCoreModuleSchemaCxxSpecJSI : public TurboModule {
 protected:
   CommCoreModuleSchemaCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
 
 public:
   virtual jsi::Value getDraft(jsi::Runtime &rt, jsi::String key) = 0;
   virtual jsi::Value updateDraft(jsi::Runtime &rt, jsi::String key, jsi::String text) = 0;
   virtual jsi::Value moveDraft(jsi::Runtime &rt, jsi::String oldKey, jsi::String newKey) = 0;
   virtual jsi::Value getClientDBStore(jsi::Runtime &rt) = 0;
   virtual jsi::Value removeAllDrafts(jsi::Runtime &rt) = 0;
   virtual jsi::Array getAllMessagesSync(jsi::Runtime &rt) = 0;
   virtual void processMessageStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual jsi::Array getAllThreadsSync(jsi::Runtime &rt) = 0;
   virtual void processReportStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual void processThreadStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual jsi::Value processDBStoreOperations(jsi::Runtime &rt, jsi::Object operations) = 0;
   virtual jsi::Value initializeCryptoAccount(jsi::Runtime &rt) = 0;
   virtual jsi::Value getUserPublicKey(jsi::Runtime &rt) = 0;
   virtual jsi::Value getOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) = 0;
   virtual jsi::Value validateAndGetPrekeys(jsi::Runtime &rt) = 0;
   virtual jsi::Value validateAndUploadPrekeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken) = 0;
   virtual jsi::Value initializeNotificationsSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, std::optional<jsi::String> oneTimeKey, jsi::String keyserverID) = 0;
   virtual jsi::Value isNotificationsSessionInitialized(jsi::Runtime &rt) = 0;
   virtual jsi::Value isDeviceNotificationsSessionInitialized(jsi::Runtime &rt, jsi::String deviceID) = 0;
   virtual jsi::Value isNotificationsSessionInitializedWithDevices(jsi::Runtime &rt, jsi::Array deviceIDs) = 0;
   virtual jsi::Value updateKeyserverDataInNotifStorage(jsi::Runtime &rt, jsi::Array keyserversData) = 0;
   virtual jsi::Value removeKeyserverDataFromNotifStorage(jsi::Runtime &rt, jsi::Array keyserverIDsToDelete) = 0;
   virtual jsi::Value getKeyserverDataFromNotifStorage(jsi::Runtime &rt, jsi::Array keyserverIDs) = 0;
   virtual jsi::Value initializeContentOutboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, std::optional<jsi::String> oneTimeKey, jsi::String deviceID) = 0;
   virtual jsi::Value initializeContentInboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::Object encryptedContent, jsi::String deviceID, double sessionVersion, bool overwrite) = 0;
   virtual jsi::Value isContentSessionInitialized(jsi::Runtime &rt, jsi::String deviceID) = 0;
   virtual jsi::Value initializeNotificationsOutboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, std::optional<jsi::String> oneTimeKey, jsi::String deviceID) = 0;
   virtual jsi::Value encrypt(jsi::Runtime &rt, jsi::String message, jsi::String deviceID) = 0;
   virtual jsi::Value encryptNotification(jsi::Runtime &rt, jsi::String payload, jsi::String deviceID) = 0;
   virtual jsi::Value encryptAndPersist(jsi::Runtime &rt, jsi::String message, jsi::String deviceID, jsi::String messageID) = 0;
   virtual jsi::Value decrypt(jsi::Runtime &rt, jsi::Object encryptedData, jsi::String deviceID) = 0;
   virtual jsi::Value decryptAndPersist(jsi::Runtime &rt, jsi::Object encryptedData, jsi::String deviceID, jsi::String userID, jsi::String messageID) = 0;
   virtual jsi::Value signMessage(jsi::Runtime &rt, jsi::String message) = 0;
   virtual jsi::Value verifySignature(jsi::Runtime &rt, jsi::String publicKey, jsi::String message, jsi::String signature) = 0;
   virtual double getCodeVersion(jsi::Runtime &rt) = 0;
   virtual void terminate(jsi::Runtime &rt) = 0;
   virtual jsi::Value setNotifyToken(jsi::Runtime &rt, jsi::String token) = 0;
   virtual jsi::Value clearNotifyToken(jsi::Runtime &rt) = 0;
   virtual jsi::Value stampSQLiteDBUserID(jsi::Runtime &rt, jsi::String userID) = 0;
   virtual jsi::Value getSQLiteStampedUserID(jsi::Runtime &rt) = 0;
   virtual jsi::Value clearSensitiveData(jsi::Runtime &rt) = 0;
   virtual bool checkIfDatabaseNeedsDeletion(jsi::Runtime &rt) = 0;
   virtual void reportDBOperationsFailure(jsi::Runtime &rt) = 0;
   virtual jsi::Value computeBackupKey(jsi::Runtime &rt, jsi::String password, jsi::String backupID) = 0;
   virtual jsi::Value generateRandomString(jsi::Runtime &rt, double size) = 0;
   virtual jsi::Value setCommServicesAuthMetadata(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
   virtual jsi::Value getCommServicesAuthMetadata(jsi::Runtime &rt) = 0;
   virtual jsi::Value clearCommServicesAuthMetadata(jsi::Runtime &rt) = 0;
   virtual jsi::Value setCommServicesAccessToken(jsi::Runtime &rt, jsi::String accessToken) = 0;
   virtual jsi::Value clearCommServicesAccessToken(jsi::Runtime &rt) = 0;
   virtual void startBackupHandler(jsi::Runtime &rt) = 0;
   virtual void stopBackupHandler(jsi::Runtime &rt) = 0;
   virtual jsi::Value createNewBackup(jsi::Runtime &rt, jsi::String backupSecret) = 0;
   virtual jsi::Value createNewSIWEBackup(jsi::Runtime &rt, jsi::String backupSecret, jsi::String siweBackupMsg) = 0;
   virtual jsi::Value restoreBackup(jsi::Runtime &rt, jsi::String backupSecret, jsi::String maxVersion) = 0;
   virtual jsi::Value restoreSIWEBackup(jsi::Runtime &rt, jsi::String backupSecret, jsi::String backupID, jsi::String maxVersion) = 0;
   virtual jsi::Value restoreBackupData(jsi::Runtime &rt, jsi::String backupID, jsi::String backupDataKey, jsi::String backupLogDataKey, jsi::String maxVersion) = 0;
   virtual jsi::Value retrieveBackupKeys(jsi::Runtime &rt, jsi::String backupSecret) = 0;
   virtual jsi::Value retrieveLatestSIWEBackupData(jsi::Runtime &rt) = 0;
   virtual jsi::Value setSIWEBackupSecrets(jsi::Runtime &rt, jsi::Object siweBackupSecrets) = 0;
   virtual jsi::Value getSIWEBackupSecrets(jsi::Runtime &rt) = 0;
   virtual jsi::Value getAllInboundP2PMessages(jsi::Runtime &rt) = 0;
   virtual jsi::Value removeInboundP2PMessages(jsi::Runtime &rt, jsi::Array ids) = 0;
   virtual jsi::Value getOutboundP2PMessagesByID(jsi::Runtime &rt, jsi::Array ids) = 0;
   virtual jsi::Value getAllOutboundP2PMessages(jsi::Runtime &rt) = 0;
   virtual jsi::Value markOutboundP2PMessageAsSent(jsi::Runtime &rt, jsi::String messageID, jsi::String deviceID) = 0;
-  virtual jsi::Value removeOutboundP2PMessagesOlderThan(jsi::Runtime &rt, jsi::String messageID, jsi::String deviceID) = 0;
+  virtual jsi::Value removeOutboundP2PMessage(jsi::Runtime &rt, jsi::String messageID, jsi::String deviceID) = 0;
   virtual jsi::Value resetOutboundP2PMessagesForDevice(jsi::Runtime &rt, jsi::String deviceID) = 0;
   virtual jsi::Value getSyncedDatabaseVersion(jsi::Runtime &rt) = 0;
   virtual jsi::Value markPrekeysAsPublished(jsi::Runtime &rt) = 0;
   virtual jsi::Value getRelatedMessages(jsi::Runtime &rt, jsi::String messageID) = 0;
   virtual jsi::Value searchMessages(jsi::Runtime &rt, jsi::String query, jsi::String threadID, std::optional<jsi::String> timestampCursor, std::optional<jsi::String> messageIDCursor) = 0;
 
 };
 
 template <typename T>
 class JSI_EXPORT CommCoreModuleSchemaCxxSpec : public TurboModule {
 public:
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
     return delegate_.get(rt, propName);
   }
 
 protected:
   CommCoreModuleSchemaCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule("CommTurboModule", jsInvoker),
       delegate_(static_cast<T*>(this), jsInvoker) {}
 
 private:
   class Delegate : public CommCoreModuleSchemaCxxSpecJSI {
   public:
     Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
       CommCoreModuleSchemaCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {}
 
     jsi::Value getDraft(jsi::Runtime &rt, jsi::String key) override {
       static_assert(
           bridging::getParameterCount(&T::getDraft) == 2,
           "Expected getDraft(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getDraft, jsInvoker_, instance_, std::move(key));
     }
     jsi::Value updateDraft(jsi::Runtime &rt, jsi::String key, jsi::String text) override {
       static_assert(
           bridging::getParameterCount(&T::updateDraft) == 3,
           "Expected updateDraft(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::updateDraft, jsInvoker_, instance_, std::move(key), std::move(text));
     }
     jsi::Value moveDraft(jsi::Runtime &rt, jsi::String oldKey, jsi::String newKey) override {
       static_assert(
           bridging::getParameterCount(&T::moveDraft) == 3,
           "Expected moveDraft(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::moveDraft, jsInvoker_, instance_, std::move(oldKey), std::move(newKey));
     }
     jsi::Value getClientDBStore(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getClientDBStore) == 1,
           "Expected getClientDBStore(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getClientDBStore, jsInvoker_, instance_);
     }
     jsi::Value removeAllDrafts(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::removeAllDrafts) == 1,
           "Expected removeAllDrafts(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::removeAllDrafts, jsInvoker_, instance_);
     }
     jsi::Array getAllMessagesSync(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getAllMessagesSync) == 1,
           "Expected getAllMessagesSync(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Array>(
           rt, &T::getAllMessagesSync, jsInvoker_, instance_);
     }
     void processMessageStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) override {
       static_assert(
           bridging::getParameterCount(&T::processMessageStoreOperationsSync) == 2,
           "Expected processMessageStoreOperationsSync(...) to have 2 parameters");
 
       return bridging::callFromJs<void>(
           rt, &T::processMessageStoreOperationsSync, jsInvoker_, instance_, std::move(operations));
     }
     jsi::Array getAllThreadsSync(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getAllThreadsSync) == 1,
           "Expected getAllThreadsSync(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Array>(
           rt, &T::getAllThreadsSync, jsInvoker_, instance_);
     }
     void processReportStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) override {
       static_assert(
           bridging::getParameterCount(&T::processReportStoreOperationsSync) == 2,
           "Expected processReportStoreOperationsSync(...) to have 2 parameters");
 
       return bridging::callFromJs<void>(
           rt, &T::processReportStoreOperationsSync, jsInvoker_, instance_, std::move(operations));
     }
     void processThreadStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) override {
       static_assert(
           bridging::getParameterCount(&T::processThreadStoreOperationsSync) == 2,
           "Expected processThreadStoreOperationsSync(...) to have 2 parameters");
 
       return bridging::callFromJs<void>(
           rt, &T::processThreadStoreOperationsSync, jsInvoker_, instance_, std::move(operations));
     }
     jsi::Value processDBStoreOperations(jsi::Runtime &rt, jsi::Object operations) override {
       static_assert(
           bridging::getParameterCount(&T::processDBStoreOperations) == 2,
           "Expected processDBStoreOperations(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::processDBStoreOperations, jsInvoker_, instance_, std::move(operations));
     }
     jsi::Value initializeCryptoAccount(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::initializeCryptoAccount) == 1,
           "Expected initializeCryptoAccount(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::initializeCryptoAccount, jsInvoker_, instance_);
     }
     jsi::Value getUserPublicKey(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getUserPublicKey) == 1,
           "Expected getUserPublicKey(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getUserPublicKey, jsInvoker_, instance_);
     }
     jsi::Value getOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) override {
       static_assert(
           bridging::getParameterCount(&T::getOneTimeKeys) == 2,
           "Expected getOneTimeKeys(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getOneTimeKeys, jsInvoker_, instance_, std::move(oneTimeKeysAmount));
     }
     jsi::Value validateAndGetPrekeys(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::validateAndGetPrekeys) == 1,
           "Expected validateAndGetPrekeys(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::validateAndGetPrekeys, jsInvoker_, instance_);
     }
     jsi::Value validateAndUploadPrekeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken) override {
       static_assert(
           bridging::getParameterCount(&T::validateAndUploadPrekeys) == 4,
           "Expected validateAndUploadPrekeys(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::validateAndUploadPrekeys, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken));
     }
     jsi::Value initializeNotificationsSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, std::optional<jsi::String> oneTimeKey, jsi::String keyserverID) override {
       static_assert(
           bridging::getParameterCount(&T::initializeNotificationsSession) == 6,
           "Expected initializeNotificationsSession(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::initializeNotificationsSession, jsInvoker_, instance_, std::move(identityKeys), std::move(prekey), std::move(prekeySignature), std::move(oneTimeKey), std::move(keyserverID));
     }
     jsi::Value isNotificationsSessionInitialized(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::isNotificationsSessionInitialized) == 1,
           "Expected isNotificationsSessionInitialized(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::isNotificationsSessionInitialized, jsInvoker_, instance_);
     }
     jsi::Value isDeviceNotificationsSessionInitialized(jsi::Runtime &rt, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::isDeviceNotificationsSessionInitialized) == 2,
           "Expected isDeviceNotificationsSessionInitialized(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::isDeviceNotificationsSessionInitialized, jsInvoker_, instance_, std::move(deviceID));
     }
     jsi::Value isNotificationsSessionInitializedWithDevices(jsi::Runtime &rt, jsi::Array deviceIDs) override {
       static_assert(
           bridging::getParameterCount(&T::isNotificationsSessionInitializedWithDevices) == 2,
           "Expected isNotificationsSessionInitializedWithDevices(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::isNotificationsSessionInitializedWithDevices, jsInvoker_, instance_, std::move(deviceIDs));
     }
     jsi::Value updateKeyserverDataInNotifStorage(jsi::Runtime &rt, jsi::Array keyserversData) override {
       static_assert(
           bridging::getParameterCount(&T::updateKeyserverDataInNotifStorage) == 2,
           "Expected updateKeyserverDataInNotifStorage(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::updateKeyserverDataInNotifStorage, jsInvoker_, instance_, std::move(keyserversData));
     }
     jsi::Value removeKeyserverDataFromNotifStorage(jsi::Runtime &rt, jsi::Array keyserverIDsToDelete) override {
       static_assert(
           bridging::getParameterCount(&T::removeKeyserverDataFromNotifStorage) == 2,
           "Expected removeKeyserverDataFromNotifStorage(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::removeKeyserverDataFromNotifStorage, jsInvoker_, instance_, std::move(keyserverIDsToDelete));
     }
     jsi::Value getKeyserverDataFromNotifStorage(jsi::Runtime &rt, jsi::Array keyserverIDs) override {
       static_assert(
           bridging::getParameterCount(&T::getKeyserverDataFromNotifStorage) == 2,
           "Expected getKeyserverDataFromNotifStorage(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getKeyserverDataFromNotifStorage, jsInvoker_, instance_, std::move(keyserverIDs));
     }
     jsi::Value initializeContentOutboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, std::optional<jsi::String> oneTimeKey, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::initializeContentOutboundSession) == 6,
           "Expected initializeContentOutboundSession(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::initializeContentOutboundSession, jsInvoker_, instance_, std::move(identityKeys), std::move(prekey), std::move(prekeySignature), std::move(oneTimeKey), std::move(deviceID));
     }
     jsi::Value initializeContentInboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::Object encryptedContent, jsi::String deviceID, double sessionVersion, bool overwrite) override {
       static_assert(
           bridging::getParameterCount(&T::initializeContentInboundSession) == 6,
           "Expected initializeContentInboundSession(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::initializeContentInboundSession, jsInvoker_, instance_, std::move(identityKeys), std::move(encryptedContent), std::move(deviceID), std::move(sessionVersion), std::move(overwrite));
     }
     jsi::Value isContentSessionInitialized(jsi::Runtime &rt, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::isContentSessionInitialized) == 2,
           "Expected isContentSessionInitialized(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::isContentSessionInitialized, jsInvoker_, instance_, std::move(deviceID));
     }
     jsi::Value initializeNotificationsOutboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, std::optional<jsi::String> oneTimeKey, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::initializeNotificationsOutboundSession) == 6,
           "Expected initializeNotificationsOutboundSession(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::initializeNotificationsOutboundSession, jsInvoker_, instance_, std::move(identityKeys), std::move(prekey), std::move(prekeySignature), std::move(oneTimeKey), std::move(deviceID));
     }
     jsi::Value encrypt(jsi::Runtime &rt, jsi::String message, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::encrypt) == 3,
           "Expected encrypt(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::encrypt, jsInvoker_, instance_, std::move(message), std::move(deviceID));
     }
     jsi::Value encryptNotification(jsi::Runtime &rt, jsi::String payload, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::encryptNotification) == 3,
           "Expected encryptNotification(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::encryptNotification, jsInvoker_, instance_, std::move(payload), std::move(deviceID));
     }
     jsi::Value encryptAndPersist(jsi::Runtime &rt, jsi::String message, jsi::String deviceID, jsi::String messageID) override {
       static_assert(
           bridging::getParameterCount(&T::encryptAndPersist) == 4,
           "Expected encryptAndPersist(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::encryptAndPersist, jsInvoker_, instance_, std::move(message), std::move(deviceID), std::move(messageID));
     }
     jsi::Value decrypt(jsi::Runtime &rt, jsi::Object encryptedData, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::decrypt) == 3,
           "Expected decrypt(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::decrypt, jsInvoker_, instance_, std::move(encryptedData), std::move(deviceID));
     }
     jsi::Value decryptAndPersist(jsi::Runtime &rt, jsi::Object encryptedData, jsi::String deviceID, jsi::String userID, jsi::String messageID) override {
       static_assert(
           bridging::getParameterCount(&T::decryptAndPersist) == 5,
           "Expected decryptAndPersist(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::decryptAndPersist, jsInvoker_, instance_, std::move(encryptedData), std::move(deviceID), std::move(userID), std::move(messageID));
     }
     jsi::Value signMessage(jsi::Runtime &rt, jsi::String message) override {
       static_assert(
           bridging::getParameterCount(&T::signMessage) == 2,
           "Expected signMessage(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::signMessage, jsInvoker_, instance_, std::move(message));
     }
     jsi::Value verifySignature(jsi::Runtime &rt, jsi::String publicKey, jsi::String message, jsi::String signature) override {
       static_assert(
           bridging::getParameterCount(&T::verifySignature) == 4,
           "Expected verifySignature(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::verifySignature, jsInvoker_, instance_, std::move(publicKey), std::move(message), std::move(signature));
     }
     double getCodeVersion(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getCodeVersion) == 1,
           "Expected getCodeVersion(...) to have 1 parameters");
 
       return bridging::callFromJs<double>(
           rt, &T::getCodeVersion, jsInvoker_, instance_);
     }
     void terminate(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::terminate) == 1,
           "Expected terminate(...) to have 1 parameters");
 
       return bridging::callFromJs<void>(
           rt, &T::terminate, jsInvoker_, instance_);
     }
     jsi::Value setNotifyToken(jsi::Runtime &rt, jsi::String token) override {
       static_assert(
           bridging::getParameterCount(&T::setNotifyToken) == 2,
           "Expected setNotifyToken(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::setNotifyToken, jsInvoker_, instance_, std::move(token));
     }
     jsi::Value clearNotifyToken(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::clearNotifyToken) == 1,
           "Expected clearNotifyToken(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::clearNotifyToken, jsInvoker_, instance_);
     }
     jsi::Value stampSQLiteDBUserID(jsi::Runtime &rt, jsi::String userID) override {
       static_assert(
           bridging::getParameterCount(&T::stampSQLiteDBUserID) == 2,
           "Expected stampSQLiteDBUserID(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::stampSQLiteDBUserID, jsInvoker_, instance_, std::move(userID));
     }
     jsi::Value getSQLiteStampedUserID(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getSQLiteStampedUserID) == 1,
           "Expected getSQLiteStampedUserID(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getSQLiteStampedUserID, jsInvoker_, instance_);
     }
     jsi::Value clearSensitiveData(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::clearSensitiveData) == 1,
           "Expected clearSensitiveData(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::clearSensitiveData, jsInvoker_, instance_);
     }
     bool checkIfDatabaseNeedsDeletion(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::checkIfDatabaseNeedsDeletion) == 1,
           "Expected checkIfDatabaseNeedsDeletion(...) to have 1 parameters");
 
       return bridging::callFromJs<bool>(
           rt, &T::checkIfDatabaseNeedsDeletion, jsInvoker_, instance_);
     }
     void reportDBOperationsFailure(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::reportDBOperationsFailure) == 1,
           "Expected reportDBOperationsFailure(...) to have 1 parameters");
 
       return bridging::callFromJs<void>(
           rt, &T::reportDBOperationsFailure, jsInvoker_, instance_);
     }
     jsi::Value computeBackupKey(jsi::Runtime &rt, jsi::String password, jsi::String backupID) override {
       static_assert(
           bridging::getParameterCount(&T::computeBackupKey) == 3,
           "Expected computeBackupKey(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::computeBackupKey, jsInvoker_, instance_, std::move(password), std::move(backupID));
     }
     jsi::Value generateRandomString(jsi::Runtime &rt, double size) override {
       static_assert(
           bridging::getParameterCount(&T::generateRandomString) == 2,
           "Expected generateRandomString(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::generateRandomString, jsInvoker_, instance_, std::move(size));
     }
     jsi::Value setCommServicesAuthMetadata(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
       static_assert(
           bridging::getParameterCount(&T::setCommServicesAuthMetadata) == 4,
           "Expected setCommServicesAuthMetadata(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::setCommServicesAuthMetadata, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
     }
     jsi::Value getCommServicesAuthMetadata(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getCommServicesAuthMetadata) == 1,
           "Expected getCommServicesAuthMetadata(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getCommServicesAuthMetadata, jsInvoker_, instance_);
     }
     jsi::Value clearCommServicesAuthMetadata(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::clearCommServicesAuthMetadata) == 1,
           "Expected clearCommServicesAuthMetadata(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::clearCommServicesAuthMetadata, jsInvoker_, instance_);
     }
     jsi::Value setCommServicesAccessToken(jsi::Runtime &rt, jsi::String accessToken) override {
       static_assert(
           bridging::getParameterCount(&T::setCommServicesAccessToken) == 2,
           "Expected setCommServicesAccessToken(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::setCommServicesAccessToken, jsInvoker_, instance_, std::move(accessToken));
     }
     jsi::Value clearCommServicesAccessToken(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::clearCommServicesAccessToken) == 1,
           "Expected clearCommServicesAccessToken(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::clearCommServicesAccessToken, jsInvoker_, instance_);
     }
     void startBackupHandler(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::startBackupHandler) == 1,
           "Expected startBackupHandler(...) to have 1 parameters");
 
       return bridging::callFromJs<void>(
           rt, &T::startBackupHandler, jsInvoker_, instance_);
     }
     void stopBackupHandler(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::stopBackupHandler) == 1,
           "Expected stopBackupHandler(...) to have 1 parameters");
 
       return bridging::callFromJs<void>(
           rt, &T::stopBackupHandler, jsInvoker_, instance_);
     }
     jsi::Value createNewBackup(jsi::Runtime &rt, jsi::String backupSecret) override {
       static_assert(
           bridging::getParameterCount(&T::createNewBackup) == 2,
           "Expected createNewBackup(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::createNewBackup, jsInvoker_, instance_, std::move(backupSecret));
     }
     jsi::Value createNewSIWEBackup(jsi::Runtime &rt, jsi::String backupSecret, jsi::String siweBackupMsg) override {
       static_assert(
           bridging::getParameterCount(&T::createNewSIWEBackup) == 3,
           "Expected createNewSIWEBackup(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::createNewSIWEBackup, jsInvoker_, instance_, std::move(backupSecret), std::move(siweBackupMsg));
     }
     jsi::Value restoreBackup(jsi::Runtime &rt, jsi::String backupSecret, jsi::String maxVersion) override {
       static_assert(
           bridging::getParameterCount(&T::restoreBackup) == 3,
           "Expected restoreBackup(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::restoreBackup, jsInvoker_, instance_, std::move(backupSecret), std::move(maxVersion));
     }
     jsi::Value restoreSIWEBackup(jsi::Runtime &rt, jsi::String backupSecret, jsi::String backupID, jsi::String maxVersion) override {
       static_assert(
           bridging::getParameterCount(&T::restoreSIWEBackup) == 4,
           "Expected restoreSIWEBackup(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::restoreSIWEBackup, jsInvoker_, instance_, std::move(backupSecret), std::move(backupID), std::move(maxVersion));
     }
     jsi::Value restoreBackupData(jsi::Runtime &rt, jsi::String backupID, jsi::String backupDataKey, jsi::String backupLogDataKey, jsi::String maxVersion) override {
       static_assert(
           bridging::getParameterCount(&T::restoreBackupData) == 5,
           "Expected restoreBackupData(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::restoreBackupData, jsInvoker_, instance_, std::move(backupID), std::move(backupDataKey), std::move(backupLogDataKey), std::move(maxVersion));
     }
     jsi::Value retrieveBackupKeys(jsi::Runtime &rt, jsi::String backupSecret) override {
       static_assert(
           bridging::getParameterCount(&T::retrieveBackupKeys) == 2,
           "Expected retrieveBackupKeys(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::retrieveBackupKeys, jsInvoker_, instance_, std::move(backupSecret));
     }
     jsi::Value retrieveLatestSIWEBackupData(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::retrieveLatestSIWEBackupData) == 1,
           "Expected retrieveLatestSIWEBackupData(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::retrieveLatestSIWEBackupData, jsInvoker_, instance_);
     }
     jsi::Value setSIWEBackupSecrets(jsi::Runtime &rt, jsi::Object siweBackupSecrets) override {
       static_assert(
           bridging::getParameterCount(&T::setSIWEBackupSecrets) == 2,
           "Expected setSIWEBackupSecrets(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::setSIWEBackupSecrets, jsInvoker_, instance_, std::move(siweBackupSecrets));
     }
     jsi::Value getSIWEBackupSecrets(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getSIWEBackupSecrets) == 1,
           "Expected getSIWEBackupSecrets(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getSIWEBackupSecrets, jsInvoker_, instance_);
     }
     jsi::Value getAllInboundP2PMessages(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getAllInboundP2PMessages) == 1,
           "Expected getAllInboundP2PMessages(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getAllInboundP2PMessages, jsInvoker_, instance_);
     }
     jsi::Value removeInboundP2PMessages(jsi::Runtime &rt, jsi::Array ids) override {
       static_assert(
           bridging::getParameterCount(&T::removeInboundP2PMessages) == 2,
           "Expected removeInboundP2PMessages(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::removeInboundP2PMessages, jsInvoker_, instance_, std::move(ids));
     }
     jsi::Value getOutboundP2PMessagesByID(jsi::Runtime &rt, jsi::Array ids) override {
       static_assert(
           bridging::getParameterCount(&T::getOutboundP2PMessagesByID) == 2,
           "Expected getOutboundP2PMessagesByID(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getOutboundP2PMessagesByID, jsInvoker_, instance_, std::move(ids));
     }
     jsi::Value getAllOutboundP2PMessages(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getAllOutboundP2PMessages) == 1,
           "Expected getAllOutboundP2PMessages(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getAllOutboundP2PMessages, jsInvoker_, instance_);
     }
     jsi::Value markOutboundP2PMessageAsSent(jsi::Runtime &rt, jsi::String messageID, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::markOutboundP2PMessageAsSent) == 3,
           "Expected markOutboundP2PMessageAsSent(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::markOutboundP2PMessageAsSent, jsInvoker_, instance_, std::move(messageID), std::move(deviceID));
     }
-    jsi::Value removeOutboundP2PMessagesOlderThan(jsi::Runtime &rt, jsi::String messageID, jsi::String deviceID) override {
+    jsi::Value removeOutboundP2PMessage(jsi::Runtime &rt, jsi::String messageID, jsi::String deviceID) override {
       static_assert(
-          bridging::getParameterCount(&T::removeOutboundP2PMessagesOlderThan) == 3,
-          "Expected removeOutboundP2PMessagesOlderThan(...) to have 3 parameters");
+          bridging::getParameterCount(&T::removeOutboundP2PMessage) == 3,
+          "Expected removeOutboundP2PMessage(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::removeOutboundP2PMessagesOlderThan, jsInvoker_, instance_, std::move(messageID), std::move(deviceID));
+          rt, &T::removeOutboundP2PMessage, jsInvoker_, instance_, std::move(messageID), std::move(deviceID));
     }
     jsi::Value resetOutboundP2PMessagesForDevice(jsi::Runtime &rt, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::resetOutboundP2PMessagesForDevice) == 2,
           "Expected resetOutboundP2PMessagesForDevice(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::resetOutboundP2PMessagesForDevice, jsInvoker_, instance_, std::move(deviceID));
     }
     jsi::Value getSyncedDatabaseVersion(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getSyncedDatabaseVersion) == 1,
           "Expected getSyncedDatabaseVersion(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getSyncedDatabaseVersion, jsInvoker_, instance_);
     }
     jsi::Value markPrekeysAsPublished(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::markPrekeysAsPublished) == 1,
           "Expected markPrekeysAsPublished(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::markPrekeysAsPublished, jsInvoker_, instance_);
     }
     jsi::Value getRelatedMessages(jsi::Runtime &rt, jsi::String messageID) override {
       static_assert(
           bridging::getParameterCount(&T::getRelatedMessages) == 2,
           "Expected getRelatedMessages(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getRelatedMessages, jsInvoker_, instance_, std::move(messageID));
     }
     jsi::Value searchMessages(jsi::Runtime &rt, jsi::String query, jsi::String threadID, std::optional<jsi::String> timestampCursor, std::optional<jsi::String> messageIDCursor) override {
       static_assert(
           bridging::getParameterCount(&T::searchMessages) == 5,
           "Expected searchMessages(...) to have 5 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::searchMessages, jsInvoker_, instance_, std::move(query), std::move(threadID), std::move(timestampCursor), std::move(messageIDCursor));
     }
 
   private:
     T *instance_;
   };
 
   Delegate delegate_;
 };
 
 } // namespace react
 } // namespace facebook
diff --git a/native/database/sqlite-api.js b/native/database/sqlite-api.js
index d3e4b4f1c..d303bbdf5 100644
--- a/native/database/sqlite-api.js
+++ b/native/database/sqlite-api.js
@@ -1,64 +1,63 @@
 // @flow
 
 import { getKeyserversToRemoveFromNotifsStore } from 'lib/ops/keyserver-store-ops.js';
 import { convertStoreOperationsToClientDBStoreOperations } from 'lib/shared/redux/client-db-utils.js';
 import type { SQLiteAPI } from 'lib/types/sqlite-types.js';
 import type { StoreOperations } from 'lib/types/store-ops-types';
 import { values } from 'lib/utils/objects.js';
 
 import { commCoreModule } from '../native-modules.js';
 import { isTaskCancelledError } from '../utils/error-handling.js';
 
 const sqliteAPI: SQLiteAPI = {
   // read operations
   getAllInboundP2PMessages: commCoreModule.getAllInboundP2PMessages,
   getAllOutboundP2PMessages: commCoreModule.getAllOutboundP2PMessages,
   getRelatedMessages: commCoreModule.getRelatedMessages,
   getOutboundP2PMessagesByID: commCoreModule.getOutboundP2PMessagesByID,
   searchMessages: commCoreModule.searchMessages,
 
   // write operations
   removeInboundP2PMessages: commCoreModule.removeInboundP2PMessages,
   markOutboundP2PMessageAsSent: commCoreModule.markOutboundP2PMessageAsSent,
   resetOutboundP2PMessagesForDevice:
     commCoreModule.resetOutboundP2PMessagesForDevice,
-  removeOutboundP2PMessagesOlderThan:
-    commCoreModule.removeOutboundP2PMessagesOlderThan,
+  removeOutboundP2PMessage: commCoreModule.removeOutboundP2PMessage,
 
   async processDBStoreOperations(
     storeOperations: StoreOperations,
   ): Promise<void> {
     const keyserversToRemoveFromNotifsStore =
       getKeyserversToRemoveFromNotifsStore(
         storeOperations.keyserverStoreOperations ?? [],
       );
 
     try {
       const promises = [];
       if (keyserversToRemoveFromNotifsStore.length > 0) {
         promises.push(
           commCoreModule.removeKeyserverDataFromNotifStorage(
             keyserversToRemoveFromNotifsStore,
           ),
         );
       }
 
       const dbOps =
         convertStoreOperationsToClientDBStoreOperations(storeOperations);
       if (values(dbOps).some(ops => ops && ops.length > 0)) {
         promises.push(commCoreModule.processDBStoreOperations(dbOps));
       }
       await Promise.all(promises);
     } catch (e) {
       if (isTaskCancelledError(e)) {
         return;
       }
       // this code will make an entry in SecureStore and cause re-creating
       // database when user will open app again
       commCoreModule.reportDBOperationsFailure();
       commCoreModule.terminate();
     }
   },
 };
 
 export { sqliteAPI };
diff --git a/native/schema/CommCoreModuleSchema.js b/native/schema/CommCoreModuleSchema.js
index 101f508d9..b7c0b8085 100644
--- a/native/schema/CommCoreModuleSchema.js
+++ b/native/schema/CommCoreModuleSchema.js
@@ -1,234 +1,234 @@
 // @flow
 
 'use strict';
 
 import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport.js';
 
 import type { ClientDBMessageStoreOperation } from 'lib/ops/message-store-ops.js';
 import type { ClientDBReportStoreOperation } from 'lib/ops/report-store-ops.js';
 import type { ClientDBThreadStoreOperation } from 'lib/ops/thread-store-ops.js';
 import type {
   OneTimeKeysResult,
   SignedPrekeys,
   ClientPublicKeys,
   EncryptedData,
   OutboundSessionCreationResult,
 } from 'lib/types/crypto-types.js';
 import type { ClientDBMessageInfo } from 'lib/types/message-types.js';
 import type { SIWEBackupSecrets } from 'lib/types/siwe-types.js';
 import type {
   InboundP2PMessage,
   OutboundP2PMessage,
 } from 'lib/types/sqlite-types.js';
 import type {
   ClientDBStore,
   ClientDBStoreOperations,
 } from 'lib/types/store-ops-types';
 import type { ClientDBThreadInfo } from 'lib/types/thread-types.js';
 
 type CommServicesAuthMetadata = {
   +userID?: ?string,
   +deviceID?: ?string,
   +accessToken?: ?string,
 };
 
 interface Spec extends TurboModule {
   +getDraft: (key: string) => Promise<string>;
   +updateDraft: (key: string, text: string) => Promise<boolean>;
   +moveDraft: (oldKey: string, newKey: string) => Promise<boolean>;
   +getClientDBStore: () => Promise<ClientDBStore>;
   +removeAllDrafts: () => Promise<void>;
   +getAllMessagesSync: () => $ReadOnlyArray<ClientDBMessageInfo>;
   +processMessageStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBMessageStoreOperation>,
   ) => void;
   +getAllThreadsSync: () => $ReadOnlyArray<ClientDBThreadInfo>;
   +processReportStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBReportStoreOperation>,
   ) => void;
   +processThreadStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBThreadStoreOperation>,
   ) => void;
   +processDBStoreOperations: (operations: Object) => Promise<void>;
   +initializeCryptoAccount: () => Promise<string>;
   +getUserPublicKey: () => Promise<ClientPublicKeys>;
   +getOneTimeKeys: (oneTimeKeysAmount: number) => Promise<OneTimeKeysResult>;
   +validateAndGetPrekeys: () => Promise<SignedPrekeys>;
   +validateAndUploadPrekeys: (
     authUserID: string,
     authDeviceID: string,
     authAccessToken: string,
   ) => Promise<void>;
   +initializeNotificationsSession: (
     identityKeys: string,
     prekey: string,
     prekeySignature: string,
     oneTimeKey: ?string,
     keyserverID: string,
   ) => Promise<string>;
   +isNotificationsSessionInitialized: () => Promise<boolean>;
   +isDeviceNotificationsSessionInitialized: (
     deviceID: string,
   ) => Promise<boolean>;
   +isNotificationsSessionInitializedWithDevices: (
     deviceIDs: $ReadOnlyArray<string>,
   ) => Promise<{ +[deviceID: string]: boolean }>;
   +updateKeyserverDataInNotifStorage: (
     keyserversData: $ReadOnlyArray<{ +id: string, +unreadCount: number }>,
   ) => Promise<void>;
   +removeKeyserverDataFromNotifStorage: (
     keyserverIDsToDelete: $ReadOnlyArray<string>,
   ) => Promise<void>;
   +getKeyserverDataFromNotifStorage: (
     keyserverIDs: $ReadOnlyArray<string>,
   ) => Promise<$ReadOnlyArray<{ +id: string, +unreadCount: number }>>;
   +initializeContentOutboundSession: (
     identityKeys: string,
     prekey: string,
     prekeySignature: string,
     oneTimeKey: ?string,
     deviceID: string,
   ) => Promise<OutboundSessionCreationResult>;
   +initializeContentInboundSession: (
     identityKeys: string,
     encryptedContent: Object,
     deviceID: string,
     sessionVersion: number,
     overwrite: boolean,
   ) => Promise<string>;
   +isContentSessionInitialized: (deviceID: string) => Promise<boolean>;
   +initializeNotificationsOutboundSession: (
     identityKeys: string,
     prekey: string,
     prekeySignature: string,
     oneTimeKey: ?string,
     deviceID: string,
   ) => Promise<EncryptedData>;
   +encrypt: (message: string, deviceID: string) => Promise<EncryptedData>;
   +encryptNotification: (
     payload: string,
     deviceID: string,
   ) => Promise<EncryptedData>;
   +encryptAndPersist: (
     message: string,
     deviceID: string,
     messageID: string,
   ) => Promise<EncryptedData>;
   +decrypt: (encryptedData: Object, deviceID: string) => Promise<string>;
   +decryptAndPersist: (
     encryptedData: Object,
     deviceID: string,
     userID: string,
     messageID: string,
   ) => Promise<string>;
   +signMessage: (message: string) => Promise<string>;
   +verifySignature: (
     publicKey: string,
     message: string,
     signature: string,
   ) => Promise<void>;
   +getCodeVersion: () => number;
   +terminate: () => void;
   +setNotifyToken: (token: string) => Promise<void>;
   +clearNotifyToken: () => Promise<void>;
   +stampSQLiteDBUserID: (userID: string) => Promise<void>;
   +getSQLiteStampedUserID: () => Promise<string>;
   +clearSensitiveData: () => Promise<void>;
   +checkIfDatabaseNeedsDeletion: () => boolean;
   +reportDBOperationsFailure: () => void;
   +computeBackupKey: (password: string, backupID: string) => Promise<Object>;
   +generateRandomString: (size: number) => Promise<string>;
   +setCommServicesAuthMetadata: (
     userID: string,
     deviceID: string,
     accessToken: string,
   ) => Promise<void>;
   +getCommServicesAuthMetadata: () => Promise<CommServicesAuthMetadata>;
   +clearCommServicesAuthMetadata: () => Promise<void>;
   +setCommServicesAccessToken: (accessToken: string) => Promise<void>;
   +clearCommServicesAccessToken: () => Promise<void>;
   +startBackupHandler: () => void;
   +stopBackupHandler: () => void;
   +createNewBackup: (backupSecret: string) => Promise<void>;
   +createNewSIWEBackup: (
     backupSecret: string,
     siweBackupMsg: string,
   ) => Promise<void>;
   +restoreBackup: (backupSecret: string, maxVersion: string) => Promise<string>;
   +restoreSIWEBackup: (
     backupSecret: string,
     backupID: string,
     maxVersion: string,
   ) => Promise<string>;
   +restoreBackupData: (
     backupID: string,
     backupDataKey: string,
     backupLogDataKey: string,
     maxVersion: string,
   ) => Promise<void>;
   +retrieveBackupKeys: (backupSecret: string) => Promise<string>;
   +retrieveLatestSIWEBackupData: () => Promise<string>;
   +setSIWEBackupSecrets: (siweBackupSecrets: Object) => Promise<void>;
   +getSIWEBackupSecrets: () => Promise<?Object>;
   +getAllInboundP2PMessages: () => Promise<Array<InboundP2PMessage>>;
   +removeInboundP2PMessages: (ids: $ReadOnlyArray<string>) => Promise<void>;
   +getOutboundP2PMessagesByID: (
     ids: $ReadOnlyArray<string>,
   ) => Promise<Array<OutboundP2PMessage>>;
   +getAllOutboundP2PMessages: () => Promise<Array<OutboundP2PMessage>>;
   +markOutboundP2PMessageAsSent: (
     messageID: string,
     deviceID: string,
   ) => Promise<void>;
-  +removeOutboundP2PMessagesOlderThan: (
+  +removeOutboundP2PMessage: (
     messageID: string,
     deviceID: string,
   ) => Promise<void>;
   +resetOutboundP2PMessagesForDevice: (
     deviceID: string,
   ) => Promise<Array<string>>;
   +getSyncedDatabaseVersion: () => Promise<string>;
   +markPrekeysAsPublished: () => Promise<void>;
   +getRelatedMessages: (
     messageID: string,
   ) => Promise<Array<ClientDBMessageInfo>>;
   +searchMessages: (
     query: string,
     threadID: string,
     timestampCursor: ?string,
     messageIDCursor: ?string,
   ) => Promise<Array<ClientDBMessageInfo>>;
 }
 
 export interface CoreModuleSpec extends Spec {
   +computeBackupKey: (
     password: string,
     backupID: string,
   ) => Promise<ArrayBuffer>;
   +decrypt: (encryptedData: EncryptedData, deviceID: string) => Promise<string>;
   +decryptAndPersist: (
     encryptedData: EncryptedData,
     deviceID: string,
     userID: string,
     messageID: string,
   ) => Promise<string>;
   +initializeContentInboundSession: (
     identityKeys: string,
     encryptedContent: EncryptedData,
     deviceID: string,
     sessionVersion: number,
     overwrite: boolean,
   ) => Promise<string>;
   +setSIWEBackupSecrets: (
     siweBackupSecrets: SIWEBackupSecrets,
   ) => Promise<void>;
   +getSIWEBackupSecrets: () => Promise<?SIWEBackupSecrets>;
   +processDBStoreOperations: (
     operations: ClientDBStoreOperations,
   ) => Promise<void>;
 }
 
 export default (TurboModuleRegistry.getEnforcing<Spec>(
   'CommTurboModule',
 ): Spec);
diff --git a/web/cpp/SQLiteQueryExecutorBindings.cpp b/web/cpp/SQLiteQueryExecutorBindings.cpp
index c962782e8..6db5c8eb3 100644
--- a/web/cpp/SQLiteQueryExecutorBindings.cpp
+++ b/web/cpp/SQLiteQueryExecutorBindings.cpp
@@ -1,414 +1,414 @@
 #include "SQLiteQueryExecutor.cpp"
 #include "entities/InboundP2PMessage.h"
 #include "entities/Nullable.h"
 #include "entities/OutboundP2PMessage.h"
 
 #include <emscripten/bind.h>
 #include <optional>
 #include <vector>
 
 namespace comm {
 
 using namespace emscripten;
 
 std::string getExceptionMessage(int exceptionPtr) {
   if (exceptionPtr == 0) {
     return std::string("Exception pointer value was null");
   }
 
   std::exception *e = reinterpret_cast<std::exception *>(exceptionPtr);
   if (e) {
     return std::string(e->what());
   }
   return std::string("Pointer to exception was invalid");
 }
 
 EMSCRIPTEN_BINDINGS(SQLiteQueryExecutor) {
   function("getExceptionMessage", &getExceptionMessage);
 
   value_object<NullableString>("NullableString")
       .field("value", &NullableString::value)
       .field("isNull", &NullableString::isNull);
   value_object<NullableInt>("NullableInt")
       .field("value", &NullableInt::value)
       .field("isNull", &NullableInt::isNull);
 
   value_object<Draft>("Draft")
       .field("key", &Draft::key)
       .field("text", &Draft::text);
   value_object<Report>("Report")
       .field("id", &Report::id)
       .field("report", &Report::report);
   value_object<PersistItem>("PersistItem")
       .field("key", &PersistItem::key)
       .field("item", &PersistItem::item);
   value_object<UserInfo>("UserInfo")
       .field("id", &UserInfo::id)
       .field("userInfo", &UserInfo::user_info);
   value_object<KeyserverInfo>("KeyserverInfo")
       .field("id", &KeyserverInfo::id)
       .field("keyserverInfo", &KeyserverInfo::keyserver_info)
       .field("syncedKeyserverInfo", &KeyserverInfo::synced_keyserver_info);
   value_object<MessageStoreThread>("MessageStoreThreads")
       .field("id", &MessageStoreThread::id)
       .field("startReached", &MessageStoreThread::start_reached);
   value_object<CommunityInfo>("CommunityInfo")
       .field("id", &CommunityInfo::id)
       .field("communityInfo", &CommunityInfo::community_info);
   value_object<IntegrityThreadHash>("IntegrityThreadHash")
       .field("id", &IntegrityThreadHash::id)
       .field("threadHash", &IntegrityThreadHash::thread_hash);
   value_object<SyncedMetadataEntry>("SyncedMetadataEntry")
       .field("name", &SyncedMetadataEntry::name)
       .field("data", &SyncedMetadataEntry::data);
   value_object<AuxUserInfo>("AuxUserInfo")
       .field("id", &AuxUserInfo::id)
       .field("auxUserInfo", &AuxUserInfo::aux_user_info);
   value_object<ThreadActivityEntry>("ThreadActivityEntry")
       .field("id", &ThreadActivityEntry::id)
       .field(
           "threadActivityStoreEntry",
           &ThreadActivityEntry::thread_activity_store_entry);
   value_object<EntryInfo>("EntryInfo")
       .field("id", &EntryInfo::id)
       .field("entry", &EntryInfo::entry);
   value_object<LocalMessageInfo>("LocalMessageInfo")
       .field("id", &LocalMessageInfo::id)
       .field("localMessageInfo", &LocalMessageInfo::local_message_info);
 
   value_object<WebThread>("WebThread")
       .field("id", &WebThread::id)
       .field("type", &WebThread::type)
       .field("name", &WebThread::name)
       .field("description", &WebThread::description)
       .field("color", &WebThread::color)
       .field("creationTime", &WebThread::creation_time)
       .field("parentThreadID", &WebThread::parent_thread_id)
       .field("containingThreadID", &WebThread::containing_thread_id)
       .field("community", &WebThread::community)
       .field("members", &WebThread::members)
       .field("roles", &WebThread::roles)
       .field("currentUser", &WebThread::current_user)
       .field("sourceMessageID", &WebThread::source_message_id)
       .field("repliesCount", &WebThread::replies_count)
       .field("avatar", &WebThread::avatar)
       .field("pinnedCount", &WebThread::pinned_count);
 
   value_object<WebMessage>("WebMessage")
       .field("id", &WebMessage::id)
       .field("localID", &WebMessage::local_id)
       .field("thread", &WebMessage::thread)
       .field("user", &WebMessage::user)
       .field("type", &WebMessage::type)
       .field("futureType", &WebMessage::future_type)
       .field("content", &WebMessage::content)
       .field("time", &WebMessage::time);
 
   value_object<Media>("Media")
       .field("id", &Media::id)
       .field("container", &Media::container)
       .field("thread", &Media::thread)
       .field("uri", &Media::uri)
       .field("type", &Media::type)
       .field("extras", &Media::extras);
 
   value_object<MessageWithMedias>("MessageWithMedias")
       .field("message", &MessageWithMedias::message)
       .field("medias", &MessageWithMedias::medias);
 
   value_object<OlmPersistSession>("OlmPersistSession")
       .field("targetDeviceID", &OlmPersistSession::target_device_id)
       .field("sessionData", &OlmPersistSession::session_data)
       .field("version", &OlmPersistSession::version);
 
   value_object<OutboundP2PMessage>("OutboundP2PMessage")
       .field("messageID", &OutboundP2PMessage::message_id)
       .field("deviceID", &OutboundP2PMessage::device_id)
       .field("userID", &OutboundP2PMessage::user_id)
       .field("timestamp", &OutboundP2PMessage::timestamp)
       .field("plaintext", &OutboundP2PMessage::plaintext)
       .field("ciphertext", &OutboundP2PMessage::ciphertext)
       .field("status", &OutboundP2PMessage::status)
       .field("supportsAutoRetry", &OutboundP2PMessage::supports_auto_retry);
 
   value_object<InboundP2PMessage>("InboundP2PMessage")
       .field("messageID", &InboundP2PMessage::message_id)
       .field("senderDeviceID", &InboundP2PMessage::sender_device_id)
       .field("senderUserID", &InboundP2PMessage::sender_user_id)
       .field("plaintext", &InboundP2PMessage::plaintext)
       .field("status", &InboundP2PMessage::status);
 
   class_<SQLiteQueryExecutor>("SQLiteQueryExecutor")
       .constructor<std::string>()
       .function("updateDraft", &SQLiteQueryExecutor::updateDraft)
       .function("moveDraft", &SQLiteQueryExecutor::moveDraft)
       .function("getAllDrafts", &SQLiteQueryExecutor::getAllDrafts)
       .function("removeAllDrafts", &SQLiteQueryExecutor::removeAllDrafts)
       .function("removeDrafts", &SQLiteQueryExecutor::removeDrafts)
       .function("getAllMessagesWeb", &SQLiteQueryExecutor::getAllMessagesWeb)
       .function("removeAllMessages", &SQLiteQueryExecutor::removeAllMessages)
       .function("removeMessages", &SQLiteQueryExecutor::removeMessages)
       .function(
           "removeMessagesForThreads",
           &SQLiteQueryExecutor::removeMessagesForThreads)
       .function("replaceMessageWeb", &SQLiteQueryExecutor::replaceMessageWeb)
       .function("rekeyMessage", &SQLiteQueryExecutor::rekeyMessage)
       .function("removeAllMedia", &SQLiteQueryExecutor::removeAllMedia)
       .function(
           "removeMediaForThreads", &SQLiteQueryExecutor::removeMediaForThreads)
       .function(
           "removeMediaForMessage", &SQLiteQueryExecutor::removeMediaForMessage)
       .function(
           "removeMediaForMessages",
           &SQLiteQueryExecutor::removeMediaForMessages)
       .function("replaceMedia", &SQLiteQueryExecutor::replaceMedia)
       .function(
           "rekeyMediaContainers", &SQLiteQueryExecutor::rekeyMediaContainers)
       .function(
           "replaceMessageStoreThreads",
           &SQLiteQueryExecutor::replaceMessageStoreThreads)
       .function(
           "removeMessageStoreThreads",
           &SQLiteQueryExecutor::removeMessageStoreThreads)
       .function(
           "getAllMessageStoreThreads",
           &SQLiteQueryExecutor::getAllMessageStoreThreads)
       .function(
           "removeAllMessageStoreThreads",
           &SQLiteQueryExecutor::removeAllMessageStoreThreads)
       .function("setMetadata", &SQLiteQueryExecutor::setMetadata)
       .function("clearMetadata", &SQLiteQueryExecutor::clearMetadata)
       .function("getMetadata", &SQLiteQueryExecutor::getMetadata)
       .function("replaceReport", &SQLiteQueryExecutor::replaceReport)
       .function("removeReports", &SQLiteQueryExecutor::removeReports)
       .function("removeAllReports", &SQLiteQueryExecutor::removeAllReports)
       .function("getAllReports", &SQLiteQueryExecutor::getAllReports)
       .function(
           "setPersistStorageItem", &SQLiteQueryExecutor::setPersistStorageItem)
       .function(
           "removePersistStorageItem",
           &SQLiteQueryExecutor::removePersistStorageItem)
       .function(
           "getPersistStorageItem", &SQLiteQueryExecutor::getPersistStorageItem)
       .function("replaceUser", &SQLiteQueryExecutor::replaceUser)
       .function("removeUsers", &SQLiteQueryExecutor::removeUsers)
       .function("removeAllUsers", &SQLiteQueryExecutor::removeAllUsers)
       .function("getAllUsers", &SQLiteQueryExecutor::getAllUsers)
       .function("replaceThreadWeb", &SQLiteQueryExecutor::replaceThreadWeb)
       .function("getAllThreadsWeb", &SQLiteQueryExecutor::getAllThreadsWeb)
       .function("removeAllThreads", &SQLiteQueryExecutor::removeAllThreads)
       .function("removeThreads", &SQLiteQueryExecutor::removeThreads)
       .function("replaceKeyserver", &SQLiteQueryExecutor::replaceKeyserver)
       .function("removeKeyservers", &SQLiteQueryExecutor::removeKeyservers)
       .function(
           "removeAllKeyservers", &SQLiteQueryExecutor::removeAllKeyservers)
       .function("getAllKeyservers", &SQLiteQueryExecutor::getAllKeyservers)
       .function("replaceCommunity", &SQLiteQueryExecutor::replaceCommunity)
       .function("removeCommunities", &SQLiteQueryExecutor::removeCommunities)
       .function(
           "removeAllCommunities", &SQLiteQueryExecutor::removeAllCommunities)
       .function("getAllCommunities", &SQLiteQueryExecutor::getAllCommunities)
       .function(
           "replaceIntegrityThreadHashes",
           &SQLiteQueryExecutor::replaceIntegrityThreadHashes)
       .function(
           "removeIntegrityThreadHashes",
           &SQLiteQueryExecutor::removeIntegrityThreadHashes)
       .function(
           "removeAllIntegrityThreadHashes",
           &SQLiteQueryExecutor::removeAllIntegrityThreadHashes)
       .function(
           "getAllIntegrityThreadHashes",
           &SQLiteQueryExecutor::getAllIntegrityThreadHashes)
       .function(
           "replaceSyncedMetadataEntry",
           &SQLiteQueryExecutor::replaceSyncedMetadataEntry)
       .function(
           "removeSyncedMetadata", &SQLiteQueryExecutor::removeSyncedMetadata)
       .function(
           "removeAllSyncedMetadata",
           &SQLiteQueryExecutor::removeAllSyncedMetadata)
       .function(
           "getAllSyncedMetadata", &SQLiteQueryExecutor::getAllSyncedMetadata)
       .function("replaceAuxUserInfo", &SQLiteQueryExecutor::replaceAuxUserInfo)
       .function("removeAuxUserInfos", &SQLiteQueryExecutor::removeAuxUserInfos)
       .function(
           "removeAllAuxUserInfos", &SQLiteQueryExecutor::removeAllAuxUserInfos)
       .function("getAllAuxUserInfos", &SQLiteQueryExecutor::getAllAuxUserInfos)
       .function(
           "replaceThreadActivityEntry",
           &SQLiteQueryExecutor::replaceThreadActivityEntry)
       .function(
           "removeThreadActivityEntries",
           &SQLiteQueryExecutor::removeThreadActivityEntries)
       .function(
           "removeAllThreadActivityEntries",
           &SQLiteQueryExecutor::removeAllThreadActivityEntries)
       .function(
           "getAllThreadActivityEntries",
           &SQLiteQueryExecutor::getAllThreadActivityEntries)
       .function("replaceEntry", &SQLiteQueryExecutor::replaceEntry)
       .function("removeEntries", &SQLiteQueryExecutor::removeEntries)
       .function("removeAllEntries", &SQLiteQueryExecutor::removeAllEntries)
       .function("getAllEntries", &SQLiteQueryExecutor::getAllEntries)
       .function(
           "replaceMessageStoreLocalMessageInfo",
           &SQLiteQueryExecutor::replaceMessageStoreLocalMessageInfo)
       .function(
           "removeMessageStoreLocalMessageInfos",
           &SQLiteQueryExecutor::removeMessageStoreLocalMessageInfos)
       .function(
           "removeAllMessageStoreLocalMessageInfos",
           &SQLiteQueryExecutor::removeAllMessageStoreLocalMessageInfos)
       .function(
           "getAllMessageStoreLocalMessageInfos",
           &SQLiteQueryExecutor::getAllMessageStoreLocalMessageInfos)
       .function("beginTransaction", &SQLiteQueryExecutor::beginTransaction)
       .function("commitTransaction", &SQLiteQueryExecutor::commitTransaction)
       .function(
           "getContentAccountID", &SQLiteQueryExecutor::getContentAccountID)
       .function("getNotifsAccountID", &SQLiteQueryExecutor::getNotifsAccountID)
       .function(
           "getOlmPersistSessionsData",
           &SQLiteQueryExecutor::getOlmPersistSessionsData)
       .function(
           "getOlmPersistAccountDataWeb",
           &SQLiteQueryExecutor::getOlmPersistAccountDataWeb)
       .function(
           "storeOlmPersistSession",
           &SQLiteQueryExecutor::storeOlmPersistSession)
       .function(
           "storeOlmPersistAccount",
           &SQLiteQueryExecutor::storeOlmPersistAccount)
       .function(
           "rollbackTransaction", &SQLiteQueryExecutor::rollbackTransaction)
       .function(
           "restoreFromMainCompaction",
           &SQLiteQueryExecutor::restoreFromMainCompaction)
       .function(
           "restoreFromBackupLog", &SQLiteQueryExecutor::restoreFromBackupLog)
       .function(
           "addOutboundP2PMessages",
           &SQLiteQueryExecutor::addOutboundP2PMessages)
       .function(
-          "removeOutboundP2PMessagesOlderThan",
-          &SQLiteQueryExecutor::removeOutboundP2PMessagesOlderThan)
+          "removeOutboundP2PMessage",
+          &SQLiteQueryExecutor::removeOutboundP2PMessage)
       .function(
           "removeAllOutboundP2PMessages",
           &SQLiteQueryExecutor::removeAllOutboundP2PMessages)
       .function(
           "getOutboundP2PMessagesByID",
           &SQLiteQueryExecutor::getOutboundP2PMessagesByID)
       .function(
           "getAllOutboundP2PMessages",
           &SQLiteQueryExecutor::getAllOutboundP2PMessages)
       .function(
           "setCiphertextForOutboundP2PMessage",
           &SQLiteQueryExecutor::setCiphertextForOutboundP2PMessage)
       .function(
           "markOutboundP2PMessageAsSent",
           &SQLiteQueryExecutor::markOutboundP2PMessageAsSent)
       .function(
           "resetOutboundP2PMessagesForDevice",
           &SQLiteQueryExecutor::resetOutboundP2PMessagesForDevice)
       .function(
           "addInboundP2PMessage", &SQLiteQueryExecutor::addInboundP2PMessage)
       .function(
           "getAllInboundP2PMessage",
           &SQLiteQueryExecutor::getAllInboundP2PMessage)
       .function(
           "removeInboundP2PMessages",
           &SQLiteQueryExecutor::removeInboundP2PMessages)
       .function(
           "getRelatedMessagesWeb", &SQLiteQueryExecutor::getRelatedMessagesWeb)
       .function(
           "updateMessageSearchIndex",
           &SQLiteQueryExecutor::updateMessageSearchIndex)
       .function("searchMessages", &SQLiteQueryExecutor::searchMessagesWeb);
 }
 
 } // namespace comm
 
 namespace emscripten {
 namespace internal {
 
 template <typename T, typename Allocator>
 struct BindingType<std::vector<T, Allocator>> {
   using ValBinding = BindingType<val>;
   using WireType = ValBinding::WireType;
 
   static WireType toWireType(const std::vector<T, Allocator> &vec) {
     std::vector<val> valVec(vec.begin(), vec.end());
     return BindingType<val>::toWireType(val::array(valVec));
   }
 
   static std::vector<T, Allocator> fromWireType(WireType value) {
     return vecFromJSArray<T>(ValBinding::fromWireType(value));
   }
 };
 
 template <typename T>
 struct TypeID<
     T,
     typename std::enable_if_t<std::is_same<
         typename Canonicalized<T>::type,
         std::vector<
             typename Canonicalized<T>::type::value_type,
             typename Canonicalized<T>::type::allocator_type>>::value>> {
   static constexpr TYPEID get() {
     return TypeID<val>::get();
   }
 };
 
 template <typename T> struct TypeID<std::optional<T>> {
   static constexpr TYPEID get() {
     return LightTypeID<val>::get();
   }
 };
 
 template <typename T> struct TypeID<const std::optional<T>> {
   static constexpr TYPEID get() {
     return LightTypeID<val>::get();
   }
 };
 
 template <typename T> struct TypeID<std::optional<T> &> {
   static constexpr TYPEID get() {
     return LightTypeID<val>::get();
   }
 };
 
 template <typename T> struct TypeID<std::optional<T> &&> {
   static constexpr TYPEID get() {
     return LightTypeID<val>::get();
   }
 };
 
 template <typename T> struct TypeID<const std::optional<T> &> {
   static constexpr TYPEID get() {
     return LightTypeID<val>::get();
   }
 };
 
 template <typename T> struct BindingType<std::optional<T>> {
   using ValBinding = BindingType<val>;
   using WireType = ValBinding::WireType;
 
   static WireType toWireType(std::optional<T> const &opt) {
     if (!opt.has_value()) {
       return ValBinding::toWireType(val::null());
     }
     return ValBinding::toWireType(val(opt.value()));
   }
 
   static std::optional<T> fromWireType(WireType value) {
     val convertedVal = ValBinding::fromWireType(value);
     if (convertedVal.isNull() || convertedVal.isUndefined()) {
       return std::nullopt;
     }
     return std::make_optional<T>(convertedVal.as<T>());
   }
 };
 
 } // namespace internal
 } // namespace emscripten
diff --git a/web/database/sqlite-api.js b/web/database/sqlite-api.js
index bd87bd1e8..9362272be 100644
--- a/web/database/sqlite-api.js
+++ b/web/database/sqlite-api.js
@@ -1,170 +1,170 @@
 // @flow
 
 import { convertStoreOperationsToClientDBStoreOperations } from 'lib/shared/redux/client-db-utils.js';
 import type { ClientDBMessageInfo } from 'lib/types/message-types.js';
 import type {
   SQLiteAPI,
   InboundP2PMessage,
   OutboundP2PMessage,
 } from 'lib/types/sqlite-types.js';
 import type { StoreOperations } from 'lib/types/store-ops-types.js';
 import { entries, values } from 'lib/utils/objects.js';
 
 import { getCommSharedWorker } from '../shared-worker/shared-worker-provider.js';
 import { workerRequestMessageTypes } from '../types/worker-types.js';
 
 const sqliteAPI: SQLiteAPI = {
   // read operations
   async getAllInboundP2PMessages(): Promise<InboundP2PMessage[]> {
     const sharedWorker = await getCommSharedWorker();
 
     const data = await sharedWorker.schedule({
       type: workerRequestMessageTypes.GET_INBOUND_P2P_MESSAGES,
     });
     const messages: ?$ReadOnlyArray<InboundP2PMessage> =
       data?.inboundP2PMessages;
     return messages ? [...messages] : [];
   },
 
   async getAllOutboundP2PMessages(): Promise<OutboundP2PMessage[]> {
     const sharedWorker = await getCommSharedWorker();
 
     const data = await sharedWorker.schedule({
       type: workerRequestMessageTypes.GET_OUTBOUND_P2P_MESSAGES,
     });
     const messages: ?$ReadOnlyArray<OutboundP2PMessage> =
       data?.outboundP2PMessages;
     return messages ? [...messages] : [];
   },
 
   async getRelatedMessages(messageID: string): Promise<ClientDBMessageInfo[]> {
     const sharedWorker = await getCommSharedWorker();
 
     const data = await sharedWorker.schedule({
       type: workerRequestMessageTypes.GET_RELATED_MESSAGES,
       messageID,
     });
     const messages: ?$ReadOnlyArray<ClientDBMessageInfo> = data?.messages;
     return messages ? [...messages] : [];
   },
 
   async getOutboundP2PMessagesByID(
     ids: $ReadOnlyArray<string>,
   ): Promise<Array<OutboundP2PMessage>> {
     const sharedWorker = await getCommSharedWorker();
 
     const data = await sharedWorker.schedule({
       type: workerRequestMessageTypes.GET_OUTBOUND_P2P_MESSAGES_BY_ID,
       messageIDs: ids,
     });
     const messages: ?$ReadOnlyArray<OutboundP2PMessage> =
       data?.outboundP2PMessages;
     return messages ? [...messages] : [];
   },
 
   async searchMessages(
     query: string,
     threadID: string,
     timestampCursor: ?string,
     messageIDCursor: ?string,
   ): Promise<ClientDBMessageInfo[]> {
     const sharedWorker = await getCommSharedWorker();
 
     const data = await sharedWorker.schedule({
       type: workerRequestMessageTypes.SEARCH_MESSAGES,
       query,
       threadID,
       timestampCursor,
       messageIDCursor,
     });
     const messages: ?$ReadOnlyArray<ClientDBMessageInfo> = data?.messages;
     return messages ? [...messages] : [];
   },
 
   // write operations
   async removeInboundP2PMessages(ids: $ReadOnlyArray<string>): Promise<void> {
     const sharedWorker = await getCommSharedWorker();
 
     await sharedWorker.schedule({
       type: workerRequestMessageTypes.REMOVE_INBOUND_P2P_MESSAGES,
       ids,
     });
   },
 
   async markOutboundP2PMessageAsSent(
     messageID: string,
     deviceID: string,
   ): Promise<void> {
     const sharedWorker = await getCommSharedWorker();
 
     await sharedWorker.schedule({
       type: workerRequestMessageTypes.MARK_OUTBOUND_P2P_MESSAGE_AS_SENT,
       messageID,
       deviceID,
     });
   },
 
   async resetOutboundP2PMessagesForDevice(
     deviceID: string,
   ): Promise<Array<string>> {
     const sharedWorker = await getCommSharedWorker();
 
     const data = await sharedWorker.schedule({
       type: workerRequestMessageTypes.RESET_OUTBOUND_P2P_MESSAGES,
       deviceID,
     });
     const messageIDs: ?$ReadOnlyArray<string> = data?.messageIDs;
     return messageIDs ? [...messageIDs] : [];
   },
 
-  async removeOutboundP2PMessagesOlderThan(
+  async removeOutboundP2PMessage(
     messageID: string,
     deviceID: string,
   ): Promise<void> {
     const sharedWorker = await getCommSharedWorker();
 
     await sharedWorker.schedule({
-      type: workerRequestMessageTypes.REMOVE_OUTBOUND_P2P_MESSAGES,
+      type: workerRequestMessageTypes.REMOVE_OUTBOUND_P2P_MESSAGE,
       messageID,
       deviceID,
     });
   },
 
   async processDBStoreOperations(
     storeOperations: StoreOperations,
   ): Promise<void> {
     const dbOps =
       convertStoreOperationsToClientDBStoreOperations(storeOperations);
 
     if (!values(dbOps).some(ops => ops && ops.length > 0)) {
       return;
     }
 
     const sharedWorker = await getCommSharedWorker();
     const isSupported = await sharedWorker.isSupported();
     if (!isSupported) {
       return;
     }
     try {
       await sharedWorker.schedule({
         type: workerRequestMessageTypes.PROCESS_STORE_OPERATIONS,
         storeOperations: dbOps,
       });
     } catch (e) {
       console.log(e);
       if (
         entries(storeOperations).some(
           ([key, ops]) =>
             key !== 'draftStoreOperations' &&
             key !== 'reportStoreOperations' &&
             ops.length > 0,
         )
       ) {
         await sharedWorker.init({ clearDatabase: true, markAsCorrupted: true });
         location.reload();
       }
     }
   },
 };
 
 export { sqliteAPI };
diff --git a/web/shared-worker/_generated/comm_query_executor.wasm b/web/shared-worker/_generated/comm_query_executor.wasm
index 314348b44..c8b57e8d5 100755
Binary files a/web/shared-worker/_generated/comm_query_executor.wasm and b/web/shared-worker/_generated/comm_query_executor.wasm differ
diff --git a/web/shared-worker/queries/outbound-p2p-message-queries.test.js b/web/shared-worker/queries/outbound-p2p-message-queries.test.js
index 53b1016b3..883df18e6 100644
--- a/web/shared-worker/queries/outbound-p2p-message-queries.test.js
+++ b/web/shared-worker/queries/outbound-p2p-message-queries.test.js
@@ -1,258 +1,249 @@
 // @flow
 
 import {
   type OutboundP2PMessage,
   outboundP2PMessageStatuses,
 } from 'lib/types/sqlite-types.js';
 
 import { getDatabaseModule } from '../db-module.js';
 import type { EmscriptenModule } from '../types/module.js';
 import { type SQLiteQueryExecutor } from '../types/sqlite-query-executor.js';
 import { clearSensitiveData } from '../utils/db-utils.js';
 
 const FILE_PATH = 'test.sqlite';
 
 const timestamp1 = new Date('2023-01-01T00:00:00').getTime().toString();
 const timestamp2 = new Date('2023-01-02T00:00:00').getTime().toString();
 const timestamp3 = new Date('2023-01-03T00:00:00').getTime().toString();
 const timestamp4 = new Date('2023-01-04T00:00:00').getTime().toString();
 
 const device1 = 'device-1';
 const device2 = 'device-2';
 
 const TEST_MSG_1: OutboundP2PMessage = {
   messageID: 'id-1',
   deviceID: device1,
   userID: 'user-1',
   timestamp: timestamp2,
   plaintext: 'decrypted-1',
   ciphertext: 'encrypted-1',
   status: 'encrypted',
   supportsAutoRetry: false,
 };
 const TEST_MSG_2: OutboundP2PMessage = {
   messageID: 'id-2',
   deviceID: device2,
   userID: 'user-2',
   timestamp: timestamp3,
   plaintext: 'decrypted-2',
   ciphertext: 'encrypted-2',
   status: 'encrypted',
   supportsAutoRetry: false,
 };
 
 const TEST_MSG_3: OutboundP2PMessage = {
   messageID: 'id-3',
   deviceID: device1,
   userID: 'user-1',
   timestamp: timestamp1,
   plaintext: 'decrypted-3',
   ciphertext: 'encrypted-3',
   status: 'encrypted',
   supportsAutoRetry: false,
 };
 
 const TEST_MSG_4: OutboundP2PMessage = {
   messageID: 'id-4',
   deviceID: device1,
   userID: 'user-1',
   timestamp: timestamp4,
   plaintext: 'decrypted-4',
   ciphertext: '',
   status: 'encrypted',
   supportsAutoRetry: false,
 };
 
 const messagesOrdered = [TEST_MSG_3, TEST_MSG_1, TEST_MSG_2, TEST_MSG_4];
 
 describe('Outbound P2P messages queries', () => {
   let queryExecutor: ?SQLiteQueryExecutor = null;
   let dbModule: ?EmscriptenModule = null;
 
   beforeAll(async () => {
     dbModule = getDatabaseModule();
   });
 
   beforeEach(() => {
     if (!dbModule) {
       throw new Error('Database module is missing');
     }
     queryExecutor = new dbModule.SQLiteQueryExecutor(FILE_PATH);
     if (!queryExecutor) {
       throw new Error('SQLiteQueryExecutor is missing');
     }
     queryExecutor?.addOutboundP2PMessages([
       TEST_MSG_1,
       TEST_MSG_2,
       TEST_MSG_3,
       TEST_MSG_4,
     ]);
   });
 
   afterEach(() => {
     if (!dbModule || !queryExecutor) {
       return;
     }
     clearSensitiveData(dbModule, FILE_PATH, queryExecutor);
   });
 
   it('should return all messages', () => {
     expect(queryExecutor?.getAllOutboundP2PMessages().length).toBe(4);
   });
 
   it('should return messages in correct order', () => {
     const messages = queryExecutor?.getAllOutboundP2PMessages();
     expect(messages).toStrictEqual(messagesOrdered);
   });
 
-  it('should not remove messages for a different deviceID', () => {
-    queryExecutor?.removeOutboundP2PMessagesOlderThan(
+  it('should remove message', () => {
+    queryExecutor?.removeOutboundP2PMessage(
       TEST_MSG_4.messageID,
       TEST_MSG_4.deviceID,
     );
 
-    expect(queryExecutor?.getAllOutboundP2PMessages().length).toBe(1);
-    expect(queryExecutor?.getAllOutboundP2PMessages()).toStrictEqual([
-      TEST_MSG_2,
-    ]);
-  });
-
-  it('should remove older messages', () => {
-    queryExecutor?.removeOutboundP2PMessagesOlderThan(
-      TEST_MSG_1.messageID,
-      TEST_MSG_1.deviceID,
-    );
+    expect(queryExecutor?.getAllOutboundP2PMessages().length).toBe(3);
     expect(queryExecutor?.getAllOutboundP2PMessages()).toStrictEqual([
+      TEST_MSG_3,
+      TEST_MSG_1,
       TEST_MSG_2,
-      TEST_MSG_4,
     ]);
   });
 
   it('should remove all messages for given device', () => {
     queryExecutor?.removeAllOutboundP2PMessages(device1);
     queryExecutor?.removeAllOutboundP2PMessages(device2);
     expect(queryExecutor?.getAllOutboundP2PMessages().length).toBe(0);
   });
 
   it('should set ciphertext for given message', () => {
     const ciphertext = 'updated';
 
     queryExecutor?.setCiphertextForOutboundP2PMessage(
       TEST_MSG_4.messageID,
       TEST_MSG_4.deviceID,
       ciphertext,
     );
 
     const messages = queryExecutor?.getAllOutboundP2PMessages() ?? [];
     expect(messages.length).toBe(4);
     expect(
       messages.find(msg => msg.messageID === TEST_MSG_4.messageID)?.ciphertext,
     ).toBe(ciphertext);
   });
 
   it('should mark message status as sent', () => {
     queryExecutor?.markOutboundP2PMessageAsSent(
       TEST_MSG_4.messageID,
       TEST_MSG_4.deviceID,
     );
 
     const messages = queryExecutor?.getAllOutboundP2PMessages() ?? [];
     expect(messages.length).toBe(4);
     expect(
       messages.find(msg => msg.messageID === TEST_MSG_4.messageID)?.status,
     ).toBe('sent');
   });
 
   it('should return message by ID', () => {
     expect(queryExecutor?.getOutboundP2PMessagesByID(['id-4'])).toEqual([
       TEST_MSG_4,
     ]);
   });
 
   it('should return message by IDs', () => {
     expect(queryExecutor?.getOutboundP2PMessagesByID(['id-4', 'id-2'])).toEqual(
       [TEST_MSG_2, TEST_MSG_4],
     );
   });
 
   it(`should return undefined when a message with ID doesn't exist`, () => {
     expect(queryExecutor?.getOutboundP2PMessagesByID(['id-5'])).toEqual([]);
   });
 
   it('should reset messages', () => {
     const deviceID = 'deviceID';
     const MSG_TO_RESET_1: OutboundP2PMessage = {
       messageID: 'reset-1',
       deviceID,
       userID: 'user-1',
       timestamp: '1',
       plaintext: 'decrypted-1',
       ciphertext: 'encrypted-1',
       status: 'encrypted',
       supportsAutoRetry: true,
     };
 
     const MSG_TO_RESET_2: OutboundP2PMessage = {
       messageID: 'reset-2',
       deviceID,
       userID: 'user-1',
       timestamp: '1',
       plaintext: 'decrypted-1',
       ciphertext: 'encrypted-1',
       status: 'sent',
       supportsAutoRetry: false,
     };
 
     const MSG_NOT_RESET: OutboundP2PMessage = {
       messageID: 'reset-3',
       deviceID,
       userID: 'user-1',
       timestamp: '3',
       plaintext: 'decrypted-1',
       ciphertext: 'encrypted-1',
       status: 'encrypted',
       supportsAutoRetry: false,
     };
 
     queryExecutor?.addOutboundP2PMessages([
       MSG_TO_RESET_1,
       MSG_TO_RESET_2,
       MSG_NOT_RESET,
     ]);
 
     const messageIDs =
       queryExecutor?.resetOutboundP2PMessagesForDevice(deviceID);
 
     expect(messageIDs).toEqual([
       MSG_TO_RESET_1.messageID,
       MSG_TO_RESET_2.messageID,
     ]);
 
     const messagesAfterReset = [
       {
         ...MSG_TO_RESET_1,
         status: outboundP2PMessageStatuses.persisted,
         ciphertext: '',
         supportsAutoRetry: true,
       },
       {
         ...MSG_TO_RESET_2,
         status: outboundP2PMessageStatuses.persisted,
         ciphertext: '',
         supportsAutoRetry: true,
       },
     ];
     expect(queryExecutor?.getOutboundP2PMessagesByID(messageIDs ?? [])).toEqual(
       messagesAfterReset,
     );
     expect(
       queryExecutor?.getOutboundP2PMessagesByID([MSG_NOT_RESET.messageID]),
     ).toEqual([
       {
         ...MSG_NOT_RESET,
         ciphertext: '',
         status: outboundP2PMessageStatuses.persisted,
       },
     ]);
   });
 });
diff --git a/web/shared-worker/types/sqlite-query-executor.js b/web/shared-worker/types/sqlite-query-executor.js
index d41f665c1..3922b42c2 100644
--- a/web/shared-worker/types/sqlite-query-executor.js
+++ b/web/shared-worker/types/sqlite-query-executor.js
@@ -1,218 +1,215 @@
 // @flow
 
 import type { ClientDBAuxUserInfo } from 'lib/ops/aux-user-store-ops.js';
 import type { ClientDBCommunityInfo } from 'lib/ops/community-store-ops.js';
 import type { ClientDBEntryInfo } from 'lib/ops/entries-store-ops.js';
 import type { ClientDBIntegrityThreadHash } from 'lib/ops/integrity-store-ops.js';
 import type { ClientDBKeyserverInfo } from 'lib/ops/keyserver-store-ops.js';
 import type { ClientDBReport } from 'lib/ops/report-store-ops.js';
 import type { ClientDBSyncedMetadataEntry } from 'lib/ops/synced-metadata-store-ops.js';
 import type { ClientDBThreadActivityEntry } from 'lib/ops/thread-activity-store-ops.js';
 import type { ClientDBUserInfo } from 'lib/ops/user-store-ops.js';
 import type { ClientDBDraftInfo } from 'lib/types/draft-types.js';
 import type { ClientDBLocalMessageInfo } from 'lib/types/message-types.js';
 import type {
   OutboundP2PMessage,
   InboundP2PMessage,
 } from 'lib/types/sqlite-types.js';
 
 import {
   type NullableInt,
   type NullableString,
   type WebClientDBThreadInfo,
 } from './entities.js';
 
 export type WebMessage = {
   +id: string,
   +localID: NullableString,
   +thread: string,
   +user: string,
   +type: number,
   +futureType: NullableInt,
   +content: NullableString,
   +time: string,
 };
 
 export type Media = {
   +id: string,
   +container: string,
   +thread: string,
   +uri: string,
   +type: 'photo' | 'video',
   +extras: string,
 };
 
 export type OlmPersistSession = {
   +targetDeviceID: string,
   +sessionData: string,
   +version: number,
 };
 
 type MessageEntity = {
   +message: WebMessage,
   +medias: $ReadOnlyArray<Media>,
 };
 
 declare export class SQLiteQueryExecutor {
   constructor(sqliteFilePath: string): void;
 
   updateDraft(key: string, text: string): void;
   moveDraft(oldKey: string, newKey: string): boolean;
   getAllDrafts(): ClientDBDraftInfo[];
   removeAllDrafts(): void;
   removeDrafts(ids: $ReadOnlyArray<string>): void;
 
   getAllMessagesWeb(): $ReadOnlyArray<MessageEntity>;
   removeAllMessages(): void;
   removeMessages(ids: $ReadOnlyArray<string>): void;
   removeMessagesForThreads(threadIDs: $ReadOnlyArray<string>): void;
   replaceMessageWeb(message: WebMessage): void;
   rekeyMessage(from: string, to: string): void;
   removeAllMedia(): void;
   removeMediaForThreads(threadIDs: $ReadOnlyArray<string>): void;
   removeMediaForMessages(msgIDs: $ReadOnlyArray<string>): void;
   removeMediaForMessage(msgID: string): void;
   replaceMedia(media: Media): void;
   rekeyMediaContainers(from: string, to: string): void;
 
   replaceMessageStoreThreads(
     threads: $ReadOnlyArray<{ +id: string, +startReached: number }>,
   ): void;
   removeMessageStoreThreads($ReadOnlyArray<string>): void;
   getAllMessageStoreThreads(): $ReadOnlyArray<{
     +id: string,
     +startReached: number,
   }>;
   removeAllMessageStoreThreads(): void;
 
   setMetadata(entryName: string, data: string): void;
   clearMetadata(entryName: string): void;
   getMetadata(entryName: string): string;
 
   replaceReport(report: ClientDBReport): void;
   removeReports(ids: $ReadOnlyArray<string>): void;
   removeAllReports(): void;
   getAllReports(): ClientDBReport[];
 
   setPersistStorageItem(key: string, item: string): void;
   removePersistStorageItem(key: string): void;
   getPersistStorageItem(key: string): string;
 
   replaceUser(userInfo: ClientDBUserInfo): void;
   removeUsers(ids: $ReadOnlyArray<string>): void;
   removeAllUsers(): void;
   getAllUsers(): ClientDBUserInfo[];
 
   replaceThreadWeb(thread: WebClientDBThreadInfo): void;
   removeThreads(ids: $ReadOnlyArray<string>): void;
   removeAllThreads(): void;
   getAllThreadsWeb(): WebClientDBThreadInfo[];
 
   replaceKeyserver(keyserverInfo: ClientDBKeyserverInfo): void;
   removeKeyservers(ids: $ReadOnlyArray<string>): void;
   removeAllKeyservers(): void;
   getAllKeyservers(): ClientDBKeyserverInfo[];
 
   replaceCommunity(communityInfo: ClientDBCommunityInfo): void;
   removeCommunities(ids: $ReadOnlyArray<string>): void;
   removeAllCommunities(): void;
   getAllCommunities(): ClientDBCommunityInfo[];
 
   replaceIntegrityThreadHashes(
     threadHashes: $ReadOnlyArray<ClientDBIntegrityThreadHash>,
   ): void;
   removeIntegrityThreadHashes(ids: $ReadOnlyArray<string>): void;
   removeAllIntegrityThreadHashes(): void;
   getAllIntegrityThreadHashes(): ClientDBIntegrityThreadHash[];
 
   replaceSyncedMetadataEntry(
     syncedMetadataEntry: ClientDBSyncedMetadataEntry,
   ): void;
   removeSyncedMetadata(names: $ReadOnlyArray<string>): void;
   removeAllSyncedMetadata(): void;
   getAllSyncedMetadata(): ClientDBSyncedMetadataEntry[];
   replaceAuxUserInfo(auxUserInfo: ClientDBAuxUserInfo): void;
   removeAuxUserInfos(ids: $ReadOnlyArray<string>): void;
   removeAllAuxUserInfos(): void;
   getAllAuxUserInfos(): ClientDBAuxUserInfo[];
 
   replaceThreadActivityEntry(
     threadActivityEntry: ClientDBThreadActivityEntry,
   ): void;
   removeThreadActivityEntries(ids: $ReadOnlyArray<string>): void;
   removeAllThreadActivityEntries(): void;
   getAllThreadActivityEntries(): ClientDBThreadActivityEntry[];
 
   replaceEntry(entryInfo: ClientDBEntryInfo): void;
   removeEntries(ids: $ReadOnlyArray<string>): void;
   removeAllEntries(): void;
   getAllEntries(): $ReadOnlyArray<ClientDBEntryInfo>;
 
   replaceMessageStoreLocalMessageInfo(
     localMessageInfo: ClientDBLocalMessageInfo,
   ): void;
   removeMessageStoreLocalMessageInfos(ids: $ReadOnlyArray<string>): void;
   removeAllMessageStoreLocalMessageInfos(): void;
   getAllMessageStoreLocalMessageInfos(): ClientDBLocalMessageInfo[];
 
   beginTransaction(): void;
   commitTransaction(): void;
   rollbackTransaction(): void;
 
   getContentAccountID(): number;
   getNotifsAccountID(): number;
   getOlmPersistAccountDataWeb(accountID: number): NullableString;
   getOlmPersistSessionsData(): $ReadOnlyArray<OlmPersistSession>;
   storeOlmPersistAccount(accountID: number, accountData: string): void;
   storeOlmPersistSession(session: OlmPersistSession): void;
 
   restoreFromMainCompaction(
     mainCompactionPath: string,
     mainCompactionEncryptionKey: string,
     maxVersion: string,
   ): void;
 
   restoreFromBackupLog(backupLog: Uint8Array): void;
 
   addOutboundP2PMessages(messages: $ReadOnlyArray<OutboundP2PMessage>): void;
-  removeOutboundP2PMessagesOlderThan(
-    lastConfirmedMessageID: string,
-    deviceID: string,
-  ): void;
+  removeOutboundP2PMessage(confirmedMessageID: string, deviceID: string): void;
   removeAllOutboundP2PMessages(deviceID: string): void;
   getOutboundP2PMessagesByID(
     ids: $ReadOnlyArray<string>,
   ): $ReadOnlyArray<OutboundP2PMessage>;
   getAllOutboundP2PMessages(): $ReadOnlyArray<OutboundP2PMessage>;
   setCiphertextForOutboundP2PMessage(
     messageID: string,
     deviceID: string,
     ciphertext: string,
   ): void;
   markOutboundP2PMessageAsSent(messageID: string, deviceID: string): void;
   resetOutboundP2PMessagesForDevice(deviceID: string): $ReadOnlyArray<string>;
 
   addInboundP2PMessage(message: InboundP2PMessage): void;
   getAllInboundP2PMessage(): $ReadOnlyArray<InboundP2PMessage>;
   removeInboundP2PMessages(ids: $ReadOnlyArray<string>): void;
 
   getRelatedMessagesWeb(id: string): $ReadOnlyArray<MessageEntity>;
 
   updateMessageSearchIndex(
     originalMessageID: string,
     messageID: string,
     content: string,
   ): void;
   searchMessages(
     query: string,
     threadID: string,
     timestampCursor: ?string,
     messageIDCursor: ?string,
   ): $ReadOnlyArray<MessageEntity>;
 
   // method is provided to manually signal that a C++ object
   // is no longer needed and can be deleted
   delete(): void;
 }
 
 export type SQLiteQueryExecutorType = typeof SQLiteQueryExecutor;
diff --git a/web/shared-worker/worker/shared-worker.js b/web/shared-worker/worker/shared-worker.js
index 50293c920..698eea60c 100644
--- a/web/shared-worker/worker/shared-worker.js
+++ b/web/shared-worker/worker/shared-worker.js
@@ -1,434 +1,434 @@
 // @flow
 
 import localforage from 'localforage';
 
 import { getMessageForException } from 'lib/utils/errors.js';
 
 import { restoreBackup } from './backup.js';
 import { processAppIdentityClientRequest } from './identity-client.js';
 import {
   getClientStoreFromQueryExecutor,
   processDBStoreOperations,
 } from './process-operations.js';
 import { clearCryptoStore, processAppOlmApiRequest } from './worker-crypto.js';
 import {
   getDBModule,
   getSQLiteQueryExecutor,
   setDBModule,
   setSQLiteQueryExecutor,
   getPlatformDetails,
   setPlatformDetails,
 } from './worker-database.js';
 import initBackupClientModule from '../../backup-client-wasm/wasm/backup-client-wasm.js';
 import {
   decryptData,
   encryptData,
   generateCryptoKey,
   importJWKKey,
   type EncryptedData,
 } from '../../crypto/aes-gcm-crypto-utils.js';
 import {
   type SharedWorkerMessageEvent,
   type WorkerRequestMessage,
   type WorkerResponseMessage,
   workerRequestMessageTypes,
   workerResponseMessageTypes,
   type WorkerRequestProxyMessage,
   workerWriteRequests,
   workerOlmAPIRequests,
 } from '../../types/worker-types.js';
 import { workerIdentityClientRequests } from '../../types/worker-types.js';
 import { getDatabaseModule } from '../db-module.js';
 import { webMessageToClientDBMessageInfo } from '../types/entities.js';
 import {
   COMM_SQLITE_DATABASE_PATH,
   SQLITE_STAMPED_USER_ID_KEY,
   localforageConfig,
   SQLITE_CONTENT,
   SQLITE_ENCRYPTION_KEY,
   DEFAULT_BACKUP_CLIENT_FILENAME,
 } from '../utils/constants.js';
 import {
   clearSensitiveData,
   exportDatabaseContent,
   importDatabaseContent,
 } from '../utils/db-utils.js';
 
 localforage.config(localforageConfig);
 
 let encryptionKey: ?CryptoKey = null;
 
 let persistNeeded: boolean = false;
 let persistInProgress: boolean = false;
 
 async function initDatabase(
   webworkerModulesFilePath: string,
   commQueryExecutorFilename: ?string,
   encryptionKeyJWK?: ?SubtleCrypto$JsonWebKey,
 ) {
   const dbModule = getDBModule();
   const sqliteQueryExecutor = getSQLiteQueryExecutor();
   if (!!dbModule && !!sqliteQueryExecutor) {
     console.log('Database already initialized');
     return;
   }
 
   const newModule = dbModule
     ? dbModule
     : getDatabaseModule(commQueryExecutorFilename, webworkerModulesFilePath);
   if (!dbModule) {
     setDBModule(newModule);
   }
 
   if (encryptionKeyJWK) {
     encryptionKey = await importJWKKey(encryptionKeyJWK);
   } else {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
     if (!encryptionKey) {
       const cryptoKey = await generateCryptoKey({ extractable: false });
       await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     }
   }
 
   const encryptedContent =
     await localforage.getItem<EncryptedData>(SQLITE_CONTENT);
 
   let dbContent = null;
   try {
     if (encryptionKey && encryptedContent) {
       dbContent = await decryptData(encryptedContent, encryptionKey);
     }
   } catch (e) {
     console.error('Error while decrypting content, clearing database content');
     await localforage.removeItem(SQLITE_CONTENT);
   }
 
   if (dbContent) {
     importDatabaseContent(dbContent, newModule, COMM_SQLITE_DATABASE_PATH);
 
     console.info(
       'Database exists and is properly encrypted, using persisted data',
     );
   } else {
     console.info('Creating fresh database');
   }
   setSQLiteQueryExecutor(
     new newModule.SQLiteQueryExecutor(COMM_SQLITE_DATABASE_PATH),
   );
 }
 
 async function initBackupClient(
   webworkerModulesFilePath: string,
   backupClientFilename: ?string,
 ) {
   let modulePath;
   if (backupClientFilename) {
     modulePath = `${webworkerModulesFilePath}/${backupClientFilename}`;
   } else {
     modulePath = `${webworkerModulesFilePath}/${DEFAULT_BACKUP_CLIENT_FILENAME}`;
   }
   await initBackupClientModule(modulePath);
 }
 
 async function persist() {
   persistInProgress = true;
   const sqliteQueryExecutor = getSQLiteQueryExecutor();
   const dbModule = getDBModule();
   if (!sqliteQueryExecutor || !dbModule) {
     persistInProgress = false;
     throw new Error(
       'Database not initialized while persisting database content',
     );
   }
 
   if (!encryptionKey) {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
   }
 
   while (persistNeeded) {
     persistNeeded = false;
     const dbData = exportDatabaseContent(dbModule, COMM_SQLITE_DATABASE_PATH);
     if (!encryptionKey) {
       persistInProgress = false;
       throw new Error('Encryption key is missing');
     }
     const encryptedData = await encryptData(dbData, encryptionKey);
     await localforage.setItem(SQLITE_CONTENT, encryptedData);
   }
   persistInProgress = false;
 }
 
 async function processAppRequest(
   message: WorkerRequestMessage,
 ): Promise<?WorkerResponseMessage> {
   // non-database operations
   if (message.type === workerRequestMessageTypes.PING) {
     return {
       type: workerResponseMessageTypes.PONG,
       text: 'PONG',
     };
   } else if (
     message.type === workerRequestMessageTypes.GENERATE_DATABASE_ENCRYPTION_KEY
   ) {
     const cryptoKey = await generateCryptoKey({ extractable: false });
     await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     return undefined;
   }
 
   const sqliteQueryExecutor = getSQLiteQueryExecutor();
   const dbModule = getDBModule();
 
   // database operations
   if (message.type === workerRequestMessageTypes.INIT) {
     setPlatformDetails(message.platformDetails);
     const promises = [
       initDatabase(
         message.webworkerModulesFilePath,
         message.commQueryExecutorFilename,
         message.encryptionKey,
       ),
     ];
     if (message.backupClientFilename !== undefined) {
       promises.push(
         initBackupClient(
           message.webworkerModulesFilePath,
           message.backupClientFilename,
         ),
       );
     }
     await Promise.all(promises);
     return undefined;
   } else if (message.type === workerRequestMessageTypes.CLEAR_SENSITIVE_DATA) {
     clearCryptoStore();
     encryptionKey = null;
     await localforage.clear();
     if (dbModule && sqliteQueryExecutor) {
       clearSensitiveData(
         dbModule,
         COMM_SQLITE_DATABASE_PATH,
         sqliteQueryExecutor,
       );
     }
     setSQLiteQueryExecutor(null);
     return undefined;
   }
 
   if (!sqliteQueryExecutor) {
     throw new Error(
       `Database not initialized, unable to process request type: ${message.type}`,
     );
   }
 
   // read-only operations
   if (message.type === workerRequestMessageTypes.GET_CLIENT_STORE) {
     return {
       type: workerResponseMessageTypes.CLIENT_STORE,
       store: getClientStoreFromQueryExecutor(sqliteQueryExecutor),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_SQLITE_STAMPED_USER_ID
   ) {
     return {
       type: workerResponseMessageTypes.GET_SQLITE_STAMPED_USER_ID,
       userID: sqliteQueryExecutor.getMetadata(SQLITE_STAMPED_USER_ID_KEY),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_PERSIST_STORAGE_ITEM
   ) {
     return {
       type: workerResponseMessageTypes.GET_PERSIST_STORAGE_ITEM,
       item: sqliteQueryExecutor.getPersistStorageItem(message.key),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_INBOUND_P2P_MESSAGES
   ) {
     return {
       type: workerResponseMessageTypes.GET_INBOUND_P2P_MESSAGES,
       inboundP2PMessages: sqliteQueryExecutor.getAllInboundP2PMessage(),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_OUTBOUND_P2P_MESSAGES
   ) {
     return {
       type: workerResponseMessageTypes.GET_OUTBOUND_P2P_MESSAGES,
       outboundP2PMessages: sqliteQueryExecutor.getAllOutboundP2PMessages(),
     };
   } else if (message.type === workerRequestMessageTypes.GET_RELATED_MESSAGES) {
     const webMessageEntities = sqliteQueryExecutor.getRelatedMessagesWeb(
       message.messageID,
     );
     return {
       type: workerResponseMessageTypes.GET_MESSAGES,
       messages: webMessageEntities.map(webMessageToClientDBMessageInfo),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_OUTBOUND_P2P_MESSAGES_BY_ID
   ) {
     return {
       type: workerResponseMessageTypes.GET_OUTBOUND_P2P_MESSAGES,
       outboundP2PMessages: sqliteQueryExecutor.getOutboundP2PMessagesByID(
         message.messageIDs,
       ),
     };
   } else if (message.type === workerRequestMessageTypes.SEARCH_MESSAGES) {
     const webMessageEntities = sqliteQueryExecutor.searchMessages(
       message.query,
       message.threadID,
       message.timestampCursor,
       message.messageIDCursor,
     );
     return {
       type: workerResponseMessageTypes.GET_MESSAGES,
       messages: webMessageEntities.map(webMessageToClientDBMessageInfo),
     };
   }
 
   // write operations
   const isOlmAPIRequest = workerOlmAPIRequests.includes(message.type);
   const isIdentityClientRequest = workerIdentityClientRequests.includes(
     message.type,
   );
   if (
     !workerWriteRequests.includes(message.type) &&
     !isOlmAPIRequest &&
     !isIdentityClientRequest
   ) {
     throw new Error(`Request type ${message.type} not supported`);
   }
   if (!sqliteQueryExecutor || !dbModule) {
     throw new Error(
       `Database not initialized, unable to process request type: ${message.type}`,
     );
   }
 
   let result;
   if (isOlmAPIRequest) {
     result = await processAppOlmApiRequest(message);
   } else if (isIdentityClientRequest) {
     const platformDetails = getPlatformDetails();
     if (!platformDetails) {
       throw new Error(
         'Platform details not set, unable to process identity client request',
       );
     }
     result = await processAppIdentityClientRequest(
       sqliteQueryExecutor,
       dbModule,
       platformDetails,
       message,
     );
   } else if (
     message.type === workerRequestMessageTypes.PROCESS_STORE_OPERATIONS
   ) {
     processDBStoreOperations(
       sqliteQueryExecutor,
       message.storeOperations,
       dbModule,
     );
   } else if (
     message.type === workerRequestMessageTypes.STAMP_SQLITE_DB_USER_ID
   ) {
     sqliteQueryExecutor.setMetadata(SQLITE_STAMPED_USER_ID_KEY, message.userID);
   } else if (
     message.type === workerRequestMessageTypes.SET_PERSIST_STORAGE_ITEM
   ) {
     sqliteQueryExecutor.setPersistStorageItem(message.key, message.item);
   } else if (
     message.type === workerRequestMessageTypes.REMOVE_PERSIST_STORAGE_ITEM
   ) {
     sqliteQueryExecutor.removePersistStorageItem(message.key);
   } else if (message.type === workerRequestMessageTypes.BACKUP_RESTORE) {
     await restoreBackup(
       sqliteQueryExecutor,
       dbModule,
       message.authMetadata,
       message.backupID,
       message.backupDataKey,
       message.backupLogDataKey,
     );
   } else if (
     message.type === workerRequestMessageTypes.REMOVE_INBOUND_P2P_MESSAGES
   ) {
     sqliteQueryExecutor.removeInboundP2PMessages(message.ids);
   } else if (
     message.type === workerRequestMessageTypes.MARK_OUTBOUND_P2P_MESSAGE_AS_SENT
   ) {
     sqliteQueryExecutor.markOutboundP2PMessageAsSent(
       message.messageID,
       message.deviceID,
     );
   } else if (
-    message.type === workerRequestMessageTypes.REMOVE_OUTBOUND_P2P_MESSAGES
+    message.type === workerRequestMessageTypes.REMOVE_OUTBOUND_P2P_MESSAGE
   ) {
-    sqliteQueryExecutor.removeOutboundP2PMessagesOlderThan(
+    sqliteQueryExecutor.removeOutboundP2PMessage(
       message.messageID,
       message.deviceID,
     );
   } else if (
     message.type === workerRequestMessageTypes.RESET_OUTBOUND_P2P_MESSAGES
   ) {
     let messageIDs: $ReadOnlyArray<string> = [];
     try {
       sqliteQueryExecutor.beginTransaction();
       messageIDs = sqliteQueryExecutor.resetOutboundP2PMessagesForDevice(
         message.deviceID,
       );
       sqliteQueryExecutor.commitTransaction();
     } catch (e) {
       sqliteQueryExecutor.rollbackTransaction();
       console.log('Error while resetting outbound P2P messages: ', e);
       throw e;
     }
 
     return {
       type: workerResponseMessageTypes.RESET_OUTBOUND_P2P_MESSAGES,
       messageIDs,
     };
   }
 
   persistNeeded = true;
   if (!persistInProgress) {
     void persist();
   }
 
   return result;
 }
 
 let currentlyProcessedMessage: ?Promise<void> = null;
 
 function connectHandler(event: SharedWorkerMessageEvent) {
   if (!event.ports.length) {
     return;
   }
   const port: MessagePort = event.ports[0];
   console.log('Web database worker alive!');
 
   port.onmessage = async function (messageEvent: MessageEvent) {
     const data: WorkerRequestProxyMessage = (messageEvent.data: any);
     const { id, message } = data;
 
     if (!id) {
       port.postMessage({
         error: 'Request without identifier',
       });
     }
 
     currentlyProcessedMessage = (async () => {
       await currentlyProcessedMessage;
       try {
         const result = await processAppRequest(message);
         port.postMessage({
           id,
           message: result,
         });
       } catch (e) {
         port.postMessage({
           id,
           error: getMessageForException(e),
         });
       }
     })();
   };
 }
 
 self.addEventListener('connect', connectHandler);
diff --git a/web/types/worker-types.js b/web/types/worker-types.js
index ef92ae1f6..a1daa5720 100644
--- a/web/types/worker-types.js
+++ b/web/types/worker-types.js
@@ -1,338 +1,338 @@
 // @flow
 
 import type { AuthMetadata } from 'lib/shared/identity-client-context.js';
 import type {
   PickledOLMAccount,
   OLMIdentityKeys,
   OlmAPI,
 } from 'lib/types/crypto-types.js';
 import type { PlatformDetails } from 'lib/types/device-types.js';
 import type {
   IdentityServiceClient,
   IdentityServiceAuthLayer,
 } from 'lib/types/identity-service-types.js';
 import type { ClientDBMessageInfo } from 'lib/types/message-types.js';
 import type {
   InboundP2PMessage,
   OutboundP2PMessage,
 } from 'lib/types/sqlite-types.js';
 import type {
   ClientDBStore,
   ClientDBStoreOperations,
 } from 'lib/types/store-ops-types.js';
 
 // The types of messages sent from app to worker
 export const workerRequestMessageTypes = Object.freeze({
   PING: 0,
   INIT: 1,
   GENERATE_DATABASE_ENCRYPTION_KEY: 2,
   PROCESS_STORE_OPERATIONS: 3,
   GET_CLIENT_STORE: 4,
   STAMP_SQLITE_DB_USER_ID: 5,
   GET_SQLITE_STAMPED_USER_ID: 6,
   GET_PERSIST_STORAGE_ITEM: 7,
   SET_PERSIST_STORAGE_ITEM: 8,
   REMOVE_PERSIST_STORAGE_ITEM: 9,
   CLEAR_SENSITIVE_DATA: 10,
   BACKUP_RESTORE: 11,
   INITIALIZE_CRYPTO_ACCOUNT: 12,
   CREATE_IDENTITY_SERVICE_CLIENT: 13,
   CALL_IDENTITY_CLIENT_METHOD: 14,
   CALL_OLM_API_METHOD: 15,
   GET_INBOUND_P2P_MESSAGES: 16,
   REMOVE_INBOUND_P2P_MESSAGES: 17,
   GET_OUTBOUND_P2P_MESSAGES: 18,
   MARK_OUTBOUND_P2P_MESSAGE_AS_SENT: 19,
-  REMOVE_OUTBOUND_P2P_MESSAGES: 20,
+  REMOVE_OUTBOUND_P2P_MESSAGE: 20,
   GET_RELATED_MESSAGES: 21,
   GET_OUTBOUND_P2P_MESSAGES_BY_ID: 22,
   SEARCH_MESSAGES: 23,
   RESET_OUTBOUND_P2P_MESSAGES: 24,
 });
 
 export const workerWriteRequests: $ReadOnlyArray<number> = [
   workerRequestMessageTypes.PROCESS_STORE_OPERATIONS,
   workerRequestMessageTypes.STAMP_SQLITE_DB_USER_ID,
   workerRequestMessageTypes.SET_PERSIST_STORAGE_ITEM,
   workerRequestMessageTypes.REMOVE_PERSIST_STORAGE_ITEM,
   workerRequestMessageTypes.BACKUP_RESTORE,
   workerRequestMessageTypes.INITIALIZE_CRYPTO_ACCOUNT,
   workerRequestMessageTypes.REMOVE_INBOUND_P2P_MESSAGES,
   workerRequestMessageTypes.MARK_OUTBOUND_P2P_MESSAGE_AS_SENT,
-  workerRequestMessageTypes.REMOVE_OUTBOUND_P2P_MESSAGES,
+  workerRequestMessageTypes.REMOVE_OUTBOUND_P2P_MESSAGE,
   workerRequestMessageTypes.RESET_OUTBOUND_P2P_MESSAGES,
 ];
 
 export const workerOlmAPIRequests: $ReadOnlyArray<number> = [
   workerRequestMessageTypes.INITIALIZE_CRYPTO_ACCOUNT,
   workerRequestMessageTypes.CALL_OLM_API_METHOD,
 ];
 
 export const workerIdentityClientRequests: $ReadOnlyArray<number> = [
   workerRequestMessageTypes.CREATE_IDENTITY_SERVICE_CLIENT,
   workerRequestMessageTypes.CALL_IDENTITY_CLIENT_METHOD,
 ];
 
 export type PingWorkerRequestMessage = {
   +type: 0,
   +text: string,
 };
 
 export type InitWorkerRequestMessage = {
   +type: 1,
   +platformDetails: PlatformDetails,
   +webworkerModulesFilePath: string,
   +commQueryExecutorFilename: ?string,
   +encryptionKey?: ?SubtleCrypto$JsonWebKey,
   +backupClientFilename?: ?string,
 };
 
 export type GenerateDatabaseEncryptionKeyRequestMessage = {
   +type: 2,
 };
 
 export type ProcessStoreOperationsRequestMessage = {
   +type: 3,
   +storeOperations: ClientDBStoreOperations,
 };
 
 export type GetClientStoreRequestMessage = {
   +type: 4,
 };
 
 export type SetCurrentUserIDRequestMessage = {
   +type: 5,
   +userID: string,
 };
 
 export type GetCurrentUserIDRequestMessage = {
   +type: 6,
 };
 
 export type GetPersistStorageItemRequestMessage = {
   +type: 7,
   +key: string,
 };
 
 export type SetPersistStorageItemRequestMessage = {
   +type: 8,
   +key: string,
   +item: string,
 };
 
 export type RemovePersistStorageItemRequestMessage = {
   +type: 9,
   +key: string,
 };
 
 export type ClearSensitiveDataRequestMessage = {
   +type: 10,
 };
 
 export type BackupRestoreRequestMessage = {
   +type: 11,
   +authMetadata: AuthMetadata,
   +backupID: string,
   +backupDataKey: string,
   +backupLogDataKey: string,
 };
 
 // Previously used on web in redux. Now only used
 // in a migration to the shared worker.
 export type LegacyCryptoStore = {
   +primaryAccount: PickledOLMAccount,
   +primaryIdentityKeys: OLMIdentityKeys,
   +notificationAccount: PickledOLMAccount,
   +notificationIdentityKeys: OLMIdentityKeys,
 };
 export type InitializeCryptoAccountRequestMessage = {
   +type: 12,
   +olmWasmPath: string,
   +initialCryptoStore?: LegacyCryptoStore,
 };
 
 export type CreateIdentityServiceClientRequestMessage = {
   +type: 13,
   +opaqueWasmPath: string,
   +authLayer: ?IdentityServiceAuthLayer,
 };
 
 export type CallIdentityClientMethodRequestMessage = {
   +type: 14,
   +method: $Keys<IdentityServiceClient>,
   +args: $ReadOnlyArray<mixed>,
 };
 
 export type CallOLMApiMethodRequestMessage = {
   +type: 15,
   +method: $Keys<OlmAPI>,
   +args: $ReadOnlyArray<mixed>,
 };
 
 export type GetInboundP2PMessagesRequestMessage = {
   +type: 16,
 };
 
 export type RemoveInboundP2PMessagesRequestMessage = {
   +type: 17,
   +ids: $ReadOnlyArray<string>,
 };
 
 export type GetOutboundP2PMessagesRequestMessage = {
   +type: 18,
 };
 
 export type MarkOutboundP2PMessageAsSentRequestMessage = {
   +type: 19,
   +messageID: string,
   +deviceID: string,
 };
 
-export type RemoveOutboundP2PMessagesRequestMessage = {
+export type RemoveOutboundP2PMessageRequestMessage = {
   +type: 20,
   +messageID: string,
   +deviceID: string,
 };
 
 export type GetRelatedMessagesRequestMessage = {
   +type: 21,
   +messageID: string,
 };
 
 export type GetOutboundP2PMessagesByIDRequestMessage = {
   +type: 22,
   +messageIDs: $ReadOnlyArray<string>,
 };
 
 export type SearchMessagesRequestMessage = {
   +type: 23,
   +query: string,
   +threadID: string,
   +timestampCursor: ?string,
   +messageIDCursor: ?string,
 };
 
 export type ResetOutboundP2PMessagesRequestMessage = {
   +type: 24,
   +deviceID: string,
 };
 
 export type WorkerRequestMessage =
   | PingWorkerRequestMessage
   | InitWorkerRequestMessage
   | GenerateDatabaseEncryptionKeyRequestMessage
   | ProcessStoreOperationsRequestMessage
   | GetClientStoreRequestMessage
   | SetCurrentUserIDRequestMessage
   | GetCurrentUserIDRequestMessage
   | GetPersistStorageItemRequestMessage
   | SetPersistStorageItemRequestMessage
   | RemovePersistStorageItemRequestMessage
   | ClearSensitiveDataRequestMessage
   | BackupRestoreRequestMessage
   | InitializeCryptoAccountRequestMessage
   | CreateIdentityServiceClientRequestMessage
   | CallIdentityClientMethodRequestMessage
   | CallOLMApiMethodRequestMessage
   | GetInboundP2PMessagesRequestMessage
   | RemoveInboundP2PMessagesRequestMessage
   | GetOutboundP2PMessagesRequestMessage
   | MarkOutboundP2PMessageAsSentRequestMessage
-  | RemoveOutboundP2PMessagesRequestMessage
+  | RemoveOutboundP2PMessageRequestMessage
   | GetRelatedMessagesRequestMessage
   | GetOutboundP2PMessagesByIDRequestMessage
   | SearchMessagesRequestMessage
   | ResetOutboundP2PMessagesRequestMessage;
 
 export type WorkerRequestProxyMessage = {
   +id: number,
   +message: WorkerRequestMessage,
 };
 
 // The types of messages sent from worker to app
 export const workerResponseMessageTypes = Object.freeze({
   PONG: 0,
   CLIENT_STORE: 1,
   GET_SQLITE_STAMPED_USER_ID: 2,
   GET_PERSIST_STORAGE_ITEM: 3,
   CALL_IDENTITY_CLIENT_METHOD: 4,
   CALL_OLM_API_METHOD: 5,
   GET_INBOUND_P2P_MESSAGES: 6,
   GET_OUTBOUND_P2P_MESSAGES: 7,
   GET_MESSAGES: 8,
   RESET_OUTBOUND_P2P_MESSAGES: 9,
 });
 
 export type PongWorkerResponseMessage = {
   +type: 0,
   +text: string,
 };
 
 export type ClientStoreResponseMessage = {
   +type: 1,
   +store: ClientDBStore,
 };
 
 export type GetCurrentUserIDResponseMessage = {
   +type: 2,
   +userID: ?string,
 };
 
 export type GetPersistStorageItemResponseMessage = {
   +type: 3,
   +item: string,
 };
 
 export type CallIdentityClientMethodResponseMessage = {
   +type: 4,
   +result: mixed,
 };
 
 export type CallOLMApiMethodResponseMessage = {
   +type: 5,
   +result: mixed,
 };
 
 export type GetInboundP2PMessagesResponseMessage = {
   +type: 6,
   +inboundP2PMessages: $ReadOnlyArray<InboundP2PMessage>,
 };
 
 export type GetOutboundP2PMessagesResponseMessage = {
   +type: 7,
   +outboundP2PMessages: $ReadOnlyArray<OutboundP2PMessage>,
 };
 
 export type GetMessagesResponse = {
   +type: 8,
   +messages: $ReadOnlyArray<ClientDBMessageInfo>,
 };
 
 export type ResetOutboundP2PMessagesResponseMessage = {
   +type: 9,
   +messageIDs: $ReadOnlyArray<string>,
 };
 
 export type WorkerResponseMessage =
   | PongWorkerResponseMessage
   | ClientStoreResponseMessage
   | GetCurrentUserIDResponseMessage
   | GetPersistStorageItemResponseMessage
   | CallIdentityClientMethodResponseMessage
   | CallOLMApiMethodResponseMessage
   | GetInboundP2PMessagesResponseMessage
   | GetOutboundP2PMessagesResponseMessage
   | GetMessagesResponse
   | ResetOutboundP2PMessagesResponseMessage;
 
 export type WorkerResponseProxyMessage = {
   +id?: number,
   +message?: WorkerResponseMessage,
   +error?: string,
 };
 
 // SharedWorker types
 export type SharedWorkerMessageEvent = MessageEvent & {
   +ports: $ReadOnlyArray<MessagePort>,
   ...
 };