diff --git a/native/cpp/CommonCpp/CryptoTools/CryptoModule.cpp b/native/cpp/CommonCpp/CryptoTools/CryptoModule.cpp
index c959f2176..eb8f92fc8 100644
--- a/native/cpp/CommonCpp/CryptoTools/CryptoModule.cpp
+++ b/native/cpp/CommonCpp/CryptoTools/CryptoModule.cpp
@@ -1,451 +1,487 @@
 #include "CryptoModule.h"
 #include "Logger.h"
 #include "PlatformSpecificTools.h"
 #include "olm/account.hh"
 #include "olm/session.hh"
 
+#include <ctime>
 #include <stdexcept>
 
 namespace comm {
 namespace crypto {
 
 CryptoModule::CryptoModule(std::string id) : id{id} {
   this->createAccount();
 }
 
 CryptoModule::CryptoModule(
     std::string id,
     std::string secretKey,
     Persist persist)
     : id{id} {
   if (persist.isEmpty()) {
     this->createAccount();
   } else {
     this->restoreFromB64(secretKey, persist);
   }
 }
 
 OlmAccount *CryptoModule::getOlmAccount() {
   return reinterpret_cast<OlmAccount *>(this->accountBuffer.data());
 }
 
 void CryptoModule::createAccount() {
   this->accountBuffer.resize(::olm_account_size());
   ::olm_account(this->accountBuffer.data());
 
   size_t randomSize = ::olm_create_account_random_length(this->getOlmAccount());
   OlmBuffer randomBuffer;
   PlatformSpecificTools::generateSecureRandomBytes(randomBuffer, randomSize);
 
   if (-1 ==
       ::olm_create_account(
           this->getOlmAccount(), randomBuffer.data(), randomSize)) {
     throw std::runtime_error{
         "error createAccount => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   };
 }
 
 void CryptoModule::exposePublicIdentityKeys() {
   size_t identityKeysSize =
       ::olm_account_identity_keys_length(this->getOlmAccount());
   if (this->keys.identityKeys.size() == identityKeysSize) {
     return;
   }
   this->keys.identityKeys.resize(
       ::olm_account_identity_keys_length(this->getOlmAccount()));
   if (-1 ==
       ::olm_account_identity_keys(
           this->getOlmAccount(),
           this->keys.identityKeys.data(),
           this->keys.identityKeys.size())) {
     throw std::runtime_error{
         "error generateIdentityKeys => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
 }
 
 void CryptoModule::generateOneTimeKeys(size_t oneTimeKeysAmount) {
   size_t oneTimeKeysSize = ::olm_account_generate_one_time_keys_random_length(
       this->getOlmAccount(), oneTimeKeysAmount);
   if (this->keys.oneTimeKeys.size() == oneTimeKeysSize) {
     return;
   }
   OlmBuffer random;
   PlatformSpecificTools::generateSecureRandomBytes(random, oneTimeKeysSize);
 
   if (-1 ==
       ::olm_account_generate_one_time_keys(
           this->getOlmAccount(),
           oneTimeKeysAmount,
           random.data(),
           random.size())) {
     throw std::runtime_error{
         "error generateOneTimeKeys => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
 }
 
 // returns number of published keys
 size_t CryptoModule::publishOneTimeKeys() {
   this->keys.oneTimeKeys.resize(
       ::olm_account_one_time_keys_length(this->getOlmAccount()));
   if (-1 ==
       ::olm_account_one_time_keys(
           this->getOlmAccount(),
           this->keys.oneTimeKeys.data(),
           this->keys.oneTimeKeys.size())) {
     throw std::runtime_error{
         "error publishOneTimeKeys => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
   return ::olm_account_mark_keys_as_published(this->getOlmAccount());
 }
 
+bool CryptoModule::prekeyExistsAndOlderThan(uint64_t threshold) {
+  // Our fork of Olm only remembers two prekeys at a time.
+  // If the new one hasn't been published, then the old one is still active.
+  // In that scenario, we need to avoid rotating the prekey because it will
+  // result in the old active prekey being discarded.
+  if (this->getUnpublishedPrekey().has_value()) {
+    return false;
+  }
+
+  uint64_t currentTime = std::time(nullptr);
+  uint64_t lastPrekeyPublishTime =
+      ::olm_account_get_last_prekey_publish_time(this->getOlmAccount());
+
+  return currentTime - lastPrekeyPublishTime >= threshold;
+}
+
 Keys CryptoModule::keysFromStrings(
     const std::string &identityKeys,
     const std::string &oneTimeKeys) {
   return {
       OlmBuffer(identityKeys.begin(), identityKeys.end()),
       OlmBuffer(oneTimeKeys.begin(), oneTimeKeys.end())};
 }
 
 std::string CryptoModule::getIdentityKeys() {
   this->exposePublicIdentityKeys();
   return std::string{
       this->keys.identityKeys.begin(), this->keys.identityKeys.end()};
 }
 
 std::string CryptoModule::getOneTimeKeys(size_t oneTimeKeysAmount) {
   this->generateOneTimeKeys(oneTimeKeysAmount);
   size_t publishedOneTimeKeys = this->publishOneTimeKeys();
   if (publishedOneTimeKeys != oneTimeKeysAmount) {
     throw std::runtime_error{
         "error generateKeys => invalid amount of one-time keys published. "
         "Expected " +
         std::to_string(oneTimeKeysAmount) + ", got " +
         std::to_string(publishedOneTimeKeys)};
   }
 
   return std::string{
       this->keys.oneTimeKeys.begin(), this->keys.oneTimeKeys.end()};
 }
 
 std::uint8_t CryptoModule::getNumPrekeys() {
   return reinterpret_cast<olm::Account *>(this->getOlmAccount())->num_prekeys;
 }
 
 std::string CryptoModule::getPrekey() {
   OlmBuffer prekey;
   prekey.resize(::olm_account_prekey_length(this->getOlmAccount()));
 
   if (-1 ==
       ::olm_account_prekey(
           this->getOlmAccount(), prekey.data(), prekey.size())) {
     throw std::runtime_error{
         "error getPrekey => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
 
   return std::string{std::string{prekey.begin(), prekey.end()}};
 }
 
 std::string CryptoModule::getPrekeySignature() {
   size_t signatureSize = ::olm_account_signature_length(this->getOlmAccount());
 
   OlmBuffer signatureBuffer;
   signatureBuffer.resize(signatureSize);
 
   if (-1 ==
       ::olm_account_prekey_signature(
           this->getOlmAccount(), signatureBuffer.data())) {
     throw std::runtime_error{
         "error getPrekeySignature => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
 
   return std::string{signatureBuffer.begin(), signatureBuffer.end()};
 }
 
-folly::Optional<std::string> CryptoModule::getUnpublishedPrekey() {
+std::optional<std::string> CryptoModule::getUnpublishedPrekey() {
   OlmBuffer prekey;
   prekey.resize(::olm_account_prekey_length(this->getOlmAccount()));
 
   std::size_t retval = ::olm_account_unpublished_prekey(
       this->getOlmAccount(), prekey.data(), prekey.size());
 
   if (0 == retval) {
-    return folly::none;
+    return std::nullopt;
   } else if (-1 == retval) {
     throw std::runtime_error{
         "error getUnpublishedPrekey => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
 
   return std::string{prekey.begin(), prekey.end()};
 }
 
 std::string CryptoModule::generateAndGetPrekey() {
   size_t prekeySize =
       ::olm_account_generate_prekey_random_length(this->getOlmAccount());
 
   OlmBuffer random;
   PlatformSpecificTools::generateSecureRandomBytes(random, prekeySize);
 
   if (-1 ==
       ::olm_account_generate_prekey(
           this->getOlmAccount(), random.data(), random.size())) {
     throw std::runtime_error{
         "error generateAndGetPrekey => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
 
   OlmBuffer prekey;
   prekey.resize(::olm_account_prekey_length(this->getOlmAccount()));
 
   if (-1 ==
       ::olm_account_prekey(
           this->getOlmAccount(), prekey.data(), prekey.size())) {
     throw std::runtime_error{
         "error generateAndGetPrekey => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
 
   return std::string{prekey.begin(), prekey.end()};
 }
 
 void CryptoModule::markPrekeyAsPublished() {
   ::olm_account_mark_prekey_as_published(this->getOlmAccount());
 }
 
 void CryptoModule::forgetOldPrekey() {
   ::olm_account_forget_old_prekey(this->getOlmAccount());
 }
 
 void CryptoModule::initializeInboundForReceivingSession(
     const std::string &targetDeviceId,
     const OlmBuffer &encryptedMessage,
     const OlmBuffer &idKeys,
     const bool overwrite) {
   if (this->hasSessionFor(targetDeviceId)) {
     if (overwrite) {
       this->sessions.erase(this->sessions.find(targetDeviceId));
     } else {
       throw std::runtime_error{
           "error initializeInboundForReceivingSession => session already "
           "initialized"};
     }
   }
   std::unique_ptr<Session> newSession = Session::createSessionAsResponder(
       this->getOlmAccount(),
       this->keys.identityKeys.data(),
       encryptedMessage,
       idKeys);
   this->sessions.insert(make_pair(targetDeviceId, std::move(newSession)));
 }
 
 void CryptoModule::initializeOutboundForSendingSession(
     const std::string &targetDeviceId,
     const OlmBuffer &idKeys,
     const OlmBuffer &preKeys,
     const OlmBuffer &preKeySignature,
     const OlmBuffer &oneTimeKeys,
     size_t keyIndex) {
   if (this->hasSessionFor(targetDeviceId)) {
     Logger::log(
         "olm session overwritten for the device with id: " + targetDeviceId);
     this->sessions.erase(this->sessions.find(targetDeviceId));
   }
   std::unique_ptr<Session> newSession = Session::createSessionAsInitializer(
       this->getOlmAccount(),
       this->keys.identityKeys.data(),
       idKeys,
       preKeys,
       preKeySignature,
       oneTimeKeys,
       keyIndex);
   this->sessions.insert(make_pair(targetDeviceId, std::move(newSession)));
 }
 
 bool CryptoModule::hasSessionFor(const std::string &targetDeviceId) {
   return (this->sessions.find(targetDeviceId) != this->sessions.end());
 }
 
 std::shared_ptr<Session>
 CryptoModule::getSessionByDeviceId(const std::string &deviceId) {
   return this->sessions.at(deviceId);
 }
 
 Persist CryptoModule::storeAsB64(const std::string &secretKey) {
   Persist persist;
   size_t accountPickleLength =
       ::olm_pickle_account_length(this->getOlmAccount());
   OlmBuffer accountPickleBuffer(accountPickleLength);
   if (accountPickleLength !=
       ::olm_pickle_account(
           this->getOlmAccount(),
           secretKey.data(),
           secretKey.size(),
           accountPickleBuffer.data(),
           accountPickleLength)) {
     throw std::runtime_error{
         "error storeAsB64 => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
   persist.account = accountPickleBuffer;
 
   std::unordered_map<std::string, std::shared_ptr<Session>>::iterator it;
   for (it = this->sessions.begin(); it != this->sessions.end(); ++it) {
     OlmBuffer buffer = it->second->storeAsB64(secretKey);
     persist.sessions.insert(make_pair(it->first, buffer));
   }
 
   return persist;
 }
 
 void CryptoModule::restoreFromB64(
     const std::string &secretKey,
     Persist persist) {
   this->accountBuffer.resize(::olm_account_size());
   ::olm_account(this->accountBuffer.data());
   if (-1 ==
       ::olm_unpickle_account(
           this->getOlmAccount(),
           secretKey.data(),
           secretKey.size(),
           persist.account.data(),
           persist.account.size())) {
     throw std::runtime_error{
         "error restoreFromB64 => " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
 
   std::unordered_map<std::string, OlmBuffer>::iterator it;
   for (it = persist.sessions.begin(); it != persist.sessions.end(); ++it) {
     std::unique_ptr<Session> session = session->restoreFromB64(
         this->getOlmAccount(),
         this->keys.identityKeys.data(),
         secretKey,
         it->second);
     this->sessions.insert(make_pair(it->first, move(session)));
   }
 }
 
 EncryptedData CryptoModule::encrypt(
     const std::string &targetDeviceId,
     const std::string &content) {
   if (!this->hasSessionFor(targetDeviceId)) {
     throw std::runtime_error{"error encrypt => uninitialized session"};
   }
   OlmSession *session = this->sessions.at(targetDeviceId)->getOlmSession();
   OlmBuffer encryptedMessage(
       ::olm_encrypt_message_length(session, content.size()));
   OlmBuffer messageRandom;
   PlatformSpecificTools::generateSecureRandomBytes(
       messageRandom, ::olm_encrypt_random_length(session));
   size_t messageType = ::olm_encrypt_message_type(session);
   if (-1 ==
       ::olm_encrypt(
           session,
           (uint8_t *)content.data(),
           content.size(),
           messageRandom.data(),
           messageRandom.size(),
           encryptedMessage.data(),
           encryptedMessage.size())) {
     throw std::runtime_error{
         "error encrypt => " + std::string{::olm_session_last_error(session)}};
   }
   return {encryptedMessage, messageType};
 }
 
 std::string CryptoModule::decrypt(
     const std::string &targetDeviceId,
     EncryptedData &encryptedData) {
   if (!this->hasSessionFor(targetDeviceId)) {
     throw std::runtime_error{"error decrypt => uninitialized session"};
   }
   OlmSession *session = this->sessions.at(targetDeviceId)->getOlmSession();
 
   OlmBuffer utilityBuffer(::olm_utility_size());
   OlmUtility *olmUtility = ::olm_utility(utilityBuffer.data());
 
   OlmBuffer messageHashBuffer(::olm_sha256_length(olmUtility));
   ::olm_sha256(
       olmUtility,
       encryptedData.message.data(),
       encryptedData.message.size(),
       messageHashBuffer.data(),
       messageHashBuffer.size());
 
   OlmBuffer tmpEncryptedMessage(encryptedData.message);
   size_t maxSize = ::olm_decrypt_max_plaintext_length(
       session,
       encryptedData.messageType,
       tmpEncryptedMessage.data(),
       tmpEncryptedMessage.size());
 
   if (maxSize == -1) {
     throw std::runtime_error{
         "error decrypt_max_plaintext_length => " +
         std::string{::olm_session_last_error(session)} + ". Hash: " +
         std::string{messageHashBuffer.begin(), messageHashBuffer.end()}};
   }
 
   OlmBuffer decryptedMessage(maxSize);
   size_t decryptedSize = ::olm_decrypt(
       session,
       encryptedData.messageType,
       encryptedData.message.data(),
       encryptedData.message.size(),
       decryptedMessage.data(),
       decryptedMessage.size());
   if (decryptedSize == -1) {
     throw std::runtime_error{
         "error decrypt => " + std::string{::olm_session_last_error(session)} +
         ". Hash: " +
         std::string{messageHashBuffer.begin(), messageHashBuffer.end()}};
   }
   return std::string{(char *)decryptedMessage.data(), decryptedSize};
 }
 
 std::string CryptoModule::signMessage(const std::string &message) {
   OlmBuffer signature;
   signature.resize(::olm_account_signature_length(this->getOlmAccount()));
   size_t signatureLength = ::olm_account_sign(
       this->getOlmAccount(),
       (uint8_t *)message.data(),
       message.length(),
       signature.data(),
       signature.size());
   if (signatureLength == -1) {
     throw std::runtime_error{
         "olm error: " +
         std::string{::olm_account_last_error(this->getOlmAccount())}};
   }
   return std::string{(char *)signature.data(), signatureLength};
 }
 
 void CryptoModule::verifySignature(
     const std::string &publicKey,
     const std::string &message,
     const std::string &signature) {
   OlmBuffer utilityBuffer;
   utilityBuffer.resize(::olm_utility_size());
   OlmUtility *olmUtility = ::olm_utility(utilityBuffer.data());
   ssize_t verificationResult = ::olm_ed25519_verify(
       olmUtility,
       (uint8_t *)publicKey.data(),
       publicKey.length(),
       (uint8_t *)message.data(),
       message.length(),
       (uint8_t *)signature.data(),
       signature.length());
   if (verificationResult == -1) {
     throw std::runtime_error{
         "olm error: " + std::string{::olm_utility_last_error(olmUtility)}};
   }
 }
 
+std::optional<std::string> CryptoModule::validatePrekey() {
+  static const uint64_t maxPrekeyPublishTime = 10 * 60;
+  static const uint64_t maxOldPrekeyAge = 2 * 60;
+  std::optional<std::string> maybeNewPrekey;
+
+  bool shouldRotatePrekey =
+      this->prekeyExistsAndOlderThan(maxPrekeyPublishTime);
+  if (shouldRotatePrekey) {
+    maybeNewPrekey = this->generateAndGetPrekey();
+  }
+
+  bool shouldForgetPrekey = this->prekeyExistsAndOlderThan(maxOldPrekeyAge);
+  if (shouldForgetPrekey) {
+    this->forgetOldPrekey();
+  }
+
+  return maybeNewPrekey;
+}
+
 } // namespace crypto
 } // namespace comm
diff --git a/native/cpp/CommonCpp/CryptoTools/CryptoModule.h b/native/cpp/CommonCpp/CryptoTools/CryptoModule.h
index 46501da3d..dcc956faf 100644
--- a/native/cpp/CommonCpp/CryptoTools/CryptoModule.h
+++ b/native/cpp/CommonCpp/CryptoTools/CryptoModule.h
@@ -1,88 +1,89 @@
 #pragma once
 
 #include <memory>
 #include <string>
 #include <unordered_map>
 
-#include "folly/Optional.h"
 #include "olm/olm.h"
 
 #include "Persist.h"
 #include "Session.h"
 #include "Tools.h"
 
 namespace comm {
 namespace crypto {
 
 class CryptoModule {
 
   OlmBuffer accountBuffer;
 
   std::unordered_map<std::string, std::shared_ptr<Session>> sessions = {};
 
   Keys keys;
 
   OlmAccount *getOlmAccount();
   void createAccount();
   void exposePublicIdentityKeys();
   void generateOneTimeKeys(size_t oneTimeKeysAmount);
   // returns number of published keys
   size_t publishOneTimeKeys();
+  bool prekeyExistsAndOlderThan(uint64_t threshold);
 
 public:
   const std::string id;
   CryptoModule(std::string id);
   CryptoModule(std::string id, std::string secretKey, Persist persist);
 
   // CryptoModule's accountBuffer cannot be safely copied
   // See explanation in https://phab.comm.dev/D9562
   CryptoModule(const CryptoModule &) = delete;
 
   static Keys keysFromStrings(
       const std::string &identityKeys,
       const std::string &oneTimeKeys);
 
   std::string getIdentityKeys();
   std::string getOneTimeKeys(size_t oneTimeKeysAmount = 50);
 
   // Prekey rotation methods for X3DH
   std::uint8_t getNumPrekeys();
   std::string getPrekey();
   std::string getPrekeySignature();
-  folly::Optional<std::string> getUnpublishedPrekey();
+  std::optional<std::string> getUnpublishedPrekey();
   std::string generateAndGetPrekey();
   void markPrekeyAsPublished();
   void forgetOldPrekey();
 
   void initializeInboundForReceivingSession(
       const std::string &targetDeviceId,
       const OlmBuffer &encryptedMessage,
       const OlmBuffer &idKeys,
       const bool overwrite = true);
   void initializeOutboundForSendingSession(
       const std::string &targetDeviceId,
       const OlmBuffer &idKeys,
       const OlmBuffer &preKeys,
       const OlmBuffer &preKeySignature,
       const OlmBuffer &oneTimeKeys,
       size_t keyIndex = 0);
   bool hasSessionFor(const std::string &targetDeviceId);
   std::shared_ptr<Session> getSessionByDeviceId(const std::string &deviceId);
 
   Persist storeAsB64(const std::string &secretKey);
   void restoreFromB64(const std::string &secretKey, Persist persist);
 
   EncryptedData
   encrypt(const std::string &targetDeviceId, const std::string &content);
   std::string
   decrypt(const std::string &targetDeviceId, EncryptedData &encryptedData);
 
   std::string signMessage(const std::string &message);
   static void verifySignature(
       const std::string &publicKey,
       const std::string &message,
       const std::string &signature);
+  std::optional<std::string> validatePrekey();
 };
 
 } // namespace crypto
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp b/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
index 672751a61..e4eb5ce87 100644
--- a/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
+++ b/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
@@ -1,1307 +1,1379 @@
 #include "CommCoreModule.h"
 #include "../Notifications/BackgroundDataStorage/NotificationsCryptoModule.h"
 #include "BaseDataStore.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 "lib.rs.h"
 #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<std::pair<Message, std::vector<Media>>> messagesVector;
           std::vector<MessageStoreThread> messageStoreThreadsVector;
           std::vector<Report> reportStoreVector;
           std::vector<UserInfo> userStoreVector;
           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();
           } 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<std::pair<Message, std::vector<Media>>>>(
               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));
           this->jsInvoker_->invokeAsync([&innerRt,
                                          draftsVectorPtr,
                                          messagesVectorPtr,
                                          threadsVectorPtr,
                                          messageStoreThreadsVectorPtr,
                                          reportStoreVectorPtr,
                                          userStoreVectorPtr,
                                          error,
                                          promise,
                                          draftStore = this->draftStore,
                                          threadStore = this->threadStore,
                                          messageStore = this->messageStore,
                                          reportStore = this->reportStore,
                                          userStore = this->userStore]() {
             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);
 
             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);
 
             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<std::pair<Message, std::vector<Media>>>>(rt, []() {
     return DatabaseManager::getQueryExecutor().getAllMessages();
   });
   auto messagesVectorPtr =
       std::make_shared<std::vector<std::pair<Message, std::vector<Media>>>>(
           std::move(messagesVector));
   jsi::Array jsiMessages =
       this->messageStore.parseDBDataStore(rt, messagesVectorPtr);
   return jsiMessages;
 }
 
 jsi::Value CommCoreModule::processDraftStoreOperations(
     jsi::Runtime &rt,
     jsi::Array operations) {
   return this->draftStore.processStoreOperations(rt, std::move(operations));
 }
 
 jsi::Value CommCoreModule::processMessageStoreOperations(
     jsi::Runtime &rt,
     jsi::Array operations) {
   return this->messageStore.processStoreOperations(rt, std::move(operations));
 }
 
 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;
 }
 
 jsi::Value CommCoreModule::processThreadStoreOperations(
     jsi::Runtime &rt,
     jsi::Array operations) {
   return this->threadStore.processStoreOperations(rt, std::move(operations));
 }
 
 void CommCoreModule::processThreadStoreOperationsSync(
     jsi::Runtime &rt,
     jsi::Array operations) {
   this->threadStore.processStoreOperationsSync(rt, std::move(operations));
 }
 
 jsi::Value CommCoreModule::processReportStoreOperations(
     jsi::Runtime &rt,
     jsi::Array operations) {
   return this->reportStore.processStoreOperations(rt, std::move(operations));
 }
 
 void CommCoreModule::processReportStoreOperationsSync(
     jsi::Runtime &rt,
     jsi::Array operations) {
   this->reportStore.processStoreOperationsSync(rt, std::move(operations));
 }
 
 jsi::Value CommCoreModule::processUserStoreOperations(
     jsi::Runtime &rt,
     jsi::Array operations) {
   return this->userStore.processStoreOperations(rt, std::move(operations));
 }
 
 void CommCoreModule::terminate(jsi::Runtime &rt) {
   TerminateApp::terminate();
 }
 
 void CommCoreModule::persistCryptoModule() {
   folly::Optional<std::string> storedSecretKey =
       CommSecureStore::get(this->secureStoreAccountDataKey);
   if (!storedSecretKey.hasValue()) {
     storedSecretKey = crypto::Tools::generateRandomString(64);
     CommSecureStore::set(
         this->secureStoreAccountDataKey, storedSecretKey.value());
   }
 
   crypto::Persist newPersist =
       this->cryptoModule->storeAsB64(storedSecretKey.value());
 
   std::promise<void> persistencePromise;
   std::future<void> persistenceFuture = persistencePromise.get_future();
   GlobalDBSingleton::instance.scheduleOrRunCancellable(
       [=, &persistencePromise]() {
         try {
           DatabaseManager::getQueryExecutor().storeOlmPersistData(newPersist);
           persistencePromise.set_value();
         } catch (std::system_error &e) {
           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 persist;
           std::string error;
           try {
             std::optional<std::string> accountData =
                 DatabaseManager::getQueryExecutor().getOlmPersistAccountData();
             if (accountData.has_value()) {
               persist.account =
                   crypto::OlmBuffer(accountData->begin(), accountData->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());
                 persist.sessions.insert(std::make_pair(
                     sessionsDataItem.target_user_id, sessionDataBuffer));
               }
             }
           } catch (std::system_error &e) {
             error = e.what();
           }
 
           this->cryptoThread->scheduleTask([=]() {
             std::string error;
             this->cryptoModule.reset(new crypto::CryptoModule(
                 this->publicCryptoAccountID, storedSecretKey.value(), persist));
             if (persist.isEmpty()) {
               crypto::Persist newPersist =
                   this->cryptoModule->storeAsB64(storedSecretKey.value());
               GlobalDBSingleton::instance.scheduleOrRunCancellable(
                   [=]() {
                     std::string error;
                     try {
                       DatabaseManager::getQueryExecutor().storeOlmPersistData(
                           newPersist);
                     } catch (std::system_error &e) {
                       error = e.what();
                     }
                     this->jsInvoker_->invokeAsync([=]() {
                       if (error.size()) {
                         promise->reject(error);
                         return;
                       }
                     });
                   },
                   promise,
                   this->jsInvoker_);
 
             } else {
               this->cryptoModule->restoreFromB64(
                   storedSecretKey.value(), persist);
               this->jsInvoker_->invokeAsync([=]() {
                 if (error.size()) {
                   promise->reject(error);
                   return;
                 }
               });
             }
             try {
               NotificationsCryptoModule::initializeNotificationsCryptoAccount(
                   "Comm");
             } catch (const std::exception &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::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->cryptoModule == nullptr) {
             error = "user has not been initialized";
           } else {
             primaryKeysResult = this->cryptoModule->getIdentityKeys();
           }
           try {
             if (!error.size()) {
               notificationsKeysResult =
                   NotificationsCryptoModule::getNotificationsIdentityKeys(
                       "Comm");
             }
           } catch (const std::exception &e) {
             error = e.what();
           }
 
           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->cryptoModule->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;
 }
 
 jsi::Value CommCoreModule::getPrimaryOneTimeKeys(
     jsi::Runtime &rt,
     double oneTimeKeysAmount) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string result;
           if (this->cryptoModule == nullptr) {
             error = "user has not been initialized";
           } else {
             result = this->cryptoModule->getOneTimeKeys(oneTimeKeysAmount);
             this->persistCryptoModule();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(parseOLMOneTimeKeys(innerRt, result));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::getNotificationsOneTimeKeys(
     jsi::Runtime &rt,
     double oneTimeKeysAmount) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string result;
           try {
             result = NotificationsCryptoModule::getNotificationsOneTimeKeys(
                 oneTimeKeysAmount, "Comm");
           } catch (const std::exception &e) {
             error = e.what();
           }
           this->jsInvoker_->invokeAsync([=, &innerRt]() {
             if (error.size()) {
               promise->reject(error);
               return;
             }
             promise->resolve(parseOLMOneTimeKeys(innerRt, result));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::generateAndGetPrekeys(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [=, &innerRt]() {
           std::string error;
           std::string contentPrekey, contentPrekeySignature, notifPrekey,
               notifPrekeySignature;
 
           if (this->cryptoModule == nullptr) {
             error = "user has not been initialized";
           } else {
             try {
               contentPrekey = this->cryptoModule->generateAndGetPrekey();
               contentPrekeySignature = this->cryptoModule->getPrekeySignature();
               this->persistCryptoModule();
               notifPrekey =
                   NotificationsCryptoModule::generateAndGetNotificationsPrekey(
                       "Comm");
               notifPrekeySignature =
                   NotificationsCryptoModule::getNotificationsPrekeySignature(
                       "Comm");
             } 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::validateAndUploadPrekeys(jsi::Runtime &rt) {
+  return createPromiseAsJSIValue(
+      rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
+        taskType job = [=, &innerRt]() {
+          std::string error;
+          std::optional<std::string> maybePrekeyToUpload;
+
+          try {
+            maybePrekeyToUpload = this->cryptoModule->validatePrekey();
+            if (maybePrekeyToUpload.has_value()) {
+              this->persistCryptoModule();
+            } else {
+              maybePrekeyToUpload = this->cryptoModule->getUnpublishedPrekey();
+            }
+          } catch (const std::exception &e) {
+            error = e.what();
+          }
+
+          if (error.size()) {
+            this->jsInvoker_->invokeAsync(
+                [=, &innerRt]() { promise->reject(error); });
+            return;
+          } else if (!maybePrekeyToUpload.has_value()) {
+            this->jsInvoker_->invokeAsync(
+                [=]() { promise->resolve(jsi::Value::undefined()); });
+            return;
+          }
+
+          std::string prekeyToUpload = maybePrekeyToUpload.value();
+          std::string prekeyUploadError;
+
+          try {
+            std::string prekeySignature =
+                this->cryptoModule->getPrekeySignature();
+            // TODO: Implement notifs prekey rotation.
+            // Notifications prekey is not rotated at this moment. It
+            // is fetched with signature to match identity service API.
+            std::string notificationsPrekey =
+                NotificationsCryptoModule::getNotificationsPrekey("Comm");
+            std::string notificationsPrekeySignature =
+                NotificationsCryptoModule::getNotificationsPrekeySignature(
+                    "Comm");
+            try {
+              // TODO: upload prekey to identity service
+            } catch (const std::exception &e) {
+              prekeyUploadError = e.what();
+            }
+
+            if (!prekeyUploadError.size()) {
+              this->cryptoModule->markPrekeyAsPublished();
+              this->persistCryptoModule();
+            }
+          } 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::initializeNotificationsSession(
     jsi::Runtime &rt,
     jsi::String identityKeys,
     jsi::String prekey,
     jsi::String prekeySignature,
     jsi::String oneTimeKeys,
     jsi::String keyserverID) {
   auto identityKeysCpp{identityKeys.utf8(rt)};
   auto prekeyCpp{prekey.utf8(rt)};
   auto prekeySignatureCpp{prekeySignature.utf8(rt)};
   auto oneTimeKeysCpp{oneTimeKeys.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::initializeNotificationsSession(
                 identityKeysCpp,
                 prekeyCpp,
                 prekeySignatureCpp,
                 oneTimeKeysCpp,
                 "Comm");
           } 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::initializeContentOutboundSession(
     jsi::Runtime &rt,
     jsi::String identityKeys,
     jsi::String prekey,
     jsi::String prekeySignature,
     jsi::String oneTimeKeys,
     jsi::String deviceID) {
   auto identityKeysCpp{identityKeys.utf8(rt)};
   auto prekeyCpp{prekey.utf8(rt)};
   auto prekeySignatureCpp{prekeySignature.utf8(rt)};
   auto oneTimeKeysCpp{oneTimeKeys.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 initialEncryptedMessage;
           try {
             this->cryptoModule->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()),
                 std::vector<uint8_t>(
                     oneTimeKeysCpp.begin(), oneTimeKeysCpp.end()));
 
             const std::string initMessage = "{\"type\": \"init\"}";
             initialEncryptedMessage =
                 cryptoModule->encrypt(deviceIDCpp, initMessage);
             this->persistCryptoModule();
           } 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{
                     initialEncryptedMessage.message.begin(),
                     initialEncryptedMessage.message.end()}));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::initializeContentInboundSession(
     jsi::Runtime &rt,
     jsi::String identityKeys,
     jsi::String encryptedMessage,
     jsi::String deviceID) {
   auto identityKeysCpp{identityKeys.utf8(rt)};
   auto encryptedMessageCpp{encryptedMessage.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->cryptoModule->initializeInboundForReceivingSession(
                 deviceIDCpp,
                 std::vector<uint8_t>(
                     encryptedMessageCpp.begin(), encryptedMessageCpp.end()),
                 std::vector<uint8_t>(
                     identityKeysCpp.begin(), identityKeysCpp.end()));
             crypto::EncryptedData encryptedData{std::vector<uint8_t>(
                 encryptedMessageCpp.begin(), encryptedMessageCpp.end())};
             decryptedMessage =
                 cryptoModule->decrypt(deviceIDCpp, encryptedData);
             this->persistCryptoModule();
           } 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::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 = cryptoModule->encrypt(deviceIDCpp, messageCpp);
             this->persistCryptoModule();
           } 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{
                     encryptedMessage.message.begin(),
                     encryptedMessage.message.end()}));
           });
         };
         this->cryptoThread->scheduleTask(job);
       });
 }
 
 jsi::Value CommCoreModule::decrypt(
     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;
           std::string decryptedMessage;
           try {
             crypto::EncryptedData encryptedData{
                 std::vector<uint8_t>(messageCpp.begin(), messageCpp.end()),
                 ENCRYPTED_MESSAGE_TYPE};
             decryptedMessage =
                 cryptoModule->decrypt(deviceIDCpp, encryptedData);
             this->persistCryptoModule();
           } 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);
       });
 }
 
 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) {
   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::setCurrentUserID(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().setCurrentUserID(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::getCurrentUserID(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().getCurrentUserID();
           } 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 {
             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) {
         taskType job =
             [this, promise, userIDStr, deviceIDStr, accessTokenStr]() {
               std::string error;
               try {
                 CommSecureStore::set(CommSecureStore::userID, userIDStr);
                 CommSecureStore::set(CommSecureStore::deviceID, deviceIDStr);
                 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());
                 }
               });
             };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::getCommServicesAuthMetadata(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 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));
                 }
               });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 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) {
         taskType job = [this, promise, accessTokenStr]() {
           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());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::clearCommServicesAccessToken(jsi::Runtime &rt) {
   return createPromiseAsJSIValue(
       rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         taskType job = [this, 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());
             }
           });
         };
         GlobalDBSingleton::instance.scheduleOrRunCancellable(
             job, promise, this->jsInvoker_);
       });
 }
 
 jsi::Value CommCoreModule::createNewBackup(
     jsi::Runtime &rt,
     jsi::String backupSecret,
     jsi::String userData) {
   std::string backupSecretStr = backupSecret.utf8(rt);
   std::string userDataStr = userData.utf8(rt);
   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->cryptoModule->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(backupSecretStr),
                 rust::string(pickleKey),
                 rust::string(pickledAccount),
                 rust::string(userDataStr),
                 currentID);
           } else {
             this->jsInvoker_->invokeAsync(
                 [=, &innerRt]() { promise->reject(error); });
           }
         });
       });
 }
 
 jsi::Value
 CommCoreModule::restoreBackup(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});
         ::restoreBackup(rust::string(backupSecretStr), currentID);
       });
 }
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/CommCoreModule.h b/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
index 33cdda5dd..f6076c062 100644
--- a/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
+++ b/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
@@ -1,138 +1,139 @@
 #pragma once
 
 #include "../CryptoTools/CryptoModule.h"
 #include "../Tools/CommSecureStore.h"
 #include "../Tools/WorkerThread.h"
 #include "../_generated/commJSI.h"
 #include "PersistentStorageUtilities/DataStores/DraftStore.h"
 #include "PersistentStorageUtilities/DataStores/MessageStore.h"
 #include "PersistentStorageUtilities/DataStores/ReportStore.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{308};
   std::unique_ptr<WorkerThread> cryptoThread;
 
   const std::string secureStoreAccountDataKey = "cryptoAccountDataKey";
   const std::string publicCryptoAccountID = "publicCryptoAccountID";
   std::unique_ptr<crypto::CryptoModule> cryptoModule;
   DraftStore draftStore;
   ThreadStore threadStore;
   MessageStore messageStore;
   ReportStore reportStore;
   UserStore userStore;
 
   void persistCryptoModule();
 
   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 jsi::Value
   processDraftStoreOperations(jsi::Runtime &rt, jsi::Array operations) override;
   virtual jsi::Value processReportStoreOperations(
       jsi::Runtime &rt,
       jsi::Array operations) override;
   virtual void processReportStoreOperationsSync(
       jsi::Runtime &rt,
       jsi::Array operations) override;
   virtual jsi::Value processMessageStoreOperations(
       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 jsi::Value processThreadStoreOperations(
       jsi::Runtime &rt,
       jsi::Array operations) override;
   virtual void processThreadStoreOperationsSync(
       jsi::Runtime &rt,
       jsi::Array operations) override;
   virtual jsi::Value
   processUserStoreOperations(jsi::Runtime &rt, jsi::Array operations) override;
   virtual jsi::Value initializeCryptoAccount(jsi::Runtime &rt) override;
   virtual jsi::Value getUserPublicKey(jsi::Runtime &rt) override;
   virtual jsi::Value
   getPrimaryOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) override;
   virtual jsi::Value getNotificationsOneTimeKeys(
       jsi::Runtime &rt,
       double oneTimeKeysAmount) override;
   virtual jsi::Value generateAndGetPrekeys(jsi::Runtime &rt) override;
+  virtual jsi::Value validateAndUploadPrekeys(jsi::Runtime &rt) override;
   virtual jsi::Value initializeNotificationsSession(
       jsi::Runtime &rt,
       jsi::String identityKeys,
       jsi::String prekey,
       jsi::String prekeySignature,
       jsi::String oneTimeKeys,
       jsi::String keyserverID) override;
   virtual jsi::Value
   isNotificationsSessionInitialized(jsi::Runtime &rt) override;
   virtual jsi::Value initializeContentOutboundSession(
       jsi::Runtime &rt,
       jsi::String identityKeys,
       jsi::String prekey,
       jsi::String prekeySignature,
       jsi::String oneTimeKeys,
       jsi::String deviceID) override;
   virtual jsi::Value initializeContentInboundSession(
       jsi::Runtime &rt,
       jsi::String identityKeys,
       jsi::String encryptedMessage,
       jsi::String deviceID) override;
   virtual jsi::Value
   encrypt(jsi::Runtime &rt, jsi::String message, jsi::String deviceID) override;
   virtual jsi::Value
   decrypt(jsi::Runtime &rt, jsi::String message, jsi::String deviceID) 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
   setCurrentUserID(jsi::Runtime &rt, jsi::String userID) override;
   virtual jsi::Value getCurrentUserID(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 jsi::Value getCommServicesAuthMetadata(jsi::Runtime &rt) override;
   virtual jsi::Value setCommServicesAccessToken(
       jsi::Runtime &rt,
       jsi::String accessToken) override;
   virtual jsi::Value clearCommServicesAccessToken(jsi::Runtime &rt) override;
   virtual jsi::Value createNewBackup(
       jsi::Runtime &rt,
       jsi::String backupSecret,
       jsi::String userData) override;
   virtual jsi::Value
   restoreBackup(jsi::Runtime &rt, jsi::String backupSecret) override;
 
 public:
   CommCoreModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
 };
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/Notifications/BackgroundDataStorage/NotificationsCryptoModule.cpp b/native/cpp/CommonCpp/Notifications/BackgroundDataStorage/NotificationsCryptoModule.cpp
index d7b746f63..f5b57ae42 100644
--- a/native/cpp/CommonCpp/Notifications/BackgroundDataStorage/NotificationsCryptoModule.cpp
+++ b/native/cpp/CommonCpp/Notifications/BackgroundDataStorage/NotificationsCryptoModule.cpp
@@ -1,344 +1,355 @@
 #include "NotificationsCryptoModule.h"
 #include "../../CryptoTools/Persist.h"
 #include "../../CryptoTools/Tools.h"
 #include "../../Tools/CommSecureStore.h"
 #include "../../Tools/PlatformSpecificTools.h"
 
 #include <fcntl.h>
 #include <folly/String.h>
 #include <folly/dynamic.h>
 #include <folly/json.h>
 #include <unistd.h>
 #include <fstream>
 #include <memory>
 #include <sstream>
 
 namespace comm {
 
 const std::string
     NotificationsCryptoModule::secureStoreNotificationsAccountDataKey =
         "notificationsCryptoAccountDataKey";
 const std::string NotificationsCryptoModule::notificationsCryptoAccountID =
     "notificationsCryptoAccountDataID";
 const std::string NotificationsCryptoModule::keyserverHostedNotificationsID =
     "keyserverHostedNotificationsID";
 const std::string NotificationsCryptoModule::initialEncryptedMessageContent =
     "{\"type\": \"init\"}";
 const int NotificationsCryptoModule::olmEncryptedTypeMessage = 1;
 const int temporaryFilePathRandomSuffixLength = 32;
 
 std::unique_ptr<crypto::CryptoModule>
 NotificationsCryptoModule::deserializeCryptoModule(
     const std::string &path,
     const std::string &picklingKey) {
   std::ifstream pickledPersistStream(path, std::ifstream::in);
   if (!pickledPersistStream.good()) {
     throw std::runtime_error(
         "Attempt to deserialize non-existing notifications crypto account");
   }
   std::stringstream pickledPersistStringStream;
   pickledPersistStringStream << pickledPersistStream.rdbuf();
   pickledPersistStream.close();
   std::string pickledPersist = pickledPersistStringStream.str();
 
   folly::dynamic persistJSON;
   try {
     persistJSON = folly::parseJson(pickledPersist);
   } catch (const folly::json::parse_error &e) {
     throw std::runtime_error(
         "Notifications crypto account JSON deserialization failed with "
         "reason: " +
         std::string(e.what()));
   }
 
   std::string accountString = persistJSON["account"].asString();
   crypto::OlmBuffer account =
       std::vector<uint8_t>(accountString.begin(), accountString.end());
   std::unordered_map<std::string, crypto::OlmBuffer> sessions;
 
   if (persistJSON["sessions"].isNull()) {
     return std::make_unique<crypto::CryptoModule>(
         notificationsCryptoAccountID,
         picklingKey,
         crypto::Persist({account, sessions}));
   }
   for (auto &sessionKeyValuePair : persistJSON["sessions"].items()) {
     std::string targetUserID = sessionKeyValuePair.first.asString();
     std::string sessionData = sessionKeyValuePair.second.asString();
     sessions[targetUserID] =
         std::vector<uint8_t>(sessionData.begin(), sessionData.end());
   }
   return std::make_unique<crypto::CryptoModule>(
       notificationsCryptoAccountID,
       picklingKey,
       crypto::Persist({account, sessions}));
 }
 
 void NotificationsCryptoModule::serializeAndFlushCryptoModule(
     std::unique_ptr<crypto::CryptoModule> cryptoModule,
     const std::string &path,
     const std::string &picklingKey,
     const std::string &callingProcessName) {
   crypto::Persist persist = cryptoModule->storeAsB64(picklingKey);
 
   folly::dynamic sessions = folly::dynamic::object;
   for (auto &sessionKeyValuePair : persist.sessions) {
     std::string targetUserID = sessionKeyValuePair.first;
     crypto::OlmBuffer sessionData = sessionKeyValuePair.second;
     sessions[targetUserID] =
         std::string(sessionData.begin(), sessionData.end());
   }
 
   std::string account =
       std::string(persist.account.begin(), persist.account.end());
   folly::dynamic persistJSON =
       folly::dynamic::object("account", account)("sessions", sessions);
   std::string pickledPersist = folly::toJson(persistJSON);
 
   std::string temporaryFilePathRandomSuffix =
       crypto::Tools::generateRandomHexString(
           temporaryFilePathRandomSuffixLength);
   std::string temporaryPath =
       path + callingProcessName + temporaryFilePathRandomSuffix;
 
   mode_t readWritePermissionsMode = 0666;
   int temporaryFD =
       open(temporaryPath.c_str(), O_CREAT | O_WRONLY, readWritePermissionsMode);
   if (temporaryFD == -1) {
     throw std::runtime_error(
         "Failed to create temporary file. Unable to atomically update "
         "notifications crypto account. Details: " +
         std::string(strerror(errno)));
   }
   ssize_t bytesWritten =
       write(temporaryFD, pickledPersist.c_str(), pickledPersist.length());
   if (bytesWritten == -1 || bytesWritten != pickledPersist.length()) {
     remove(temporaryPath.c_str());
     throw std::runtime_error(
         "Failed to write all data to temporary file. Unable to atomically "
         "update notifications crypto account. Details: " +
         std::string(strerror(errno)));
   }
   if (fsync(temporaryFD) == -1) {
     remove(temporaryPath.c_str());
     throw std::runtime_error(
         "Failed to synchronize temporary file data with hardware storage. "
         "Unable to atomically update notifications crypto account. Details: " +
         std::string(strerror(errno)));
   };
   close(temporaryFD);
   if (rename(temporaryPath.c_str(), path.c_str()) == -1) {
     remove(temporaryPath.c_str());
     throw std::runtime_error(
         "Failed to replace temporary file content with notifications crypto "
         "account. Unable to atomically update notifications crypto account. "
         "Details: " +
         std::string(strerror(errno)));
   }
   remove(temporaryPath.c_str());
 }
 
 std::string NotificationsCryptoModule::getPicklingKey() {
   folly::Optional<std::string> picklingKey = CommSecureStore::get(
       NotificationsCryptoModule::secureStoreNotificationsAccountDataKey);
   if (!picklingKey.hasValue()) {
     throw std::runtime_error(
         "Attempt to retrieve notifications crypto account before it was "
         "correctly initialized.");
   }
   return picklingKey.value();
 }
 
 void NotificationsCryptoModule::callCryptoModule(
     std::function<
         void(const std::unique_ptr<crypto::CryptoModule> &cryptoModule)> caller,
     const std::string &callingProcessName) {
   const std::string picklingKey = NotificationsCryptoModule::getPicklingKey();
   const std::string path =
       PlatformSpecificTools::getNotificationsCryptoAccountPath();
   std::unique_ptr<crypto::CryptoModule> cryptoModule =
       NotificationsCryptoModule::deserializeCryptoModule(path, picklingKey);
   caller(cryptoModule);
   NotificationsCryptoModule::serializeAndFlushCryptoModule(
       std::move(cryptoModule), path, picklingKey, callingProcessName);
 }
 
 void NotificationsCryptoModule::initializeNotificationsCryptoAccount(
     const std::string &callingProcessName) {
   const std::string notificationsCryptoAccountPath =
       PlatformSpecificTools::getNotificationsCryptoAccountPath();
   std::ifstream notificationCryptoAccountCheck(notificationsCryptoAccountPath);
   if (notificationCryptoAccountCheck.good()) {
     // Implemented in CommmCoreModule semantics regarding public olm account
     // initialization is idempotent. We should follow the same approach when it
     // comes to notifications
     notificationCryptoAccountCheck.close();
     return;
   }
   // There is no reason to check if the key is already present since if we are
   // in this place in the code we are about to create new account
   std::string picklingKey = crypto::Tools::generateRandomString(64);
   CommSecureStore::set(
       NotificationsCryptoModule::secureStoreNotificationsAccountDataKey,
       picklingKey);
 
   std::unique_ptr<crypto::CryptoModule> cryptoModule =
       std::make_unique<crypto::CryptoModule>(
           NotificationsCryptoModule::notificationsCryptoAccountID);
   NotificationsCryptoModule::serializeAndFlushCryptoModule(
       std::move(cryptoModule),
       notificationsCryptoAccountPath,
       picklingKey,
       callingProcessName);
 }
 
 std::string NotificationsCryptoModule::getNotificationsIdentityKeys(
     const std::string &callingProcessName) {
   std::string identityKeys;
   auto caller = [&identityKeys](
                     const std::unique_ptr<crypto::CryptoModule> &cryptoModule) {
     identityKeys = cryptoModule->getIdentityKeys();
   };
   NotificationsCryptoModule::callCryptoModule(caller, callingProcessName);
   return identityKeys;
 }
 
+std::string NotificationsCryptoModule::getNotificationsPrekey(
+    const std::string &callingProcessName) {
+  std::string prekey;
+  auto caller =
+      [&prekey](const std::unique_ptr<crypto::CryptoModule> &cryptoModule) {
+        prekey = cryptoModule->getPrekey();
+      };
+  NotificationsCryptoModule::callCryptoModule(caller, callingProcessName);
+  return prekey;
+}
+
 std::string NotificationsCryptoModule::generateAndGetNotificationsPrekey(
     const std::string &callingProcessName) {
   std::string prekey;
   auto caller =
       [&prekey](const std::unique_ptr<crypto::CryptoModule> &cryptoModule) {
         prekey = cryptoModule->generateAndGetPrekey();
       };
   NotificationsCryptoModule::callCryptoModule(caller, callingProcessName);
   return prekey;
 }
 
 std::string NotificationsCryptoModule::getNotificationsPrekeySignature(
     const std::string &callingProcessName) {
   std::string prekeySignature;
   auto caller = [&prekeySignature](
                     const std::unique_ptr<crypto::CryptoModule> &cryptoModule) {
     prekeySignature = cryptoModule->getPrekeySignature();
   };
   NotificationsCryptoModule::callCryptoModule(caller, callingProcessName);
   return prekeySignature;
 }
 
 std::string NotificationsCryptoModule::getNotificationsOneTimeKeys(
     const size_t oneTimeKeysAmount,
     const std::string &callingProcessName) {
   std::string oneTimeKeys;
   auto caller = [&oneTimeKeys, oneTimeKeysAmount](
                     const std::unique_ptr<crypto::CryptoModule> &cryptoModule) {
     oneTimeKeys = cryptoModule->getOneTimeKeys(oneTimeKeysAmount);
   };
   NotificationsCryptoModule::callCryptoModule(caller, callingProcessName);
   return oneTimeKeys;
 }
 
 crypto::EncryptedData NotificationsCryptoModule::initializeNotificationsSession(
     const std::string &identityKeys,
     const std::string &prekey,
     const std::string &prekeySignature,
     const std::string &oneTimeKeys,
     const std::string &callingProcessName) {
   crypto::EncryptedData initialEncryptedMessage;
   auto caller = [&](const std::unique_ptr<crypto::CryptoModule> &cryptoModule) {
     cryptoModule->initializeOutboundForSendingSession(
         NotificationsCryptoModule::keyserverHostedNotificationsID,
         std::vector<uint8_t>(identityKeys.begin(), identityKeys.end()),
         std::vector<uint8_t>(prekey.begin(), prekey.end()),
         std::vector<uint8_t>(prekeySignature.begin(), prekeySignature.end()),
         std::vector<uint8_t>(oneTimeKeys.begin(), oneTimeKeys.end()));
     initialEncryptedMessage = cryptoModule->encrypt(
         NotificationsCryptoModule::keyserverHostedNotificationsID,
         NotificationsCryptoModule::initialEncryptedMessageContent);
   };
   NotificationsCryptoModule::callCryptoModule(caller, callingProcessName);
   return initialEncryptedMessage;
 }
 
 bool NotificationsCryptoModule::isNotificationsSessionInitialized(
     const std::string &callingProcessName) {
   bool sessionInitialized;
   auto caller = [&sessionInitialized](
                     const std::unique_ptr<crypto::CryptoModule> &cryptoModule) {
     sessionInitialized = cryptoModule->hasSessionFor(
         NotificationsCryptoModule::keyserverHostedNotificationsID);
   };
   NotificationsCryptoModule::callCryptoModule(caller, callingProcessName);
   return sessionInitialized;
 }
 
 void NotificationsCryptoModule::clearSensitiveData() {
   std::string notificationsCryptoAccountPath =
       PlatformSpecificTools::getNotificationsCryptoAccountPath();
   if (remove(notificationsCryptoAccountPath.c_str()) == -1 && errno != ENOENT) {
     throw std::runtime_error(
         "Unable to remove notifications crypto account. Security requirements "
         "might be violated.");
   }
 }
 
 std::string NotificationsCryptoModule::decrypt(
     const std::string &data,
     const size_t messageType,
     const std::string &callingProcessName) {
   std::string decryptedData;
   auto caller = [&](const std::unique_ptr<crypto::CryptoModule> &cryptoModule) {
     crypto::EncryptedData encryptedData{
         std::vector<uint8_t>(data.begin(), data.end()), messageType};
     decryptedData = cryptoModule->decrypt(
         NotificationsCryptoModule::keyserverHostedNotificationsID,
         encryptedData);
   };
   NotificationsCryptoModule::callCryptoModule(caller, callingProcessName);
   return decryptedData;
 }
 
 NotificationsCryptoModule::StatefulDecryptResult::StatefulDecryptResult(
     std::unique_ptr<crypto::CryptoModule> cryptoModule,
     std::string decryptedData)
     : cryptoModuleState(std::move(cryptoModule)), decryptedData(decryptedData) {
 }
 
 std::string
 NotificationsCryptoModule::StatefulDecryptResult::getDecryptedData() {
   return this->decryptedData;
 }
 
 std::unique_ptr<NotificationsCryptoModule::StatefulDecryptResult>
 NotificationsCryptoModule::statefulDecrypt(
     const std::string &data,
     const size_t messageType) {
   std::string path = PlatformSpecificTools::getNotificationsCryptoAccountPath();
   std::string picklingKey = NotificationsCryptoModule::getPicklingKey();
 
   std::unique_ptr<crypto::CryptoModule> cryptoModule =
       NotificationsCryptoModule::deserializeCryptoModule(path, picklingKey);
   crypto::EncryptedData encryptedData{
       std::vector<uint8_t>(data.begin(), data.end()), messageType};
   std::string decryptedData = cryptoModule->decrypt(
       NotificationsCryptoModule::keyserverHostedNotificationsID, encryptedData);
   StatefulDecryptResult statefulDecryptResult(
       std::move(cryptoModule), decryptedData);
 
   return std::make_unique<StatefulDecryptResult>(
       std::move(statefulDecryptResult));
 }
 
 void NotificationsCryptoModule::flushState(
     std::unique_ptr<StatefulDecryptResult> statefulDecryptResult,
     const std::string &callingProcessName) {
 
   std::string path = PlatformSpecificTools::getNotificationsCryptoAccountPath();
   std::string picklingKey = NotificationsCryptoModule::getPicklingKey();
 
   NotificationsCryptoModule::serializeAndFlushCryptoModule(
       std::move(statefulDecryptResult->cryptoModuleState),
       path,
       picklingKey,
       callingProcessName);
 }
 } // namespace comm
diff --git a/native/cpp/CommonCpp/Notifications/BackgroundDataStorage/NotificationsCryptoModule.h b/native/cpp/CommonCpp/Notifications/BackgroundDataStorage/NotificationsCryptoModule.h
index 85211a217..9bc331d90 100644
--- a/native/cpp/CommonCpp/Notifications/BackgroundDataStorage/NotificationsCryptoModule.h
+++ b/native/cpp/CommonCpp/Notifications/BackgroundDataStorage/NotificationsCryptoModule.h
@@ -1,73 +1,75 @@
 #pragma once
 
 #include "../../CryptoTools/CryptoModule.h"
 
 #include <string>
 
 namespace comm {
 class NotificationsCryptoModule {
   const static std::string secureStoreNotificationsAccountDataKey;
   const static std::string notificationsCryptoAccountID;
   const static std::string keyserverHostedNotificationsID;
   const static std::string initialEncryptedMessageContent;
 
   static std::string getPicklingKey();
   static void serializeAndFlushCryptoModule(
       std::unique_ptr<crypto::CryptoModule> cryptoModule,
       const std::string &path,
       const std::string &picklingKey,
       const std::string &callingProcessName);
   static std::unique_ptr<crypto::CryptoModule> deserializeCryptoModule(
       const std::string &path,
       const std::string &picklingKey);
   static void callCryptoModule(
       std::function<void(
           const std::unique_ptr<crypto::CryptoModule> &cryptoModule)> caller,
       const std::string &callingProcessName);
 
 public:
   const static int olmEncryptedTypeMessage;
   static void
   initializeNotificationsCryptoAccount(const std::string &callingProcessName);
   static void clearSensitiveData();
   static std::string
   getNotificationsIdentityKeys(const std::string &callingProcessName);
   static std::string
+  getNotificationsPrekey(const std::string &callingProcessName);
+  static std::string
   generateAndGetNotificationsPrekey(const std::string &callingProcessName);
   static std::string
   getNotificationsPrekeySignature(const std::string &callingProcessName);
   static std::string getNotificationsOneTimeKeys(
       const size_t oneTimeKeysAmount,
       const std::string &callingProcessName);
   static crypto::EncryptedData initializeNotificationsSession(
       const std::string &identityKeys,
       const std::string &prekey,
       const std::string &prekeySignature,
       const std::string &oneTimeKeys,
       const std::string &callingProcessName);
   static bool
   isNotificationsSessionInitialized(const std::string &callingProcessName);
   static std::string decrypt(
       const std::string &data,
       const size_t messageType,
       const std::string &callingProcessName);
 
   class StatefulDecryptResult {
     StatefulDecryptResult(
         std::unique_ptr<crypto::CryptoModule> cryptoModule,
         std::string decryptedData);
     std::unique_ptr<crypto::CryptoModule> cryptoModuleState;
     std::string decryptedData;
     friend NotificationsCryptoModule;
 
   public:
     std::string getDecryptedData();
   };
 
   static std::unique_ptr<StatefulDecryptResult>
   statefulDecrypt(const std::string &data, const size_t messageType);
   static void flushState(
       std::unique_ptr<StatefulDecryptResult> statefulDecryptResult,
       const std::string &callingProcessName);
 };
 } // namespace comm
diff --git a/native/cpp/CommonCpp/_generated/commJSI-generated.cpp b/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
index 63b93c248..620b93a8d 100644
--- a/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
+++ b/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
@@ -1,199 +1,203 @@
 /**
  * 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_processDraftStoreOperations(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processDraftStoreOperations(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processMessageStoreOperations(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processMessageStoreOperations(rt, args[0].asObject(rt).asArray(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_processThreadStoreOperations(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processThreadStoreOperations(rt, args[0].asObject(rt).asArray(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processReportStoreOperations(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processReportStoreOperations(rt, args[0].asObject(rt).asArray(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_processUserStoreOperations(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->processUserStoreOperations(rt, args[0].asObject(rt).asArray(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_getPrimaryOneTimeKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getPrimaryOneTimeKeys(rt, args[0].asNumber());
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getNotificationsOneTimeKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getNotificationsOneTimeKeys(rt, args[0].asNumber());
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_generateAndGetPrekeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->generateAndGetPrekeys(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);
+}
 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].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_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].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].asString(rt), args[2].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_decrypt(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->decrypt(rt, args[0].asString(rt), args[1].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_setCurrentUserID(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->setCurrentUserID(rt, args[0].asString(rt));
 }
 static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getCurrentUserID(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getCurrentUserID(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_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_createNewBackup(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->createNewBackup(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));
 }
 
 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_["processDraftStoreOperations"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processDraftStoreOperations};
   methodMap_["processMessageStoreOperations"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processMessageStoreOperations};
   methodMap_["processMessageStoreOperationsSync"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processMessageStoreOperationsSync};
   methodMap_["getAllThreadsSync"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getAllThreadsSync};
   methodMap_["processThreadStoreOperations"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processThreadStoreOperations};
   methodMap_["processReportStoreOperations"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processReportStoreOperations};
   methodMap_["processReportStoreOperationsSync"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processReportStoreOperationsSync};
   methodMap_["processThreadStoreOperationsSync"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processThreadStoreOperationsSync};
   methodMap_["processUserStoreOperations"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_processUserStoreOperations};
   methodMap_["initializeCryptoAccount"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeCryptoAccount};
   methodMap_["getUserPublicKey"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getUserPublicKey};
   methodMap_["getPrimaryOneTimeKeys"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getPrimaryOneTimeKeys};
   methodMap_["getNotificationsOneTimeKeys"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getNotificationsOneTimeKeys};
   methodMap_["generateAndGetPrekeys"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_generateAndGetPrekeys};
+  methodMap_["validateAndUploadPrekeys"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_validateAndUploadPrekeys};
   methodMap_["initializeNotificationsSession"] = MethodMetadata {5, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeNotificationsSession};
   methodMap_["isNotificationsSessionInitialized"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isNotificationsSessionInitialized};
   methodMap_["initializeContentOutboundSession"] = MethodMetadata {5, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeContentOutboundSession};
   methodMap_["initializeContentInboundSession"] = MethodMetadata {3, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeContentInboundSession};
   methodMap_["encrypt"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_encrypt};
   methodMap_["decrypt"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_decrypt};
   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_["setCurrentUserID"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setCurrentUserID};
   methodMap_["getCurrentUserID"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getCurrentUserID};
   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_["setCommServicesAccessToken"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setCommServicesAccessToken};
   methodMap_["clearCommServicesAccessToken"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_clearCommServicesAccessToken};
   methodMap_["createNewBackup"] = MethodMetadata {2, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_createNewBackup};
   methodMap_["restoreBackup"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_restoreBackup};
 }
 
 
 } // namespace react
 } // namespace facebook
diff --git a/native/cpp/CommonCpp/_generated/commJSI.h b/native/cpp/CommonCpp/_generated/commJSI.h
index 8d91db5ae..bb3949e0d 100644
--- a/native/cpp/CommonCpp/_generated/commJSI.h
+++ b/native/cpp/CommonCpp/_generated/commJSI.h
@@ -1,440 +1,449 @@
 /**
  * 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 jsi::Value processDraftStoreOperations(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual jsi::Value processMessageStoreOperations(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual void processMessageStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual jsi::Array getAllThreadsSync(jsi::Runtime &rt) = 0;
   virtual jsi::Value processThreadStoreOperations(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual jsi::Value processReportStoreOperations(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual void processReportStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual void processThreadStoreOperationsSync(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual jsi::Value processUserStoreOperations(jsi::Runtime &rt, jsi::Array operations) = 0;
   virtual jsi::Value initializeCryptoAccount(jsi::Runtime &rt) = 0;
   virtual jsi::Value getUserPublicKey(jsi::Runtime &rt) = 0;
   virtual jsi::Value getPrimaryOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) = 0;
   virtual jsi::Value getNotificationsOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) = 0;
   virtual jsi::Value generateAndGetPrekeys(jsi::Runtime &rt) = 0;
+  virtual jsi::Value validateAndUploadPrekeys(jsi::Runtime &rt) = 0;
   virtual jsi::Value initializeNotificationsSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, jsi::String oneTimeKeys, jsi::String keyserverID) = 0;
   virtual jsi::Value isNotificationsSessionInitialized(jsi::Runtime &rt) = 0;
   virtual jsi::Value initializeContentOutboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, jsi::String oneTimeKeys, jsi::String deviceID) = 0;
   virtual jsi::Value initializeContentInboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String encryptedMessage, jsi::String deviceID) = 0;
   virtual jsi::Value encrypt(jsi::Runtime &rt, jsi::String message, jsi::String deviceID) = 0;
   virtual jsi::Value decrypt(jsi::Runtime &rt, jsi::String message, jsi::String deviceID) = 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 setCurrentUserID(jsi::Runtime &rt, jsi::String userID) = 0;
   virtual jsi::Value getCurrentUserID(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 setCommServicesAccessToken(jsi::Runtime &rt, jsi::String accessToken) = 0;
   virtual jsi::Value clearCommServicesAccessToken(jsi::Runtime &rt) = 0;
   virtual jsi::Value createNewBackup(jsi::Runtime &rt, jsi::String backupSecret, jsi::String userData) = 0;
   virtual jsi::Value restoreBackup(jsi::Runtime &rt, jsi::String backupSecret) = 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_);
     }
     jsi::Value processDraftStoreOperations(jsi::Runtime &rt, jsi::Array operations) override {
       static_assert(
           bridging::getParameterCount(&T::processDraftStoreOperations) == 2,
           "Expected processDraftStoreOperations(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::processDraftStoreOperations, jsInvoker_, instance_, std::move(operations));
     }
     jsi::Value processMessageStoreOperations(jsi::Runtime &rt, jsi::Array operations) override {
       static_assert(
           bridging::getParameterCount(&T::processMessageStoreOperations) == 2,
           "Expected processMessageStoreOperations(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::processMessageStoreOperations, jsInvoker_, instance_, std::move(operations));
     }
     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_);
     }
     jsi::Value processThreadStoreOperations(jsi::Runtime &rt, jsi::Array operations) override {
       static_assert(
           bridging::getParameterCount(&T::processThreadStoreOperations) == 2,
           "Expected processThreadStoreOperations(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::processThreadStoreOperations, jsInvoker_, instance_, std::move(operations));
     }
     jsi::Value processReportStoreOperations(jsi::Runtime &rt, jsi::Array operations) override {
       static_assert(
           bridging::getParameterCount(&T::processReportStoreOperations) == 2,
           "Expected processReportStoreOperations(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::processReportStoreOperations, jsInvoker_, instance_, std::move(operations));
     }
     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 processUserStoreOperations(jsi::Runtime &rt, jsi::Array operations) override {
       static_assert(
           bridging::getParameterCount(&T::processUserStoreOperations) == 2,
           "Expected processUserStoreOperations(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::processUserStoreOperations, 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 getPrimaryOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) override {
       static_assert(
           bridging::getParameterCount(&T::getPrimaryOneTimeKeys) == 2,
           "Expected getPrimaryOneTimeKeys(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getPrimaryOneTimeKeys, jsInvoker_, instance_, std::move(oneTimeKeysAmount));
     }
     jsi::Value getNotificationsOneTimeKeys(jsi::Runtime &rt, double oneTimeKeysAmount) override {
       static_assert(
           bridging::getParameterCount(&T::getNotificationsOneTimeKeys) == 2,
           "Expected getNotificationsOneTimeKeys(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getNotificationsOneTimeKeys, jsInvoker_, instance_, std::move(oneTimeKeysAmount));
     }
     jsi::Value generateAndGetPrekeys(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::generateAndGetPrekeys) == 1,
           "Expected generateAndGetPrekeys(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::generateAndGetPrekeys, jsInvoker_, instance_);
     }
+    jsi::Value validateAndUploadPrekeys(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::validateAndUploadPrekeys) == 1,
+          "Expected validateAndUploadPrekeys(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::validateAndUploadPrekeys, jsInvoker_, instance_);
+    }
     jsi::Value initializeNotificationsSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, jsi::String oneTimeKeys, 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(oneTimeKeys), 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 initializeContentOutboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, jsi::String oneTimeKeys, 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(oneTimeKeys), std::move(deviceID));
     }
     jsi::Value initializeContentInboundSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String encryptedMessage, jsi::String deviceID) override {
       static_assert(
           bridging::getParameterCount(&T::initializeContentInboundSession) == 4,
           "Expected initializeContentInboundSession(...) to have 4 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::initializeContentInboundSession, jsInvoker_, instance_, std::move(identityKeys), std::move(encryptedMessage), 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 decrypt(jsi::Runtime &rt, jsi::String message, 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(message), std::move(deviceID));
     }
     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 setCurrentUserID(jsi::Runtime &rt, jsi::String userID) override {
       static_assert(
           bridging::getParameterCount(&T::setCurrentUserID) == 2,
           "Expected setCurrentUserID(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::setCurrentUserID, jsInvoker_, instance_, std::move(userID));
     }
     jsi::Value getCurrentUserID(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::getCurrentUserID) == 1,
           "Expected getCurrentUserID(...) to have 1 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::getCurrentUserID, 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 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_);
     }
     jsi::Value createNewBackup(jsi::Runtime &rt, jsi::String backupSecret, jsi::String userData) override {
       static_assert(
           bridging::getParameterCount(&T::createNewBackup) == 3,
           "Expected createNewBackup(...) to have 3 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::createNewBackup, jsInvoker_, instance_, std::move(backupSecret), std::move(userData));
     }
     jsi::Value restoreBackup(jsi::Runtime &rt, jsi::String backupSecret) override {
       static_assert(
           bridging::getParameterCount(&T::restoreBackup) == 2,
           "Expected restoreBackup(...) to have 2 parameters");
 
       return bridging::callFromJs<jsi::Value>(
           rt, &T::restoreBackup, jsInvoker_, instance_, std::move(backupSecret));
     }
 
   private:
     T *instance_;
   };
 
   Delegate delegate_;
 };
 
 } // namespace react
 } // namespace facebook
diff --git a/native/schema/CommCoreModuleSchema.js b/native/schema/CommCoreModuleSchema.js
index a3ae1a485..d6a015319 100644
--- a/native/schema/CommCoreModuleSchema.js
+++ b/native/schema/CommCoreModuleSchema.js
@@ -1,139 +1,140 @@
 // @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 { ClientDBUserStoreOperation } from 'lib/ops/user-store-ops';
 import type { OLMOneTimeKeys } from 'lib/types/crypto-types';
 import type { ClientDBDraftStoreOperation } from 'lib/types/draft-types.js';
 import type { ClientDBMessageInfo } from 'lib/types/message-types.js';
 import type { ClientDBStore } from 'lib/types/store-ops-types';
 import type { ClientDBThreadInfo } from 'lib/types/thread-types.js';
 
 type ClientPublicKeys = {
   +primaryIdentityPublicKeys: {
     +ed25519: string,
     +curve25519: string,
   },
   +notificationIdentityPublicKeys: {
     +ed25519: string,
     +curve25519: string,
   },
   +blobPayload: string,
   +signature: string,
 };
 
 type SignedPrekeys = {
   +contentPrekey: string,
   +contentPrekeySignature: string,
   +notifPrekey: string,
   +notifPrekeySignature: string,
 };
 
 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>;
   +processDraftStoreOperations: (
     operations: $ReadOnlyArray<ClientDBDraftStoreOperation>,
   ) => Promise<void>;
   +processMessageStoreOperations: (
     operations: $ReadOnlyArray<ClientDBMessageStoreOperation>,
   ) => Promise<void>;
   +processMessageStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBMessageStoreOperation>,
   ) => void;
   +getAllThreadsSync: () => $ReadOnlyArray<ClientDBThreadInfo>;
   +processThreadStoreOperations: (
     operations: $ReadOnlyArray<ClientDBThreadStoreOperation>,
   ) => Promise<void>;
   +processReportStoreOperations: (
     operations: $ReadOnlyArray<ClientDBReportStoreOperation>,
   ) => Promise<void>;
   +processReportStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBReportStoreOperation>,
   ) => void;
   +processThreadStoreOperationsSync: (
     operations: $ReadOnlyArray<ClientDBThreadStoreOperation>,
   ) => void;
   +processUserStoreOperations: (
     operations: $ReadOnlyArray<ClientDBUserStoreOperation>,
   ) => Promise<void>;
   +initializeCryptoAccount: () => Promise<string>;
   +getUserPublicKey: () => Promise<ClientPublicKeys>;
   +getPrimaryOneTimeKeys: (
     oneTimeKeysAmount: number,
   ) => Promise<OLMOneTimeKeys>;
   +getNotificationsOneTimeKeys: (
     oneTimeKeysAmount: number,
   ) => Promise<OLMOneTimeKeys>;
   +generateAndGetPrekeys: () => Promise<SignedPrekeys>;
+  +validateAndUploadPrekeys: () => Promise<void>;
   +initializeNotificationsSession: (
     identityKeys: string,
     prekey: string,
     prekeySignature: string,
     oneTimeKeys: string,
     keyserverID: string,
   ) => Promise<string>;
   +isNotificationsSessionInitialized: () => Promise<boolean>;
   +initializeContentOutboundSession: (
     identityKeys: string,
     prekey: string,
     prekeySignature: string,
     oneTimeKeys: string,
     deviceID: string,
   ) => Promise<string>;
   +initializeContentInboundSession: (
     identityKeys: string,
     encryptedMessage: string,
     deviceID: string,
   ) => Promise<string>;
   +encrypt: (message: string, deviceID: string) => Promise<string>;
   +decrypt: (message: string, deviceID: string) => Promise<string>;
   +getCodeVersion: () => number;
   +terminate: () => void;
   +setNotifyToken: (token: string) => Promise<void>;
   +clearNotifyToken: () => Promise<void>;
   +setCurrentUserID: (userID: string) => Promise<void>;
   +getCurrentUserID: () => 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>;
   +setCommServicesAccessToken: (accessToken: string) => Promise<void>;
   +clearCommServicesAccessToken: () => Promise<void>;
   +createNewBackup: (backupSecret: string, userData: string) => Promise<void>;
   +restoreBackup: (backupSecret: string) => Promise<string>;
 }
 
 export interface CoreModuleSpec extends Spec {
   +computeBackupKey: (
     password: string,
     backupID: string,
   ) => Promise<ArrayBuffer>;
 }
 
 export default (TurboModuleRegistry.getEnforcing<Spec>(
   'CommTurboModule',
 ): Spec);