diff --git a/native/cpp/CommonCpp/DatabaseManagers/entities/MessageToDevice.h b/native/cpp/CommonCpp/DatabaseManagers/entities/MessageToDevice.h
new file mode 100644
index 000000000..3bb575ede
--- /dev/null
+++ b/native/cpp/CommonCpp/DatabaseManagers/entities/MessageToDevice.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <sqlite3.h>
+#include <memory>
+#include <string>
+
+#include "SQLiteDataConverters.h"
+
+namespace comm {
+
+struct MessageToDevice {
+  std::string message_id;
+  std::string device_id;
+  std::string user_id;
+  int64_t timestamp;
+  std::string plaintext;
+  std::string ciphertext;
+
+  static MessageToDevice fromSQLResult(sqlite3_stmt *sqlRow, int idx) {
+    return MessageToDevice{
+        getStringFromSQLRow(sqlRow, idx),
+        getStringFromSQLRow(sqlRow, idx + 1),
+        getStringFromSQLRow(sqlRow, idx + 2),
+        getInt64FromSQLRow(sqlRow, idx + 3),
+        getStringFromSQLRow(sqlRow, idx + 4),
+        getStringFromSQLRow(sqlRow, idx + 5),
+    };
+  }
+
+  int bindToSQL(sqlite3_stmt *sql, int idx) const {
+    bindStringToSQL(message_id, sql, idx);
+    bindStringToSQL(device_id, sql, idx + 1);
+    bindStringToSQL(user_id, sql, idx + 2);
+    bindInt64ToSQL(timestamp, sql, idx + 3);
+    bindStringToSQL(plaintext, sql, idx + 4);
+    return bindStringToSQL(ciphertext, sql, idx + 5);
+  }
+};
+
+struct ClientMessageToDevice {
+  std::string message_id;
+  std::string device_id;
+  std::string user_id;
+  std::string timestamp;
+  std::string plaintext;
+  std::string ciphertext;
+
+  ClientMessageToDevice() = default;
+
+  ClientMessageToDevice(const MessageToDevice &msg) {
+    message_id = msg.message_id;
+    device_id = msg.device_id;
+    user_id = msg.user_id;
+    timestamp = std::to_string(msg.timestamp);
+    plaintext = msg.plaintext;
+    ciphertext = msg.ciphertext;
+  }
+
+  MessageToDevice toMessageToDevice() const {
+    MessageToDevice msg;
+    msg.message_id = message_id;
+    msg.device_id = device_id;
+    msg.user_id = user_id;
+    msg.timestamp = std::stoll(timestamp);
+    msg.plaintext = plaintext;
+    msg.ciphertext = ciphertext;
+    return msg;
+  }
+};
+
+} // namespace comm
diff --git a/web/cpp/SQLiteQueryExecutorBindings.cpp b/web/cpp/SQLiteQueryExecutorBindings.cpp
index 163180261..7118ddfd6 100644
--- a/web/cpp/SQLiteQueryExecutorBindings.cpp
+++ b/web/cpp/SQLiteQueryExecutorBindings.cpp
@@ -1,226 +1,235 @@
 #include "SQLiteQueryExecutor.cpp"
+#include "entities/MessageToDevice.h"
 #include "entities/Nullable.h"
 
 #include <emscripten/bind.h>
 #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);
   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<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("targetUserID", &OlmPersistSession::target_user_id)
       .field("sessionData", &OlmPersistSession::session_data);
 
+  value_object<ClientMessageToDevice>("ClientMessageToDevice")
+      .field("messageID", &ClientMessageToDevice::message_id)
+      .field("deviceID", &ClientMessageToDevice::device_id)
+      .field("userID", &ClientMessageToDevice::user_id)
+      .field("timestamp", &ClientMessageToDevice::timestamp)
+      .field("plaintext", &ClientMessageToDevice::plaintext)
+      .field("ciphertext", &ClientMessageToDevice::ciphertext);
+
   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("beginTransaction", &SQLiteQueryExecutor::beginTransaction)
       .function("commitTransaction", &SQLiteQueryExecutor::commitTransaction)
       .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);
 }
 
 } // 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();
   }
 };
 
 } // namespace internal
 } // namespace emscripten
diff --git a/web/database/_generated/comm_query_executor.wasm b/web/database/_generated/comm_query_executor.wasm
index 24e689928..7bd87ff8f 100755
Binary files a/web/database/_generated/comm_query_executor.wasm and b/web/database/_generated/comm_query_executor.wasm differ
diff --git a/web/database/types/sqlite-query-executor.js b/web/database/types/sqlite-query-executor.js
index 4a76bc798..9358046f6 100644
--- a/web/database/types/sqlite-query-executor.js
+++ b/web/database/types/sqlite-query-executor.js
@@ -1,129 +1,138 @@
 // @flow
 
 import type { ClientDBCommunityInfo } from 'lib/ops/community-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 { ClientDBUserInfo } from 'lib/ops/user-store-ops.js';
 import type { ClientDBDraftInfo } from 'lib/types/draft-types.js';
 
 import {
   type WebClientDBThreadInfo,
   type NullableString,
   type NullableInt,
 } from './entities.js';
 
 type WebMessage = {
   +id: string,
   +localID: NullableString,
   +thread: string,
   +user: string,
   +type: number,
   +futureType: NullableInt,
   +content: NullableString,
   +time: string,
 };
 
 type Media = {
   +id: string,
   +container: string,
   +thread: string,
   +uri: string,
   +type: string,
   +extras: string,
 };
 
 type OlmPersistSession = {
   +targetUserID: string,
   +sessionData: string,
 };
 
+export type ClientMessageToDevice = {
+  +messageID: string,
+  +deviceID: string,
+  +userID: string,
+  +timestamp: string,
+  +plaintext: string,
+  +ciphertext: string,
+};
+
 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<{
     +message: WebMessage,
     +medias: $ReadOnlyArray<Media>,
   }>;
   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(user_info: ClientDBKeyserverInfo): void;
   removeKeyservers(ids: $ReadOnlyArray<string>): void;
   removeAllKeyservers(): void;
   getAllKeyservers(): ClientDBKeyserverInfo[];
 
   replaceCommunity(communityInfo: ClientDBCommunityInfo): void;
   removeCommunities(ids: $ReadOnlyArray<string>): void;
   removeAllCommunities(): void;
   getAllCommunities(): ClientDBCommunityInfo[];
 
   beginTransaction(): void;
   commitTransaction(): void;
   rollbackTransaction(): void;
 
   getOlmPersistAccountDataWeb(): NullableString;
   getOlmPersistSessionsData(): $ReadOnlyArray<OlmPersistSession>;
   storeOlmPersistAccount(accountData: string): void;
   storeOlmPersistSession(session: OlmPersistSession): void;
 
   restoreFromMainCompaction(
     mainCompactionPath: string,
     mainCompactionEncryptionKey: string,
   ): void;
 
   restoreFromBackupLog(backupLog: Uint8Array): void;
 
   // 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;