No OneTemporary
Actions

Size

76 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp b/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
	index 07d755cdc..5b6332943 100644
	--- a/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
	+++ b/native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp
	@@ -1,934 +1,960 @@
	#include "CommCoreModule.h"
	#include "../CryptoTools/DeviceID.h"
	#include "../Notifications/BackgroundDataStorage/NotificationsCryptoModule.h"
	#include "BaseDataStore.h"
	#include "DatabaseManager.h"
	#include "InternalModules/GlobalDBSingleton.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;
	try {
	draftsVector = DatabaseManager::getQueryExecutor().getAllDrafts();
	messagesVector =
	DatabaseManager::getQueryExecutor().getAllMessages();
	threadsVector = DatabaseManager::getQueryExecutor().getAllThreads();
	messageStoreThreadsVector =
	DatabaseManager::getQueryExecutor().getAllMessageStoreThreads();
	reportStoreVector =
	DatabaseManager::getQueryExecutor().getAllReports();
	} 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));
	this->jsInvoker_->invokeAsync([&innerRt,
	draftsVectorPtr,
	messagesVectorPtr,
	threadsVectorPtr,
	messageStoreThreadsVectorPtr,
	reportStoreVectorPtr,
	error,
	promise,
	draftStore = this->draftStore,
	threadStore = this->threadStore,
	messageStore = this->messageStore,
	reportStore = this->reportStore]() {
	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);

	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);

	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));
	}

	void CommCoreModule::terminate(jsi::Runtime &rt) {
	TerminateApp::terminate();
	}

	jsi::Value CommCoreModule::initializeCryptoAccount(jsi::Runtime &rt) {
	folly::Optional<std::string> storedSecretKey =
	this->secureStore.get(this->secureStoreAccountDataKey);
	if (!storedSecretKey.hasValue()) {
	storedSecretKey = crypto::Tools::generateRandomString(64);
	this->secureStore.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->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();
	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::initializeNotificationsSession(
	jsi::Runtime &rt,
	jsi::String identityKeys,
	jsi::String prekey,
	jsi::String prekeySignature,
	jsi::String oneTimeKeys) {
	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);
	});
	}

	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) {
	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::setDeviceID(jsi::Runtime &rt, jsi::String deviceType) {
	std::string type = deviceType.utf8(rt);
	std::string deviceID;
	std::string deviceIDGenerationError;

	try {
	deviceID = DeviceIDGenerator::generateDeviceID(type);
	} catch (std::invalid_argument &e) {
	deviceIDGenerationError =
	"setDeviceID: incorrect function argument. Must be one of: KEYSERVER, "
	"WEB, MOBILE.";
	}

	return createPromiseAsJSIValue(
	rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	taskType job = [this,
	&innerRt,
	promise,
	deviceIDGenerationError,
	deviceID]() {
	std::string error = deviceIDGenerationError;
	if (!error.size()) {
	try {
	DatabaseManager::getQueryExecutor().setDeviceID(deviceID);
	} catch (const std::exception &e) {
	error = e.what();
	}
	}
	this->jsInvoker_->invokeAsync([&innerRt, promise, error, deviceID]() {
	if (error.size()) {
	promise->reject(error);
	} else {
	promise->resolve(jsi::String::createFromUtf8(innerRt, deviceID));
	}
	});
	};
	GlobalDBSingleton::instance.scheduleOrRunCancellable(
	job, promise, this->jsInvoker_);
	});
	}

	jsi::Value CommCoreModule::getDeviceID(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().getDeviceID();
	} 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,
	[this, &size](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	taskType job = [this, &innerRt, &size, promise]() {
	std::string error;
	std::string randomString;
	try {
	randomString = crypto::Tools::generateRandomString(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);
	});
	}

	} // namespace comm
	diff --git a/native/cpp/CommonCpp/NativeModules/CommCoreModule.h b/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
	index 6a42528a3..7734661f0 100644
	--- a/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
	+++ b/native/cpp/CommonCpp/NativeModules/CommCoreModule.h
	@@ -1,100 +1,103 @@
	#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 <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{258};
	std::unique_ptr<WorkerThread> cryptoThread;

	CommSecureStore secureStore;
	const std::string secureStoreAccountDataKey = "cryptoAccountDataKey";
	const std::string publicCryptoAccountID = "publicCryptoAccountID";
	std::unique_ptr<crypto::CryptoModule> cryptoModule;
	DraftStore draftStore;
	ThreadStore threadStore;
	MessageStore messageStore;
	ReportStore reportStore;

	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 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 initializeNotificationsSession(
	jsi::Runtime &rt,
	jsi::String identityKeys,
	jsi::String prekey,
	jsi::String prekeySignature,
	jsi::String oneTimeKeys) override;
	virtual jsi::Value
	isNotificationsSessionInitialized(jsi::Runtime &rt) 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
	setDeviceID(jsi::Runtime &rt, jsi::String deviceType) override;
	virtual jsi::Value getDeviceID(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;

	public:
	CommCoreModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
	};

	} // namespace comm
	diff --git a/native/cpp/CommonCpp/_generated/commJSI-generated.cpp b/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
	index 575ec41cd..cbab926f2 100644
	--- a/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
	+++ b/native/cpp/CommonCpp/_generated/commJSI-generated.cpp
	@@ -1,159 +1,163 @@
	/**
	* 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_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_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));
	}
	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_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_setDeviceID(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->setDeviceID(rt, args[0].asString(rt));
	}
	static jsi::Value __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getDeviceID(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommCoreModuleSchemaCxxSpecJSI *>(&turboModule)->getDeviceID(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());
	}

	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_["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_["initializeNotificationsSession"] = MethodMetadata {4, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_initializeNotificationsSession};
	methodMap_["isNotificationsSessionInitialized"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_isNotificationsSessionInitialized};
	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_["setDeviceID"] = MethodMetadata {1, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_setDeviceID};
	methodMap_["getDeviceID"] = MethodMetadata {0, __hostFunction_CommCoreModuleSchemaCxxSpecJSI_getDeviceID};
	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};
	}


	} // namespace react
	} // namespace facebook
	diff --git a/native/cpp/CommonCpp/_generated/commJSI.h b/native/cpp/CommonCpp/_generated/commJSI.h
	index 9212c4767..3a77135e1 100644
	--- a/native/cpp/CommonCpp/_generated/commJSI.h
	+++ b/native/cpp/CommonCpp/_generated/commJSI.h
	@@ -1,350 +1,359 @@
	/**
	* 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 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 initializeNotificationsSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, jsi::String oneTimeKeys) = 0;
	virtual jsi::Value isNotificationsSessionInitialized(jsi::Runtime &rt) = 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 setDeviceID(jsi::Runtime &rt, jsi::String deviceType) = 0;
	virtual jsi::Value getDeviceID(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;

	};

	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 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 initializeNotificationsSession(jsi::Runtime &rt, jsi::String identityKeys, jsi::String prekey, jsi::String prekeySignature, jsi::String oneTimeKeys) override {
	static_assert(
	bridging::getParameterCount(&T::initializeNotificationsSession) == 5,
	"Expected initializeNotificationsSession(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::initializeNotificationsSession, jsInvoker_, instance_, std::move(identityKeys), std::move(prekey), std::move(prekeySignature), std::move(oneTimeKeys));
	}
	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_);
	}
	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 setDeviceID(jsi::Runtime &rt, jsi::String deviceType) override {
	static_assert(
	bridging::getParameterCount(&T::setDeviceID) == 2,
	"Expected setDeviceID(...) to have 2 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::setDeviceID, jsInvoker_, instance_, std::move(deviceType));
	}
	jsi::Value getDeviceID(jsi::Runtime &rt) override {
	static_assert(
	bridging::getParameterCount(&T::getDeviceID) == 1,
	"Expected getDeviceID(...) to have 1 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::getDeviceID, 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));
	}

	private:
	T *instance_;
	};

	Delegate delegate_;
	};

	} // namespace react
	} // namespace facebook
	diff --git a/native/schema/CommCoreModuleSchema.js b/native/schema/CommCoreModuleSchema.js
	index 37bae950d..17dd836d3 100644
	--- a/native/schema/CommCoreModuleSchema.js
	+++ b/native/schema/CommCoreModuleSchema.js
	@@ -1,103 +1,106 @@
	// @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 { 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,
	};

	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;
	+initializeCryptoAccount: () => Promise<string>;
	+getUserPublicKey: () => Promise<ClientPublicKeys>;
	+getPrimaryOneTimeKeys: (
	oneTimeKeysAmount: number,
	) => Promise<OLMOneTimeKeys>;
	+ +getNotificationsOneTimeKeys: (
	+ oneTimeKeysAmount: number,
	+ ) => Promise<OLMOneTimeKeys>;
	+generateAndGetPrekeys: () => Promise<SignedPrekeys>;
	+initializeNotificationsSession: (
	identityKeys: string,
	prekey: string,
	prekeySignature: string,
	oneTimeKeys: string,
	) => Promise<string>;
	+isNotificationsSessionInitialized: () => Promise<boolean>;
	+getCodeVersion: () => number;
	+terminate: () => void;
	+setNotifyToken: (token: string) => Promise<void>;
	+clearNotifyToken: () => Promise<void>;
	+setCurrentUserID: (userID: string) => Promise<void>;
	+getCurrentUserID: () => Promise<string>;
	+setDeviceID: (deviceType: string) => Promise<string>;
	+getDeviceID: () => Promise<string>;
	+clearSensitiveData: () => Promise<void>;
	+checkIfDatabaseNeedsDeletion: () => boolean;
	+reportDBOperationsFailure: () => void;
	+computeBackupKey: (password: string, backupID: string) => Promise<Object>;
	+generateRandomString: (size: number) => Promise<string>;
	}

	export interface CoreModuleSpec extends Spec {
	+computeBackupKey: (
	password: string,
	backupID: string,
	) => Promise<ArrayBuffer>;
	}

	export default (TurboModuleRegistry.getEnforcing<Spec>(
	'CommTurboModule',
	): Spec);

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 2:00 AM (22 h, 48 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2559352
Default Alt Text: (76 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions