No OneTemporary
Actions

Size

149 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp b/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
	index aacf8d62f..63aa5183a 100644
	--- a/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
	+++ b/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
	@@ -1,1077 +1,1089 @@
	#include "CommRustModule.h"
	#include "InternalModules/RustPromiseManager.h"
	#include "JSIRust.h"
	#include "lib.rs.h"

	#include <ReactCommon/TurboModuleUtils.h>

	namespace comm {

	using namespace facebook::react;

	CommRustModule::CommRustModule(std::shared_ptr<CallInvoker> jsInvoker)
	: CommRustModuleSchemaCxxSpecJSI(jsInvoker) {
	}

	jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
	return createPromiseAsJSIValue(
	rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityGenerateNonce(currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::registerPasswordUser(
	jsi::Runtime &rt,
	jsi::String username,
	jsi::String password,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys,
	jsi::String farcasterID,
	jsi::String initialDeviceList) {
	auto usernameRust = jsiStringToRustString(username, rt);
	auto passwordRust = jsiStringToRustString(password, rt);
	auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
	auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
	auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
	auto contentPrekeySignatureRust =
	jsiStringToRustString(contentPrekeySignature, rt);
	auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
	auto notifPrekeySignatureRust =
	jsiStringToRustString(notifPrekeySignature, rt);
	auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
	auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
	auto farcasterIDRust = jsiStringToRustString(farcasterID, rt);
	auto initialDeviceListRust = jsiStringToRustString(initialDeviceList, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityRegisterPasswordUser(
	usernameRust,
	passwordRust,
	keyPayloadRust,
	keyPayloadSignatureRust,
	contentPrekeyRust,
	contentPrekeySignatureRust,
	notifPrekeyRust,
	notifPrekeySignatureRust,
	contentOneTimeKeysRust,
	notifOneTimeKeysRust,
	farcasterIDRust,
	initialDeviceListRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::registerReservedPasswordUser(
	jsi::Runtime &rt,
	jsi::String username,
	jsi::String password,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys,
	jsi::String keyserverMessage,
	jsi::String keyserverSignature,
	jsi::String initialDeviceList) {
	auto usernameRust = jsiStringToRustString(username, rt);
	auto passwordRust = jsiStringToRustString(password, rt);
	auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
	auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
	auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
	auto contentPrekeySignatureRust =
	jsiStringToRustString(contentPrekeySignature, rt);
	auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
	auto notifPrekeySignatureRust =
	jsiStringToRustString(notifPrekeySignature, rt);
	auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
	auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
	auto keyserverMessageRust = jsiStringToRustString(keyserverMessage, rt);
	auto keyserverSignatureRust = jsiStringToRustString(keyserverSignature, rt);
	auto initialDeviceListRust = jsiStringToRustString(initialDeviceList, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityRegisterReservedPasswordUser(
	usernameRust,
	passwordRust,
	keyPayloadRust,
	keyPayloadSignatureRust,
	contentPrekeyRust,
	contentPrekeySignatureRust,
	notifPrekeyRust,
	notifPrekeySignatureRust,
	contentOneTimeKeysRust,
	notifOneTimeKeysRust,
	keyserverMessageRust,
	keyserverSignatureRust,
	initialDeviceListRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::logInPasswordUser(
	jsi::Runtime &rt,
	jsi::String username,
	jsi::String password,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	- jsi::String notifPrekeySignature) {
	+ jsi::String notifPrekeySignature,
	+ jsi::Array contentOneTimeKeys,
	+ jsi::Array notifOneTimeKeys) {
	auto usernameRust = jsiStringToRustString(username, rt);
	auto passwordRust = jsiStringToRustString(password, rt);
	auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
	auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
	auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
	auto contentPrekeySignatureRust =
	jsiStringToRustString(contentPrekeySignature, rt);
	auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
	auto notifPrekeySignatureRust =
	jsiStringToRustString(notifPrekeySignature, rt);
	+ auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
	+ auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityLogInPasswordUser(
	usernameRust,
	passwordRust,
	keyPayloadRust,
	keyPayloadSignatureRust,
	contentPrekeyRust,
	contentPrekeySignatureRust,
	notifPrekeyRust,
	notifPrekeySignatureRust,
	+ contentOneTimeKeysRust,
	+ notifOneTimeKeysRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::registerWalletUser(
	jsi::Runtime &rt,
	jsi::String siweMessage,
	jsi::String siweSignature,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys,
	jsi::String farcasterID,
	jsi::String initialDeviceList) {
	auto siweMessageRust = jsiStringToRustString(siweMessage, rt);
	auto siweSignatureRust = jsiStringToRustString(siweSignature, rt);
	auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
	auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
	auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
	auto contentPrekeySignatureRust =
	jsiStringToRustString(contentPrekeySignature, rt);
	auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
	auto notifPrekeySignatureRust =
	jsiStringToRustString(notifPrekeySignature, rt);
	auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
	auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
	auto farcasterIDRust = jsiStringToRustString(farcasterID, rt);
	auto initialDeviceListRust = jsiStringToRustString(initialDeviceList, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityRegisterWalletUser(
	siweMessageRust,
	siweSignatureRust,
	keyPayloadRust,
	keyPayloadSignatureRust,
	contentPrekeyRust,
	contentPrekeySignatureRust,
	notifPrekeyRust,
	notifPrekeySignatureRust,
	contentOneTimeKeysRust,
	notifOneTimeKeysRust,
	farcasterIDRust,
	initialDeviceListRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::logInWalletUser(
	jsi::Runtime &rt,
	jsi::String siweMessage,
	jsi::String siweSignature,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	- jsi::String notifPrekeySignature) {
	+ jsi::String notifPrekeySignature,
	+ jsi::Array contentOneTimeKeys,
	+ jsi::Array notifOneTimeKeys) {
	auto siweMessageRust = jsiStringToRustString(siweMessage, rt);
	auto siweSignatureRust = jsiStringToRustString(siweSignature, rt);
	auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
	auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
	auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
	auto contentPrekeySignatureRust =
	jsiStringToRustString(contentPrekeySignature, rt);
	auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
	auto notifPrekeySignatureRust =
	jsiStringToRustString(notifPrekeySignature, rt);
	+ auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
	+ auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityLogInWalletUser(
	siweMessageRust,
	siweSignatureRust,
	keyPayloadRust,
	keyPayloadSignatureRust,
	contentPrekeyRust,
	contentPrekeySignatureRust,
	notifPrekeyRust,
	notifPrekeySignatureRust,
	+ contentOneTimeKeysRust,
	+ notifOneTimeKeysRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::restoreUser(
	jsi::Runtime &rt,
	jsi::String userID,
	std::optional<jsi::String> siweMessage,
	std::optional<jsi::String> siweSignature,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys,
	jsi::String deviceList) {
	rust::String siweMessageRust = "";
	if (siweMessage.has_value()) {
	siweMessageRust = jsiStringToRustString(siweMessage.value(), rt);
	}
	rust::String siweSignatureRust = "";
	if (siweSignature.has_value()) {
	siweSignatureRust = jsiStringToRustString(siweSignature.value(), rt);
	}
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
	auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
	auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
	auto contentPrekeySignatureRust =
	jsiStringToRustString(contentPrekeySignature, rt);
	auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
	auto notifPrekeySignatureRust =
	jsiStringToRustString(notifPrekeySignature, rt);
	auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
	auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
	auto deviceListRust = jsiStringToRustString(deviceList, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityRestoreUser(
	userIDRust,
	siweMessageRust,
	siweSignatureRust,
	keyPayloadRust,
	keyPayloadSignatureRust,
	contentPrekeyRust,
	contentPrekeySignatureRust,
	notifPrekeyRust,
	notifPrekeySignatureRust,
	contentOneTimeKeysRust,
	notifOneTimeKeysRust,
	deviceListRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::updatePassword(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken,
	jsi::String oldPassword,
	jsi::String newPassword) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto accessTokenRust = jsiStringToRustString(accessToken, rt);
	auto oldPasswordRust = jsiStringToRustString(oldPassword, rt);
	auto newPasswordRust = jsiStringToRustString(newPassword, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityUpdateUserPassword(
	userIDRust,
	deviceIDRust,
	accessTokenRust,
	oldPasswordRust,
	newPasswordRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::deletePasswordUser(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken,
	jsi::String password) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto accessTokenRust = jsiStringToRustString(accessToken, rt);
	auto passwordRust = jsiStringToRustString(password, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityDeletePasswordUser(
	userIDRust,
	deviceIDRust,
	accessTokenRust,
	passwordRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::deleteWalletUser(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto accessTokenRust = jsiStringToRustString(accessToken, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityDeleteWalletUser(
	userIDRust, deviceIDRust, accessTokenRust, currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::logOut(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto accessTokenRust = jsiStringToRustString(accessToken, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityLogOut(userIDRust, deviceIDRust, accessTokenRust, currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::logOutPrimaryDevice(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken,
	jsi::String signedDeviceList) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto accessTokenRust = jsiStringToRustString(accessToken, rt);
	auto deviceListRust = jsiStringToRustString(signedDeviceList, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityLogOutPrimaryDevice(
	userIDRust,
	deviceIDRust,
	accessTokenRust,
	deviceListRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::logOutSecondaryDevice(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto accessTokenRust = jsiStringToRustString(accessToken, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityLogOutSecondaryDevice(
	userIDRust, deviceIDRust, accessTokenRust, currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::getOutboundKeysForUser(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String userID) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	auto userIDRust = jsiStringToRustString(userID, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityGetOutboundKeysForUser(
	authUserIDRust,
	authDeviceIDRust,
	authAccessTokenRust,
	userIDRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::getInboundKeysForUser(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String userID) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	auto userIDRust = jsiStringToRustString(userID, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityGetInboundKeysForUser(
	authUserIDRust,
	authDeviceIDRust,
	authAccessTokenRust,
	userIDRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityVersionSupported(currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::uploadOneTimeKeys(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::Array contentOneTimePreKeys,
	jsi::Array notifOneTimePreKeys) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	auto contentOneTimePreKeysRust =
	jsiStringArrayToRustVec(contentOneTimePreKeys, rt);
	auto notifOneTimePreKeysRust =
	jsiStringArrayToRustVec(notifOneTimePreKeys, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityUploadOneTimeKeys(
	authUserIDRust,
	authDeviceIDRust,
	authAccessTokenRust,
	contentOneTimePreKeysRust,
	notifOneTimePreKeysRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::getKeyserverKeys(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String keyserverID) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityGetKeyserverKeys(
	authUserIDRust,
	authDeviceIDRust,
	authAccessTokenRust,
	keyserverIDRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::getDeviceListForUser(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String userID,
	std::optional<double> sinceTimestamp) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	auto userIDRust = jsiStringToRustString(userID, rt);

	auto timestampI64 = static_cast<int64_t>(sinceTimestamp.value_or(0));
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityGetDeviceListForUser(
	authUserIDRust,
	authDeviceIDRust,
	authAccessTokenRust,
	userIDRust,
	timestampI64,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::getDeviceListsForUsers(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::Array userIDs) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	auto userIDsRust = jsiStringArrayToRustVec(userIDs, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityGetDeviceListsForUsers(
	authUserIDRust,
	authDeviceIDRust,
	authAccessTokenRust,
	userIDsRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::updateDeviceList(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String updatePayload) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	auto updatePayloadRust = jsiStringToRustString(updatePayload, rt);
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityUpdateDeviceList(
	authUserIDRust,
	authDeviceIDRust,
	authAccessTokenRust,
	updatePayloadRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::syncPlatformDetails(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identitySyncPlatformDetails(
	authUserIDRust, authDeviceIDRust, authAccessTokenRust, currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::uploadSecondaryDeviceKeysAndLogIn(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String nonce,
	jsi::String nonceSignature,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto nonceRust = jsiStringToRustString(nonce, rt);
	auto nonceSignatureRust = jsiStringToRustString(nonceSignature, rt);
	auto keyPayloadRust = jsiStringToRustString(keyPayload, rt);
	auto keyPayloadSignatureRust = jsiStringToRustString(keyPayloadSignature, rt);
	auto contentPrekeyRust = jsiStringToRustString(contentPrekey, rt);
	auto contentPrekeySignatureRust =
	jsiStringToRustString(contentPrekeySignature, rt);
	auto notifPrekeyRust = jsiStringToRustString(notifPrekey, rt);
	auto notifPrekeySignatureRust =
	jsiStringToRustString(notifPrekeySignature, rt);
	auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
	auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityUploadSecondaryDeviceKeysAndLogIn(
	userIDRust,
	nonceRust,
	nonceSignatureRust,
	keyPayloadRust,
	keyPayloadSignatureRust,
	contentPrekeyRust,
	contentPrekeySignatureRust,
	notifPrekeyRust,
	notifPrekeySignatureRust,
	contentOneTimeKeysRust,
	notifOneTimeKeysRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::logInExistingDevice(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String nonce,
	jsi::String nonceSignature) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto nonceRust = jsiStringToRustString(nonce, rt);
	auto nonceSignatureRust = jsiStringToRustString(nonceSignature, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityLogInExistingDevice(
	userIDRust,
	deviceIDRust,
	nonceRust,
	nonceSignatureRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::findUserIDForWalletAddress(
	jsi::Runtime &rt,
	jsi::String walletAddress) {
	auto walletAddressRust = jsiStringToRustString(walletAddress, rt);
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityFindUserIDForWalletAddress(walletAddressRust, currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value
	CommRustModule::findUserIDForUsername(jsi::Runtime &rt, jsi::String username) {
	auto usernameRust = jsiStringToRustString(username, rt);
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityFindUserIDForUsername(usernameRust, currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value
	CommRustModule::getFarcasterUsers(jsi::Runtime &rt, jsi::Array farcasterIDs) {
	auto farcasterIDsRust = jsiStringArrayToRustVec(farcasterIDs, rt);
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityGetFarcasterUsers(farcasterIDsRust, currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::linkFarcasterAccount(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken,
	jsi::String farcasterID) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto accessTokenRust = jsiStringToRustString(accessToken, rt);
	auto farcasterIDRust = jsiStringToRustString(farcasterID, rt);
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityLinkFarcasterAccount(
	userIDRust,
	deviceIDRust,
	accessTokenRust,
	farcasterIDRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::unlinkFarcasterAccount(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken) {
	auto userIDRust = jsiStringToRustString(userID, rt);
	auto deviceIDRust = jsiStringToRustString(deviceID, rt);
	auto accessTokenRust = jsiStringToRustString(accessToken, rt);
	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityUnlinkFarcasterAccount(
	userIDRust, deviceIDRust, accessTokenRust, currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	jsi::Value CommRustModule::findUserIdentities(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::Array userIDs) {
	auto authUserIDRust = jsiStringToRustString(authUserID, rt);
	auto authDeviceIDRust = jsiStringToRustString(authDeviceID, rt);
	auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
	auto userIDsRust = jsiStringArrayToRustVec(userIDs, rt);

	return createPromiseAsJSIValue(
	rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
	std::string error;
	try {
	auto currentID = RustPromiseManager::instance.addPromise(
	{promise, this->jsInvoker_, innerRt});
	identityFindUserIdentities(
	authUserIDRust,
	authDeviceIDRust,
	authAccessTokenRust,
	userIDsRust,
	currentID);
	} catch (const std::exception &e) {
	error = e.what();
	};
	if (!error.empty()) {
	this->jsInvoker_->invokeAsync(
	[error, promise]() { promise->reject(error); });
	}
	});
	}

	} // namespace comm
	diff --git a/native/cpp/CommonCpp/NativeModules/CommRustModule.h b/native/cpp/CommonCpp/NativeModules/CommRustModule.h
	index 3bc6e20ea..9380d3ad8 100644
	--- a/native/cpp/CommonCpp/NativeModules/CommRustModule.h
	+++ b/native/cpp/CommonCpp/NativeModules/CommRustModule.h
	@@ -1,224 +1,228 @@
	#pragma once

	#include "../_generated/rustJSI.h"

	#include <ReactCommon/TurboModuleUtils.h>
	#include <jsi/jsi.h>
	#include <memory>

	namespace comm {

	namespace jsi = facebook::jsi;

	class CommRustModule : public facebook::react::CommRustModuleSchemaCxxSpecJSI {
	virtual jsi::Value generateNonce(jsi::Runtime &rt) override;
	virtual jsi::Value registerPasswordUser(
	jsi::Runtime &rt,
	jsi::String username,
	jsi::String password,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys,
	jsi::String farcasterID,
	jsi::String initialDeviceList) override;
	virtual jsi::Value registerReservedPasswordUser(
	jsi::Runtime &rt,
	jsi::String username,
	jsi::String password,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys,
	jsi::String keyserverMessage,
	jsi::String keyserverSignature,
	jsi::String initialDeviceList) override;
	virtual jsi::Value logInPasswordUser(
	jsi::Runtime &rt,
	jsi::String username,
	jsi::String password,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	- jsi::String notifPrekeySignature) override;
	+ jsi::String notifPrekeySignature,
	+ jsi::Array contentOneTimeKeys,
	+ jsi::Array notifOneTimeKeys) override;
	virtual jsi::Value registerWalletUser(
	jsi::Runtime &rt,
	jsi::String siweMessage,
	jsi::String siweSignature,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys,
	jsi::String farcasterID,
	jsi::String initialDeviceList) override;
	virtual jsi::Value logInWalletUser(
	jsi::Runtime &rt,
	jsi::String siweMessage,
	jsi::String siweSignature,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	- jsi::String notifPrekeySignature) override;
	+ jsi::String notifPrekeySignature,
	+ jsi::Array contentOneTimeKeys,
	+ jsi::Array notifOneTimeKeys) override;
	virtual jsi::Value restoreUser(
	jsi::Runtime &rt,
	jsi::String userID,
	std::optional<jsi::String> siweMessage,
	std::optional<jsi::String> siweSignature,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys,
	jsi::String deviceList) override;
	virtual jsi::Value updatePassword(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken,
	jsi::String oldPassword,
	jsi::String newPassword) override;
	virtual jsi::Value deletePasswordUser(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken,
	jsi::String password) override;
	virtual jsi::Value deleteWalletUser(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken) override;
	virtual jsi::Value logOut(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken) override;
	virtual jsi::Value logOutPrimaryDevice(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken,
	jsi::String signedDeviceList) override;
	virtual jsi::Value logOutSecondaryDevice(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken) override;
	virtual jsi::Value getOutboundKeysForUser(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String userID) override;
	virtual jsi::Value getInboundKeysForUser(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String userID) override;
	virtual jsi::Value versionSupported(jsi::Runtime &rt) override;
	virtual jsi::Value uploadOneTimeKeys(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::Array contentOneTimePreKeys,
	jsi::Array notifOneTimePreKeys) override;
	virtual jsi::Value getKeyserverKeys(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String keyserverID) override;
	virtual jsi::Value getDeviceListForUser(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String userID,
	std::optional<double> sinceTimestamp) override;
	virtual jsi::Value getDeviceListsForUsers(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::Array userIDs) override;
	virtual jsi::Value updateDeviceList(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::String updatePayload) override;
	virtual jsi::Value syncPlatformDetails(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken) override;
	virtual jsi::Value uploadSecondaryDeviceKeysAndLogIn(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String nonce,
	jsi::String nonceSignature,
	jsi::String keyPayload,
	jsi::String keyPayloadSignature,
	jsi::String contentPrekey,
	jsi::String contentPrekeySignature,
	jsi::String notifPrekey,
	jsi::String notifPrekeySignature,
	jsi::Array contentOneTimeKeys,
	jsi::Array notifOneTimeKeys) override;
	virtual jsi::Value logInExistingDevice(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String nonce,
	jsi::String nonceSignature) override;
	virtual jsi::Value findUserIDForWalletAddress(
	jsi::Runtime &rt,
	jsi::String walletAddress) override;
	virtual jsi::Value
	findUserIDForUsername(jsi::Runtime &rt, jsi::String username) override;
	virtual jsi::Value
	getFarcasterUsers(jsi::Runtime &rt, jsi::Array farcasterIDs) override;
	virtual jsi::Value linkFarcasterAccount(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken,
	jsi::String farcasterID) override;
	virtual jsi::Value unlinkFarcasterAccount(
	jsi::Runtime &rt,
	jsi::String userID,
	jsi::String deviceID,
	jsi::String accessToken) override;
	virtual jsi::Value findUserIdentities(
	jsi::Runtime &rt,
	jsi::String authUserID,
	jsi::String authDeviceID,
	jsi::String authAccessToken,
	jsi::Array userIDs) override;

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

	} // namespace comm
	diff --git a/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp b/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
	index c91966313..c509d7af8 100644
	--- a/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
	+++ b/native/cpp/CommonCpp/_generated/rustJSI-generated.cpp
	@@ -1,142 +1,142 @@
	/**
	* 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 "rustJSI.h"

	namespace facebook {
	namespace react {

	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_generateNonce(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->generateNonce(rt);
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerPasswordUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->registerPasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt), args[10].asString(rt), args[11].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerReservedPasswordUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->registerReservedPasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt), args[10].asString(rt), args[11].asString(rt), args[12].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInPasswordUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	- return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInPasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt));
	+ return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInPasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerWalletUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->registerWalletUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt), args[10].asString(rt), args[11].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInWalletUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	- return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInWalletUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt));
	+ return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInWalletUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asObject(rt).asArray(rt), args[9].asObject(rt).asArray(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_restoreUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->restoreUser(rt, args[0].asString(rt), args[1].isNull() \|\| args[1].isUndefined() ? std::nullopt : std::make_optional(args[1].asString(rt)), args[2].isNull() \|\| args[2].isUndefined() ? std::nullopt : std::make_optional(args[2].asString(rt)), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asString(rt), args[9].asObject(rt).asArray(rt), args[10].asObject(rt).asArray(rt), args[11].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_updatePassword(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->updatePassword(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_CommRustModuleSchemaCxxSpecJSI_deletePasswordUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->deletePasswordUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_deleteWalletUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->deleteWalletUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logOut(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logOut(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logOutPrimaryDevice(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logOutPrimaryDevice(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logOutSecondaryDevice(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logOutSecondaryDevice(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getOutboundKeysForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getOutboundKeysForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getInboundKeysForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getInboundKeysForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_versionSupported(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->versionSupported(rt);
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadOneTimeKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->uploadOneTimeKeys(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asObject(rt).asArray(rt), args[4].asObject(rt).asArray(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getKeyserverKeys(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getKeyserverKeys(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getDeviceListForUser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getDeviceListForUser(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].isNull() \|\| args[4].isUndefined() ? std::nullopt : std::make_optional(args[4].asNumber()));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getDeviceListsForUsers(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getDeviceListsForUsers(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asObject(rt).asArray(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_updateDeviceList(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->updateDeviceList(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_syncPlatformDetails(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->syncPlatformDetails(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->uploadSecondaryDeviceKeysAndLogIn(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt), args[4].asString(rt), args[5].asString(rt), args[6].asString(rt), args[7].asString(rt), args[8].asString(rt), args[9].asObject(rt).asArray(rt), args[10].asObject(rt).asArray(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInExistingDevice(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->logInExistingDevice(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIDForWalletAddress(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->findUserIDForWalletAddress(rt, args[0].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIDForUsername(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->findUserIDForUsername(rt, args[0].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_getFarcasterUsers(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->getFarcasterUsers(rt, args[0].asObject(rt).asArray(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_linkFarcasterAccount(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->linkFarcasterAccount(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_unlinkFarcasterAccount(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->unlinkFarcasterAccount(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt));
	}
	static jsi::Value __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIdentities(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
	return static_cast<CommRustModuleSchemaCxxSpecJSI *>(&turboModule)->findUserIdentities(rt, args[0].asString(rt), args[1].asString(rt), args[2].asString(rt), args[3].asObject(rt).asArray(rt));
	}

	CommRustModuleSchemaCxxSpecJSI::CommRustModuleSchemaCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
	: TurboModule("CommRustTurboModule", jsInvoker) {
	methodMap_["generateNonce"] = MethodMetadata {0, __hostFunction_CommRustModuleSchemaCxxSpecJSI_generateNonce};
	methodMap_["registerPasswordUser"] = MethodMetadata {12, __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerPasswordUser};
	methodMap_["registerReservedPasswordUser"] = MethodMetadata {13, __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerReservedPasswordUser};
	- methodMap_["logInPasswordUser"] = MethodMetadata {8, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInPasswordUser};
	+ methodMap_["logInPasswordUser"] = MethodMetadata {10, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInPasswordUser};
	methodMap_["registerWalletUser"] = MethodMetadata {12, __hostFunction_CommRustModuleSchemaCxxSpecJSI_registerWalletUser};
	- methodMap_["logInWalletUser"] = MethodMetadata {8, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInWalletUser};
	+ methodMap_["logInWalletUser"] = MethodMetadata {10, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInWalletUser};
	methodMap_["restoreUser"] = MethodMetadata {12, __hostFunction_CommRustModuleSchemaCxxSpecJSI_restoreUser};
	methodMap_["updatePassword"] = MethodMetadata {5, __hostFunction_CommRustModuleSchemaCxxSpecJSI_updatePassword};
	methodMap_["deletePasswordUser"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_deletePasswordUser};
	methodMap_["deleteWalletUser"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_deleteWalletUser};
	methodMap_["logOut"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logOut};
	methodMap_["logOutPrimaryDevice"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logOutPrimaryDevice};
	methodMap_["logOutSecondaryDevice"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logOutSecondaryDevice};
	methodMap_["getOutboundKeysForUser"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getOutboundKeysForUser};
	methodMap_["getInboundKeysForUser"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getInboundKeysForUser};
	methodMap_["versionSupported"] = MethodMetadata {0, __hostFunction_CommRustModuleSchemaCxxSpecJSI_versionSupported};
	methodMap_["uploadOneTimeKeys"] = MethodMetadata {5, __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadOneTimeKeys};
	methodMap_["getKeyserverKeys"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getKeyserverKeys};
	methodMap_["getDeviceListForUser"] = MethodMetadata {5, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getDeviceListForUser};
	methodMap_["getDeviceListsForUsers"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getDeviceListsForUsers};
	methodMap_["updateDeviceList"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_updateDeviceList};
	methodMap_["syncPlatformDetails"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_syncPlatformDetails};
	methodMap_["uploadSecondaryDeviceKeysAndLogIn"] = MethodMetadata {11, __hostFunction_CommRustModuleSchemaCxxSpecJSI_uploadSecondaryDeviceKeysAndLogIn};
	methodMap_["logInExistingDevice"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_logInExistingDevice};
	methodMap_["findUserIDForWalletAddress"] = MethodMetadata {1, __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIDForWalletAddress};
	methodMap_["findUserIDForUsername"] = MethodMetadata {1, __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIDForUsername};
	methodMap_["getFarcasterUsers"] = MethodMetadata {1, __hostFunction_CommRustModuleSchemaCxxSpecJSI_getFarcasterUsers};
	methodMap_["linkFarcasterAccount"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_linkFarcasterAccount};
	methodMap_["unlinkFarcasterAccount"] = MethodMetadata {3, __hostFunction_CommRustModuleSchemaCxxSpecJSI_unlinkFarcasterAccount};
	methodMap_["findUserIdentities"] = MethodMetadata {4, __hostFunction_CommRustModuleSchemaCxxSpecJSI_findUserIdentities};
	}


	} // namespace react
	} // namespace facebook
	diff --git a/native/cpp/CommonCpp/_generated/rustJSI.h b/native/cpp/CommonCpp/_generated/rustJSI.h
	index d3b89e252..117220842 100644
	--- a/native/cpp/CommonCpp/_generated/rustJSI.h
	+++ b/native/cpp/CommonCpp/_generated/rustJSI.h
	@@ -1,323 +1,323 @@
	/**
	* 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 CommRustModuleSchemaCxxSpecJSI : public TurboModule {
	protected:
	CommRustModuleSchemaCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);

	public:
	virtual jsi::Value generateNonce(jsi::Runtime &rt) = 0;
	virtual jsi::Value registerPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String farcasterID, jsi::String initialDeviceList) = 0;
	virtual jsi::Value registerReservedPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String keyserverMessage, jsi::String keyserverSignature, jsi::String initialDeviceList) = 0;
	- virtual jsi::Value logInPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature) = 0;
	+ virtual jsi::Value logInPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
	virtual jsi::Value registerWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String farcasterID, jsi::String initialDeviceList) = 0;
	- virtual jsi::Value logInWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature) = 0;
	+ virtual jsi::Value logInWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
	virtual jsi::Value restoreUser(jsi::Runtime &rt, jsi::String userID, std::optional<jsi::String> siweMessage, std::optional<jsi::String> siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String deviceList) = 0;
	virtual jsi::Value updatePassword(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String oldPassword, jsi::String newPassword) = 0;
	virtual jsi::Value deletePasswordUser(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String password) = 0;
	virtual jsi::Value deleteWalletUser(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
	virtual jsi::Value logOut(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
	virtual jsi::Value logOutPrimaryDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String signedDeviceList) = 0;
	virtual jsi::Value logOutSecondaryDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
	virtual jsi::Value getOutboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) = 0;
	virtual jsi::Value getInboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) = 0;
	virtual jsi::Value versionSupported(jsi::Runtime &rt) = 0;
	virtual jsi::Value uploadOneTimeKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array contentOneTimePreKeys, jsi::Array notifOneTimePreKeys) = 0;
	virtual jsi::Value getKeyserverKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String keyserverID) = 0;
	virtual jsi::Value getDeviceListForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID, std::optional<double> sinceTimestamp) = 0;
	virtual jsi::Value getDeviceListsForUsers(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array userIDs) = 0;
	virtual jsi::Value updateDeviceList(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String updatePayload) = 0;
	virtual jsi::Value syncPlatformDetails(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken) = 0;
	virtual jsi::Value uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, jsi::String userID, jsi::String nonce, jsi::String nonceSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) = 0;
	virtual jsi::Value logInExistingDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String nonce, jsi::String nonceSignature) = 0;
	virtual jsi::Value findUserIDForWalletAddress(jsi::Runtime &rt, jsi::String walletAddress) = 0;
	virtual jsi::Value findUserIDForUsername(jsi::Runtime &rt, jsi::String username) = 0;
	virtual jsi::Value getFarcasterUsers(jsi::Runtime &rt, jsi::Array farcasterIDs) = 0;
	virtual jsi::Value linkFarcasterAccount(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String farcasterID) = 0;
	virtual jsi::Value unlinkFarcasterAccount(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) = 0;
	virtual jsi::Value findUserIdentities(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array userIDs) = 0;

	};

	template <typename T>
	class JSI_EXPORT CommRustModuleSchemaCxxSpec : public TurboModule {
	public:
	jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
	return delegate_.get(rt, propName);
	}

	protected:
	CommRustModuleSchemaCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
	: TurboModule("CommRustTurboModule", jsInvoker),
	delegate_(static_cast<T*>(this), jsInvoker) {}

	private:
	class Delegate : public CommRustModuleSchemaCxxSpecJSI {
	public:
	Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
	CommRustModuleSchemaCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {}

	jsi::Value generateNonce(jsi::Runtime &rt) override {
	static_assert(
	bridging::getParameterCount(&T::generateNonce) == 1,
	"Expected generateNonce(...) to have 1 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::generateNonce, jsInvoker_, instance_);
	}
	jsi::Value registerPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String farcasterID, jsi::String initialDeviceList) override {
	static_assert(
	bridging::getParameterCount(&T::registerPasswordUser) == 13,
	"Expected registerPasswordUser(...) to have 13 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::registerPasswordUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys), std::move(farcasterID), std::move(initialDeviceList));
	}
	jsi::Value registerReservedPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String keyserverMessage, jsi::String keyserverSignature, jsi::String initialDeviceList) override {
	static_assert(
	bridging::getParameterCount(&T::registerReservedPasswordUser) == 14,
	"Expected registerReservedPasswordUser(...) to have 14 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::registerReservedPasswordUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys), std::move(keyserverMessage), std::move(keyserverSignature), std::move(initialDeviceList));
	}
	- jsi::Value logInPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature) override {
	+ jsi::Value logInPasswordUser(jsi::Runtime &rt, jsi::String username, jsi::String password, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
	static_assert(
	- bridging::getParameterCount(&T::logInPasswordUser) == 9,
	- "Expected logInPasswordUser(...) to have 9 parameters");
	+ bridging::getParameterCount(&T::logInPasswordUser) == 11,
	+ "Expected logInPasswordUser(...) to have 11 parameters");

	return bridging::callFromJs<jsi::Value>(
	- rt, &T::logInPasswordUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature));
	+ rt, &T::logInPasswordUser, jsInvoker_, instance_, std::move(username), std::move(password), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
	}
	jsi::Value registerWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String farcasterID, jsi::String initialDeviceList) override {
	static_assert(
	bridging::getParameterCount(&T::registerWalletUser) == 13,
	"Expected registerWalletUser(...) to have 13 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::registerWalletUser, jsInvoker_, instance_, std::move(siweMessage), std::move(siweSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys), std::move(farcasterID), std::move(initialDeviceList));
	}
	- jsi::Value logInWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature) override {
	+ jsi::Value logInWalletUser(jsi::Runtime &rt, jsi::String siweMessage, jsi::String siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
	static_assert(
	- bridging::getParameterCount(&T::logInWalletUser) == 9,
	- "Expected logInWalletUser(...) to have 9 parameters");
	+ bridging::getParameterCount(&T::logInWalletUser) == 11,
	+ "Expected logInWalletUser(...) to have 11 parameters");

	return bridging::callFromJs<jsi::Value>(
	- rt, &T::logInWalletUser, jsInvoker_, instance_, std::move(siweMessage), std::move(siweSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature));
	+ rt, &T::logInWalletUser, jsInvoker_, instance_, std::move(siweMessage), std::move(siweSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
	}
	jsi::Value restoreUser(jsi::Runtime &rt, jsi::String userID, std::optional<jsi::String> siweMessage, std::optional<jsi::String> siweSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys, jsi::String deviceList) override {
	static_assert(
	bridging::getParameterCount(&T::restoreUser) == 13,
	"Expected restoreUser(...) to have 13 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::restoreUser, jsInvoker_, instance_, std::move(userID), std::move(siweMessage), std::move(siweSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys), std::move(deviceList));
	}
	jsi::Value updatePassword(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String oldPassword, jsi::String newPassword) override {
	static_assert(
	bridging::getParameterCount(&T::updatePassword) == 6,
	"Expected updatePassword(...) to have 6 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::updatePassword, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken), std::move(oldPassword), std::move(newPassword));
	}
	jsi::Value deletePasswordUser(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String password) override {
	static_assert(
	bridging::getParameterCount(&T::deletePasswordUser) == 5,
	"Expected deletePasswordUser(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::deletePasswordUser, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken), std::move(password));
	}
	jsi::Value deleteWalletUser(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
	static_assert(
	bridging::getParameterCount(&T::deleteWalletUser) == 4,
	"Expected deleteWalletUser(...) to have 4 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::deleteWalletUser, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
	}
	jsi::Value logOut(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
	static_assert(
	bridging::getParameterCount(&T::logOut) == 4,
	"Expected logOut(...) to have 4 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::logOut, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
	}
	jsi::Value logOutPrimaryDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String signedDeviceList) override {
	static_assert(
	bridging::getParameterCount(&T::logOutPrimaryDevice) == 5,
	"Expected logOutPrimaryDevice(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::logOutPrimaryDevice, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken), std::move(signedDeviceList));
	}
	jsi::Value logOutSecondaryDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
	static_assert(
	bridging::getParameterCount(&T::logOutSecondaryDevice) == 4,
	"Expected logOutSecondaryDevice(...) to have 4 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::logOutSecondaryDevice, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
	}
	jsi::Value getOutboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) override {
	static_assert(
	bridging::getParameterCount(&T::getOutboundKeysForUser) == 5,
	"Expected getOutboundKeysForUser(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::getOutboundKeysForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID));
	}
	jsi::Value getInboundKeysForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID) override {
	static_assert(
	bridging::getParameterCount(&T::getInboundKeysForUser) == 5,
	"Expected getInboundKeysForUser(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::getInboundKeysForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID));
	}
	jsi::Value versionSupported(jsi::Runtime &rt) override {
	static_assert(
	bridging::getParameterCount(&T::versionSupported) == 1,
	"Expected versionSupported(...) to have 1 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::versionSupported, jsInvoker_, instance_);
	}
	jsi::Value uploadOneTimeKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array contentOneTimePreKeys, jsi::Array notifOneTimePreKeys) override {
	static_assert(
	bridging::getParameterCount(&T::uploadOneTimeKeys) == 6,
	"Expected uploadOneTimeKeys(...) to have 6 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::uploadOneTimeKeys, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(contentOneTimePreKeys), std::move(notifOneTimePreKeys));
	}
	jsi::Value getKeyserverKeys(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String keyserverID) override {
	static_assert(
	bridging::getParameterCount(&T::getKeyserverKeys) == 5,
	"Expected getKeyserverKeys(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::getKeyserverKeys, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(keyserverID));
	}
	jsi::Value getDeviceListForUser(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String userID, std::optional<double> sinceTimestamp) override {
	static_assert(
	bridging::getParameterCount(&T::getDeviceListForUser) == 6,
	"Expected getDeviceListForUser(...) to have 6 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::getDeviceListForUser, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userID), std::move(sinceTimestamp));
	}
	jsi::Value getDeviceListsForUsers(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array userIDs) override {
	static_assert(
	bridging::getParameterCount(&T::getDeviceListsForUsers) == 5,
	"Expected getDeviceListsForUsers(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::getDeviceListsForUsers, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userIDs));
	}
	jsi::Value updateDeviceList(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::String updatePayload) override {
	static_assert(
	bridging::getParameterCount(&T::updateDeviceList) == 5,
	"Expected updateDeviceList(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::updateDeviceList, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(updatePayload));
	}
	jsi::Value syncPlatformDetails(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken) override {
	static_assert(
	bridging::getParameterCount(&T::syncPlatformDetails) == 4,
	"Expected syncPlatformDetails(...) to have 4 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::syncPlatformDetails, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken));
	}
	jsi::Value uploadSecondaryDeviceKeysAndLogIn(jsi::Runtime &rt, jsi::String userID, jsi::String nonce, jsi::String nonceSignature, jsi::String keyPayload, jsi::String keyPayloadSignature, jsi::String contentPrekey, jsi::String contentPrekeySignature, jsi::String notifPrekey, jsi::String notifPrekeySignature, jsi::Array contentOneTimeKeys, jsi::Array notifOneTimeKeys) override {
	static_assert(
	bridging::getParameterCount(&T::uploadSecondaryDeviceKeysAndLogIn) == 12,
	"Expected uploadSecondaryDeviceKeysAndLogIn(...) to have 12 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::uploadSecondaryDeviceKeysAndLogIn, jsInvoker_, instance_, std::move(userID), std::move(nonce), std::move(nonceSignature), std::move(keyPayload), std::move(keyPayloadSignature), std::move(contentPrekey), std::move(contentPrekeySignature), std::move(notifPrekey), std::move(notifPrekeySignature), std::move(contentOneTimeKeys), std::move(notifOneTimeKeys));
	}
	jsi::Value logInExistingDevice(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String nonce, jsi::String nonceSignature) override {
	static_assert(
	bridging::getParameterCount(&T::logInExistingDevice) == 5,
	"Expected logInExistingDevice(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::logInExistingDevice, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(nonce), std::move(nonceSignature));
	}
	jsi::Value findUserIDForWalletAddress(jsi::Runtime &rt, jsi::String walletAddress) override {
	static_assert(
	bridging::getParameterCount(&T::findUserIDForWalletAddress) == 2,
	"Expected findUserIDForWalletAddress(...) to have 2 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::findUserIDForWalletAddress, jsInvoker_, instance_, std::move(walletAddress));
	}
	jsi::Value findUserIDForUsername(jsi::Runtime &rt, jsi::String username) override {
	static_assert(
	bridging::getParameterCount(&T::findUserIDForUsername) == 2,
	"Expected findUserIDForUsername(...) to have 2 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::findUserIDForUsername, jsInvoker_, instance_, std::move(username));
	}
	jsi::Value getFarcasterUsers(jsi::Runtime &rt, jsi::Array farcasterIDs) override {
	static_assert(
	bridging::getParameterCount(&T::getFarcasterUsers) == 2,
	"Expected getFarcasterUsers(...) to have 2 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::getFarcasterUsers, jsInvoker_, instance_, std::move(farcasterIDs));
	}
	jsi::Value linkFarcasterAccount(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken, jsi::String farcasterID) override {
	static_assert(
	bridging::getParameterCount(&T::linkFarcasterAccount) == 5,
	"Expected linkFarcasterAccount(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::linkFarcasterAccount, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken), std::move(farcasterID));
	}
	jsi::Value unlinkFarcasterAccount(jsi::Runtime &rt, jsi::String userID, jsi::String deviceID, jsi::String accessToken) override {
	static_assert(
	bridging::getParameterCount(&T::unlinkFarcasterAccount) == 4,
	"Expected unlinkFarcasterAccount(...) to have 4 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::unlinkFarcasterAccount, jsInvoker_, instance_, std::move(userID), std::move(deviceID), std::move(accessToken));
	}
	jsi::Value findUserIdentities(jsi::Runtime &rt, jsi::String authUserID, jsi::String authDeviceID, jsi::String authAccessToken, jsi::Array userIDs) override {
	static_assert(
	bridging::getParameterCount(&T::findUserIdentities) == 5,
	"Expected findUserIdentities(...) to have 5 parameters");

	return bridging::callFromJs<jsi::Value>(
	rt, &T::findUserIdentities, jsInvoker_, instance_, std::move(authUserID), std::move(authDeviceID), std::move(authAccessToken), std::move(userIDs));
	}

	private:
	T *instance_;
	};

	Delegate delegate_;
	};

	} // namespace react
	} // namespace facebook
	diff --git a/native/identity-service/identity-service-context-provider.react.js b/native/identity-service/identity-service-context-provider.react.js
	index 6d580cb8e..69af6f589 100644
	--- a/native/identity-service/identity-service-context-provider.react.js
	+++ b/native/identity-service/identity-service-context-provider.react.js
	@@ -1,746 +1,758 @@
	// @flow

	import * as React from 'react';

	import { getOneTimeKeyValues } from 'lib/shared/crypto-utils.js';
	import { createAndSignSingletonDeviceList } from 'lib/shared/device-list-utils.js';
	import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
	import {
	type IdentityKeysBlob,
	identityKeysBlobValidator,
	type OneTimeKeysResultValues,
	} from 'lib/types/crypto-types.js';
	import {
	type DeviceOlmInboundKeys,
	deviceOlmInboundKeysValidator,
	type DeviceOlmOutboundKeys,
	deviceOlmOutboundKeysValidator,
	farcasterUsersValidator,
	identityAuthResultValidator,
	type IdentityServiceClient,
	ONE_TIME_KEYS_NUMBER,
	type SignedDeviceList,
	signedDeviceListHistoryValidator,
	type SignedNonce,
	type UserAuthMetadata,
	userDeviceOlmInboundKeysValidator,
	type UserDevicesOlmInboundKeys,
	type UserDevicesOlmOutboundKeys,
	type UsersSignedDeviceLists,
	userIdentitiesResponseValidator,
	type UsersDevicesPlatformDetails,
	peersDeviceListsValidator,
	} from 'lib/types/identity-service-types.js';
	import { getContentSigningKey } from 'lib/utils/crypto-utils.js';
	import { assertWithValidator } from 'lib/utils/validation-utils.js';

	import { getCommServicesAuthMetadataEmitter } from '../event-emitters/csa-auth-metadata-emitter.js';
	import { commCoreModule, commRustModule } from '../native-modules.js';
	import { useSelector } from '../redux/redux-utils.js';

	type Props = {
	+children: React.Node,
	};
	function IdentityServiceContextProvider(props: Props): React.Node {
	const { children } = props;

	const userIDPromiseRef = React.useRef<?Promise<?string>>();
	if (!userIDPromiseRef.current) {
	userIDPromiseRef.current = (async () => {
	const { userID } = await commCoreModule.getCommServicesAuthMetadata();
	return userID;
	})();
	}

	React.useEffect(() => {
	const metadataEmitter = getCommServicesAuthMetadataEmitter();
	const subscription = metadataEmitter.addListener(
	'commServicesAuthMetadata',
	(authMetadata: UserAuthMetadata) => {
	userIDPromiseRef.current = Promise.resolve(authMetadata.userID);
	},
	);
	return () => subscription.remove();
	}, []);

	const accessToken = useSelector(state => state.commServicesAccessToken);

	const getAuthMetadata = React.useCallback<
	() => Promise<{
	+deviceID: string,
	+userID: string,
	+accessToken: string,
	}>,
	>(async () => {
	const deviceID = await getContentSigningKey();
	const userID = await userIDPromiseRef.current;
	if (!deviceID \|\| !userID \|\| !accessToken) {
	throw new Error('Identity service client is not initialized');
	}
	return { deviceID, userID, accessToken };
	}, [accessToken]);

	const processAuthResult = async (authResult: string, deviceID: string) => {
	const { userID, accessToken: token, username } = JSON.parse(authResult);
	const identityAuthResult = {
	accessToken: token,
	userID,
	username,
	};

	const validatedResult = assertWithValidator(
	identityAuthResult,
	identityAuthResultValidator,
	);

	await commCoreModule.setCommServicesAuthMetadata(
	validatedResult.userID,
	deviceID,
	validatedResult.accessToken,
	);

	return validatedResult;
	};

	const client = React.useMemo<IdentityServiceClient>(
	() => ({
	deleteWalletUser: async () => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	return commRustModule.deleteWalletUser(userID, deviceID, token);
	},
	deletePasswordUser: async (password: string) => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	return commRustModule.deletePasswordUser(
	userID,
	deviceID,
	token,
	password,
	);
	},
	logOut: async () => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	return commRustModule.logOut(userID, deviceID, token);
	},
	logOutPrimaryDevice: async () => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	const signedDeviceList =
	await createAndSignSingletonDeviceList(deviceID);
	return commRustModule.logOutPrimaryDevice(
	userID,
	deviceID,
	token,
	JSON.stringify(signedDeviceList),
	);
	},
	logOutSecondaryDevice: async () => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	return commRustModule.logOutSecondaryDevice(userID, deviceID, token);
	},
	getKeyserverKeys: async (
	keyserverID: string,
	): Promise<DeviceOlmOutboundKeys> => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	const result = await commRustModule.getKeyserverKeys(
	userID,
	deviceID,
	token,
	keyserverID,
	);
	const resultObject = JSON.parse(result);
	const payload = resultObject?.payload;

	const keyserverKeys = {
	identityKeysBlob: payload ? JSON.parse(payload) : null,
	contentInitializationInfo: {
	prekey: resultObject?.contentPrekey,
	prekeySignature: resultObject?.contentPrekeySignature,
	oneTimeKey: resultObject?.oneTimeContentPrekey,
	},
	notifInitializationInfo: {
	prekey: resultObject?.notifPrekey,
	prekeySignature: resultObject?.notifPrekeySignature,
	oneTimeKey: resultObject?.oneTimeNotifPrekey,
	},
	payloadSignature: resultObject?.payloadSignature,
	};

	return assertWithValidator(
	keyserverKeys,
	deviceOlmOutboundKeysValidator,
	);
	},
	getOutboundKeysForUser: async (
	targetUserID: string,
	): Promise<UserDevicesOlmOutboundKeys[]> => {
	const {
	deviceID: authDeviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	const result = await commRustModule.getOutboundKeysForUser(
	userID,
	authDeviceID,
	token,
	targetUserID,
	);
	const resultArray = JSON.parse(result);

	return resultArray
	.map(outboundKeysInfo => {
	try {
	const payload = outboundKeysInfo?.payload;
	const identityKeysBlob: IdentityKeysBlob = assertWithValidator(
	payload ? JSON.parse(payload) : null,
	identityKeysBlobValidator,
	);
	const deviceID =
	identityKeysBlob.primaryIdentityPublicKeys.ed25519;

	const deviceKeys = {
	identityKeysBlob,
	contentInitializationInfo: {
	prekey: outboundKeysInfo?.contentPrekey,
	prekeySignature: outboundKeysInfo?.contentPrekeySignature,
	oneTimeKey: outboundKeysInfo?.oneTimeContentPrekey,
	},
	notifInitializationInfo: {
	prekey: outboundKeysInfo?.notifPrekey,
	prekeySignature: outboundKeysInfo?.notifPrekeySignature,
	oneTimeKey: outboundKeysInfo?.oneTimeNotifPrekey,
	},
	payloadSignature: outboundKeysInfo?.payloadSignature,
	};

	try {
	const validatedKeys = assertWithValidator(
	deviceKeys,
	deviceOlmOutboundKeysValidator,
	);
	return {
	deviceID,
	keys: validatedKeys,
	};
	} catch (e) {
	console.log(e);
	return {
	deviceID,
	keys: null,
	};
	}
	} catch (e) {
	console.log(e);
	return null;
	}
	})
	.filter(Boolean);
	},
	getInboundKeysForUser: async (
	targetUserID: string,
	): Promise<UserDevicesOlmInboundKeys> => {
	const {
	deviceID: authDeviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	const result = await commRustModule.getInboundKeysForUser(
	userID,
	authDeviceID,
	token,
	targetUserID,
	);
	const resultArray = JSON.parse(result);

	const devicesKeys: {
	[deviceID: string]: ?DeviceOlmInboundKeys,
	} = {};

	resultArray.forEach(inboundKeysInfo => {
	try {
	const payload = inboundKeysInfo?.payload;
	const identityKeysBlob: IdentityKeysBlob = assertWithValidator(
	payload ? JSON.parse(payload) : null,
	identityKeysBlobValidator,
	);
	const deviceID = identityKeysBlob.primaryIdentityPublicKeys.ed25519;

	const deviceKeys = {
	identityKeysBlob,
	signedPrekeys: {
	contentPrekey: inboundKeysInfo?.contentPrekey,
	contentPrekeySignature: inboundKeysInfo?.contentPrekeySignature,
	notifPrekey: inboundKeysInfo?.notifPrekey,
	notifPrekeySignature: inboundKeysInfo?.notifPrekeySignature,
	},
	payloadSignature: inboundKeysInfo?.payloadSignature,
	};

	try {
	devicesKeys[deviceID] = assertWithValidator(
	deviceKeys,
	deviceOlmInboundKeysValidator,
	);
	} catch (e) {
	console.log(e);
	devicesKeys[deviceID] = null;
	}
	} catch (e) {
	console.log(e);
	}
	});
	const device = resultArray?.[0];

	const inboundUserKeys = {
	keys: devicesKeys,
	username: device?.username,
	walletAddress: device?.walletAddress,
	};

	return assertWithValidator(
	inboundUserKeys,
	userDeviceOlmInboundKeysValidator,
	);
	},
	uploadOneTimeKeys: async (oneTimeKeys: OneTimeKeysResultValues) => {
	const {
	deviceID: authDeviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();

	await commRustModule.uploadOneTimeKeys(
	userID,
	authDeviceID,
	token,
	oneTimeKeys.contentOneTimeKeys,
	oneTimeKeys.notificationsOneTimeKeys,
	);
	},
	registerPasswordUser: async (
	username: string,
	password: string,
	fid: ?string,
	) => {
	await commCoreModule.initializeCryptoAccount();
	const [
	{ blobPayload, signature, primaryIdentityPublicKeys },
	{ contentOneTimeKeys, notificationsOneTimeKeys },
	prekeys,
	] = await Promise.all([
	commCoreModule.getUserPublicKey(),
	commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
	commCoreModule.validateAndGetPrekeys(),
	]);
	const initialDeviceList = await createAndSignSingletonDeviceList(
	primaryIdentityPublicKeys.ed25519,
	);
	const registrationResult = await commRustModule.registerPasswordUser(
	username,
	password,
	blobPayload,
	signature,
	prekeys.contentPrekey,
	prekeys.contentPrekeySignature,
	prekeys.notifPrekey,
	prekeys.notifPrekeySignature,
	getOneTimeKeyValues(contentOneTimeKeys),
	getOneTimeKeyValues(notificationsOneTimeKeys),
	fid ?? '',
	JSON.stringify(initialDeviceList),
	);

	return await processAuthResult(
	registrationResult,
	primaryIdentityPublicKeys.ed25519,
	);
	},
	registerReservedPasswordUser: async (
	username: string,
	password: string,
	keyserverMessage: string,
	keyserverSignature: string,
	) => {
	await commCoreModule.initializeCryptoAccount();
	const [
	{ blobPayload, signature, primaryIdentityPublicKeys },
	{ contentOneTimeKeys, notificationsOneTimeKeys },
	prekeys,
	] = await Promise.all([
	commCoreModule.getUserPublicKey(),
	commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
	commCoreModule.validateAndGetPrekeys(),
	]);
	const initialDeviceList = await createAndSignSingletonDeviceList(
	primaryIdentityPublicKeys.ed25519,
	);
	const registrationResult =
	await commRustModule.registerReservedPasswordUser(
	username,
	password,
	blobPayload,
	signature,
	prekeys.contentPrekey,
	prekeys.contentPrekeySignature,
	prekeys.notifPrekey,
	prekeys.notifPrekeySignature,
	getOneTimeKeyValues(contentOneTimeKeys),
	getOneTimeKeyValues(notificationsOneTimeKeys),
	keyserverMessage,
	keyserverSignature,
	JSON.stringify(initialDeviceList),
	);

	return await processAuthResult(
	registrationResult,
	primaryIdentityPublicKeys.ed25519,
	);
	},
	logInPasswordUser: async (username: string, password: string) => {
	await commCoreModule.initializeCryptoAccount();
	- const [{ blobPayload, signature, primaryIdentityPublicKeys }, prekeys] =
	- await Promise.all([
	- commCoreModule.getUserPublicKey(),
	- commCoreModule.validateAndGetPrekeys(),
	- ]);
	+ const [
	+ { blobPayload, signature, primaryIdentityPublicKeys },
	+ { contentOneTimeKeys, notificationsOneTimeKeys },
	+ prekeys,
	+ ] = await Promise.all([
	+ commCoreModule.getUserPublicKey(),
	+ commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
	+ commCoreModule.validateAndGetPrekeys(),
	+ ]);
	const loginResult = await commRustModule.logInPasswordUser(
	username,
	password,
	blobPayload,
	signature,
	prekeys.contentPrekey,
	prekeys.contentPrekeySignature,
	prekeys.notifPrekey,
	prekeys.notifPrekeySignature,
	+ getOneTimeKeyValues(contentOneTimeKeys),
	+ getOneTimeKeyValues(notificationsOneTimeKeys),
	);

	return await processAuthResult(
	loginResult,
	primaryIdentityPublicKeys.ed25519,
	);
	},
	registerWalletUser: async (
	walletAddress: string,
	siweMessage: string,
	siweSignature: string,
	fid: ?string,
	) => {
	await commCoreModule.initializeCryptoAccount();
	const [
	{ blobPayload, signature, primaryIdentityPublicKeys },
	{ contentOneTimeKeys, notificationsOneTimeKeys },
	prekeys,
	] = await Promise.all([
	commCoreModule.getUserPublicKey(),
	commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
	commCoreModule.validateAndGetPrekeys(),
	]);
	const initialDeviceList = await createAndSignSingletonDeviceList(
	primaryIdentityPublicKeys.ed25519,
	);
	const registrationResult = await commRustModule.registerWalletUser(
	siweMessage,
	siweSignature,
	blobPayload,
	signature,
	prekeys.contentPrekey,
	prekeys.contentPrekeySignature,
	prekeys.notifPrekey,
	prekeys.notifPrekeySignature,
	getOneTimeKeyValues(contentOneTimeKeys),
	getOneTimeKeyValues(notificationsOneTimeKeys),
	fid ?? '',
	JSON.stringify(initialDeviceList),
	);

	return await processAuthResult(
	registrationResult,
	primaryIdentityPublicKeys.ed25519,
	);
	},
	logInWalletUser: async (
	walletAddress: string,
	siweMessage: string,
	siweSignature: string,
	) => {
	await commCoreModule.initializeCryptoAccount();
	- const [{ blobPayload, signature, primaryIdentityPublicKeys }, prekeys] =
	- await Promise.all([
	- commCoreModule.getUserPublicKey(),
	- commCoreModule.validateAndGetPrekeys(),
	- ]);
	+ const [
	+ { blobPayload, signature, primaryIdentityPublicKeys },
	+ { contentOneTimeKeys, notificationsOneTimeKeys },
	+ prekeys,
	+ ] = await Promise.all([
	+ commCoreModule.getUserPublicKey(),
	+ commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
	+ commCoreModule.validateAndGetPrekeys(),
	+ ]);
	const loginResult = await commRustModule.logInWalletUser(
	siweMessage,
	siweSignature,
	blobPayload,
	signature,
	prekeys.contentPrekey,
	prekeys.contentPrekeySignature,
	prekeys.notifPrekey,
	prekeys.notifPrekeySignature,
	+ getOneTimeKeyValues(contentOneTimeKeys),
	+ getOneTimeKeyValues(notificationsOneTimeKeys),
	);

	return await processAuthResult(
	loginResult,
	primaryIdentityPublicKeys.ed25519,
	);
	},
	restoreUser: async (
	userID: string,
	deviceList: SignedDeviceList,
	siweMessage?: string,
	siweSignature?: string,
	) => {
	await commCoreModule.initializeCryptoAccount();
	const [
	{ blobPayload, signature, primaryIdentityPublicKeys },
	{ contentOneTimeKeys, notificationsOneTimeKeys },
	prekeys,
	] = await Promise.all([
	commCoreModule.getUserPublicKey(),
	commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
	commCoreModule.validateAndGetPrekeys(),
	]);
	const restoreResult = await commRustModule.restoreUser(
	userID,
	siweMessage,
	siweSignature,
	blobPayload,
	signature,
	prekeys.contentPrekey,
	prekeys.contentPrekeySignature,
	prekeys.notifPrekey,
	prekeys.notifPrekeySignature,
	getOneTimeKeyValues(contentOneTimeKeys),
	getOneTimeKeyValues(notificationsOneTimeKeys),
	JSON.stringify(deviceList),
	);

	return await processAuthResult(
	restoreResult,
	primaryIdentityPublicKeys.ed25519,
	);
	},
	uploadKeysForRegisteredDeviceAndLogIn: async (
	userID: string,
	nonceChallengeResponse: SignedNonce,
	) => {
	await commCoreModule.initializeCryptoAccount();
	const [
	{ blobPayload, signature, primaryIdentityPublicKeys },
	{ contentOneTimeKeys, notificationsOneTimeKeys },
	prekeys,
	] = await Promise.all([
	commCoreModule.getUserPublicKey(),
	commCoreModule.getOneTimeKeys(ONE_TIME_KEYS_NUMBER),
	commCoreModule.validateAndGetPrekeys(),
	]);
	const { nonce, nonceSignature } = nonceChallengeResponse;
	const registrationResult =
	await commRustModule.uploadSecondaryDeviceKeysAndLogIn(
	userID,
	nonce,
	nonceSignature,
	blobPayload,
	signature,
	prekeys.contentPrekey,
	prekeys.contentPrekeySignature,
	prekeys.notifPrekey,
	prekeys.notifPrekeySignature,
	getOneTimeKeyValues(contentOneTimeKeys),
	getOneTimeKeyValues(notificationsOneTimeKeys),
	);

	return await processAuthResult(
	registrationResult,
	primaryIdentityPublicKeys.ed25519,
	);
	},
	generateNonce: commRustModule.generateNonce,
	getDeviceListHistoryForUser: async (
	userID: string,
	sinceTimestamp?: number,
	) => {
	const {
	deviceID: authDeviceID,
	userID: authUserID,
	accessToken: token,
	} = await getAuthMetadata();
	const result = await commRustModule.getDeviceListForUser(
	authUserID,
	authDeviceID,
	token,
	userID,
	sinceTimestamp,
	);
	const rawPayloads: string[] = JSON.parse(result);
	const deviceLists: SignedDeviceList[] = rawPayloads.map(payload =>
	JSON.parse(payload),
	);
	return assertWithValidator(
	deviceLists,
	signedDeviceListHistoryValidator,
	);
	},
	getDeviceListsForUsers: async (userIDs: $ReadOnlyArray<string>) => {
	const {
	deviceID: authDeviceID,
	userID: authUserID,
	accessToken: token,
	} = await getAuthMetadata();
	const result = await commRustModule.getDeviceListsForUsers(
	authUserID,
	authDeviceID,
	token,
	userIDs,
	);

	const rawPayloads: {
	+usersDeviceLists: { +[userID: string]: string },
	+usersDevicesPlatformDetails: UsersDevicesPlatformDetails,
	} = JSON.parse(result);

	let usersDeviceLists: UsersSignedDeviceLists = {};
	for (const userID in rawPayloads.usersDeviceLists) {
	usersDeviceLists = {
	...usersDeviceLists,
	[userID]: JSON.parse(rawPayloads.usersDeviceLists[userID]),
	};
	}

	const peersDeviceLists = {
	usersSignedDeviceLists: usersDeviceLists,
	usersDevicesPlatformDetails: rawPayloads.usersDevicesPlatformDetails,
	};

	return assertWithValidator(peersDeviceLists, peersDeviceListsValidator);
	},
	updateDeviceList: async (newDeviceList: SignedDeviceList) => {
	const {
	deviceID: authDeviceID,
	userID,
	accessToken: authAccessToken,
	} = await getAuthMetadata();
	const payload = JSON.stringify(newDeviceList);
	await commRustModule.updateDeviceList(
	userID,
	authDeviceID,
	authAccessToken,
	payload,
	);
	},
	syncPlatformDetails: async () => {
	const {
	deviceID: authDeviceID,
	userID,
	accessToken: authAccessToken,
	} = await getAuthMetadata();
	await commRustModule.syncPlatformDetails(
	userID,
	authDeviceID,
	authAccessToken,
	);
	},
	getFarcasterUsers: async (farcasterIDs: $ReadOnlyArray<string>) => {
	const farcasterUsersJSONString =
	await commRustModule.getFarcasterUsers(farcasterIDs);
	const farcasterUsers = JSON.parse(farcasterUsersJSONString);
	return assertWithValidator(farcasterUsers, farcasterUsersValidator);
	},
	linkFarcasterAccount: async (farcasterID: string) => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	return commRustModule.linkFarcasterAccount(
	userID,
	deviceID,
	token,
	farcasterID,
	);
	},
	unlinkFarcasterAccount: async () => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	return commRustModule.unlinkFarcasterAccount(userID, deviceID, token);
	},
	findUserIdentities: async (userIDs: $ReadOnlyArray<string>) => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	const result = await commRustModule.findUserIdentities(
	userID,
	deviceID,
	token,
	userIDs,
	);
	return assertWithValidator(
	JSON.parse(result),
	userIdentitiesResponseValidator,
	);
	},
	versionSupported: () => {
	return commRustModule.versionSupported();
	},
	changePassword: async (oldPassword: string, newPassword: string) => {
	const {
	deviceID,
	userID,
	accessToken: token,
	} = await getAuthMetadata();
	return commRustModule.updatePassword(
	userID,
	deviceID,
	token,
	oldPassword,
	newPassword,
	);
	},
	}),
	[getAuthMetadata],
	);

	const value = React.useMemo(
	() => ({
	identityClient: client,
	getAuthMetadata,
	}),
	[client, getAuthMetadata],
	);

	return (
	<IdentityClientContext.Provider value={value}>
	{children}
	</IdentityClientContext.Provider>
	);
	}

	export default IdentityServiceContextProvider;
	diff --git a/native/native_rust_library/src/identity/login.rs b/native/native_rust_library/src/identity/login.rs
	index 48afe7374..8d9ac900e 100644
	--- a/native/native_rust_library/src/identity/login.rs
	+++ b/native/native_rust_library/src/identity/login.rs
	@@ -1,336 +1,340 @@
	use comm_opaque2::client::Login;
	use grpc_clients::identity::{
	get_unauthenticated_client,
	protos::unauth::{
	DeviceKeyUpload, ExistingDeviceLoginRequest, IdentityKeyInfo,
	OpaqueLoginFinishRequest, OpaqueLoginStartRequest, Prekey,
	RestoreUserRequest, SecondaryDeviceKeysUploadRequest, WalletAuthRequest,
	},
	};
	use tracing::instrument;

	use super::{
	IdentityAuthResult, LogInPasswordUserInfo, LogInWalletUserInfo,
	RestoreUserInfo, PLATFORM_METADATA,
	};
	use crate::utils::jsi_callbacks::handle_string_result_as_callback;
	use crate::{Error, DEVICE_TYPE, IDENTITY_SOCKET_ADDR, RUNTIME};

	#[allow(clippy::too_many_arguments)]
	pub mod ffi {
	use crate::identity::{
	DeviceKeys, LogInPasswordUserInfo, LogInWalletUserInfo,
	};

	use super::*;

	#[instrument]
	pub fn log_in_password_user(
	username: String,
	password: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	+ content_one_time_keys: Vec<String>,
	+ notif_one_time_keys: Vec<String>,
	promise_id: u32,
	) {
	RUNTIME.spawn(async move {
	let password_user_info = LogInPasswordUserInfo {
	username,
	password,
	device_keys: DeviceKeys {
	key_payload,
	key_payload_signature,
	content_prekey,
	content_prekey_signature,
	notif_prekey,
	notif_prekey_signature,
	- content_one_time_keys: Vec::new(),
	- notif_one_time_keys: Vec::new(),
	+ content_one_time_keys,
	+ notif_one_time_keys,
	},
	};
	let result = log_in_password_user_helper(password_user_info).await;
	handle_string_result_as_callback(result, promise_id);
	});
	}

	#[instrument]
	pub fn log_in_wallet_user(
	siwe_message: String,
	siwe_signature: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	+ content_one_time_keys: Vec<String>,
	+ notif_one_time_keys: Vec<String>,
	promise_id: u32,
	) {
	RUNTIME.spawn(async move {
	let wallet_user_info = LogInWalletUserInfo {
	siwe_message,
	siwe_signature,
	device_keys: DeviceKeys {
	key_payload,
	key_payload_signature,
	content_prekey,
	content_prekey_signature,
	notif_prekey,
	notif_prekey_signature,
	- content_one_time_keys: Vec::new(),
	- notif_one_time_keys: Vec::new(),
	+ content_one_time_keys,
	+ notif_one_time_keys,
	},
	};
	let result = log_in_wallet_user_helper(wallet_user_info).await;
	handle_string_result_as_callback(result, promise_id);
	});
	}

	// Primary device restore
	#[instrument]
	pub fn restore_user(
	user_id: String,
	siwe_message: String,
	siwe_signature: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	content_one_time_keys: Vec<String>,
	notif_one_time_keys: Vec<String>,
	device_list: String,
	promise_id: u32,
	) {
	RUNTIME.spawn(async move {
	let siwe_message = Some(siwe_message).filter(\|it\| !it.is_empty());
	let siwe_signature = Some(siwe_signature).filter(\|it\| !it.is_empty());
	let restored_user_info = RestoreUserInfo {
	user_id,
	siwe_message,
	siwe_signature,
	device_list,
	device_keys: DeviceKeys {
	key_payload,
	key_payload_signature,
	content_prekey,
	content_prekey_signature,
	notif_prekey,
	notif_prekey_signature,
	content_one_time_keys,
	notif_one_time_keys,
	},
	};
	let result = restore_user_helper(restored_user_info).await;
	handle_string_result_as_callback(result, promise_id);
	});
	}

	// QR code device log in
	pub fn upload_secondary_device_keys_and_log_in(
	user_id: String,
	nonce: String,
	nonce_signature: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	content_one_time_keys: Vec<String>,
	notif_one_time_keys: Vec<String>,
	promise_id: u32,
	) {
	RUNTIME.spawn(async move {
	let device_key_upload = DeviceKeyUpload {
	device_key_info: Some(IdentityKeyInfo {
	payload: key_payload,
	payload_signature: key_payload_signature,
	}),
	content_upload: Some(Prekey {
	prekey: content_prekey,
	prekey_signature: content_prekey_signature,
	}),
	notif_upload: Some(Prekey {
	prekey: notif_prekey,
	prekey_signature: notif_prekey_signature,
	}),
	one_time_content_prekeys: content_one_time_keys,
	one_time_notif_prekeys: notif_one_time_keys,
	device_type: DEVICE_TYPE.into(),
	};

	let result = upload_secondary_device_keys_and_log_in_helper(
	user_id,
	nonce,
	nonce_signature,
	device_key_upload,
	)
	.await;
	handle_string_result_as_callback(result, promise_id);
	});
	}

	pub fn log_in_existing_device(
	user_id: String,
	device_id: String,
	nonce: String,
	nonce_signature: String,
	promise_id: u32,
	) {
	RUNTIME.spawn(async move {
	let result = log_in_existing_device_helper(
	user_id,
	device_id,
	nonce,
	nonce_signature,
	)
	.await;
	handle_string_result_as_callback(result, promise_id);
	});
	}
	}

	async fn log_in_password_user_helper(
	password_user_info: LogInPasswordUserInfo,
	) -> Result<String, Error> {
	let mut client_login = Login::new();
	let opaque_login_request = client_login
	.start(&password_user_info.password)
	.map_err(crate::handle_error)?;
	let login_start_request = OpaqueLoginStartRequest {
	opaque_login_request,
	username: password_user_info.username,
	device_key_upload: Some(password_user_info.device_keys.into()),
	force: None,
	};

	let mut identity_client =
	get_unauthenticated_client(IDENTITY_SOCKET_ADDR, PLATFORM_METADATA.clone())
	.await?;

	let response = identity_client
	.log_in_password_user_start(login_start_request)
	.await?;

	let login_start_response = response.into_inner();

	let opaque_login_upload = client_login
	.finish(&login_start_response.opaque_login_response)
	.map_err(crate::handle_error)?;

	let login_finish_request = OpaqueLoginFinishRequest {
	session_id: login_start_response.session_id,
	opaque_login_upload,
	};

	let login_finish_response = identity_client
	.log_in_password_user_finish(login_finish_request)
	.await?
	.into_inner();
	let auth_result = IdentityAuthResult::from(login_finish_response);
	Ok(serde_json::to_string(&auth_result)?)
	}

	async fn log_in_wallet_user_helper(
	wallet_user_info: LogInWalletUserInfo,
	) -> Result<String, Error> {
	let login_request = WalletAuthRequest {
	siwe_message: wallet_user_info.siwe_message,
	siwe_signature: wallet_user_info.siwe_signature,
	device_key_upload: Some(wallet_user_info.device_keys.into()),
	farcaster_id: None,
	initial_device_list: "".to_string(),
	};

	let mut identity_client =
	get_unauthenticated_client(IDENTITY_SOCKET_ADDR, PLATFORM_METADATA.clone())
	.await?;

	let login_response = identity_client
	.log_in_wallet_user(login_request)
	.await?
	.into_inner();

	let auth_result = IdentityAuthResult::from(login_response);
	Ok(serde_json::to_string(&auth_result)?)
	}

	async fn restore_user_helper(
	wallet_user_info: RestoreUserInfo,
	) -> Result<String, Error> {
	let restore_request = RestoreUserRequest {
	user_id: wallet_user_info.user_id,
	siwe_message: wallet_user_info.siwe_message,
	siwe_signature: wallet_user_info.siwe_signature,
	device_list: wallet_user_info.device_list,
	device_key_upload: Some(wallet_user_info.device_keys.into()),
	};

	let mut identity_client =
	get_unauthenticated_client(IDENTITY_SOCKET_ADDR, PLATFORM_METADATA.clone())
	.await?;

	let auth_response = identity_client
	.restore_user(restore_request)
	.await?
	.into_inner();

	let auth_result = IdentityAuthResult::from(auth_response);
	Ok(serde_json::to_string(&auth_result)?)
	}

	async fn upload_secondary_device_keys_and_log_in_helper(
	user_id: String,
	nonce: String,
	nonce_signature: String,
	device_key_upload: DeviceKeyUpload,
	) -> Result<String, Error> {
	let mut identity_client =
	get_unauthenticated_client(IDENTITY_SOCKET_ADDR, PLATFORM_METADATA.clone())
	.await?;

	let request = SecondaryDeviceKeysUploadRequest {
	user_id,
	nonce,
	nonce_signature,
	device_key_upload: Some(device_key_upload),
	};

	let response = identity_client
	.upload_keys_for_registered_device_and_log_in(request)
	.await?
	.into_inner();

	let auth_result = IdentityAuthResult::from(response);
	Ok(serde_json::to_string(&auth_result)?)
	}

	async fn log_in_existing_device_helper(
	user_id: String,
	device_id: String,
	nonce: String,
	nonce_signature: String,
	) -> Result<String, Error> {
	let mut identity_client =
	get_unauthenticated_client(IDENTITY_SOCKET_ADDR, PLATFORM_METADATA.clone())
	.await?;

	let request = ExistingDeviceLoginRequest {
	user_id,
	device_id,
	nonce,
	nonce_signature,
	};

	let response = identity_client
	.log_in_existing_device(request)
	.await?
	.into_inner();

	let auth_result = IdentityAuthResult::from(response);
	Ok(serde_json::to_string(&auth_result)?)
	}
	diff --git a/native/native_rust_library/src/lib.rs b/native/native_rust_library/src/lib.rs
	index 7abd445d2..8696ee290 100644
	--- a/native/native_rust_library/src/lib.rs
	+++ b/native/native_rust_library/src/lib.rs
	@@ -1,553 +1,557 @@
	use comm_opaque2::grpc::opaque_error_to_grpc_status as handle_error;
	use grpc_clients::identity::protos::unauth::DeviceType;
	use lazy_static::lazy_static;
	use std::sync::Arc;
	use tokio::runtime::{Builder, Runtime};
	use tonic::Status;

	mod argon2_tools;
	mod backup;
	mod constants;
	mod identity;
	mod utils;

	use crate::argon2_tools::compute_backup_key_str;
	use crate::utils::jsi_callbacks::{
	handle_string_result_as_callback, handle_void_result_as_callback,
	};

	mod generated {
	// We get the CODE_VERSION from this generated file
	include!(concat!(env!("OUT_DIR"), "/version.rs"));
	// We get the IDENTITY_SOCKET_ADDR from this generated file
	include!(concat!(env!("OUT_DIR"), "/socket_config.rs"));
	}

	pub use generated::CODE_VERSION;
	pub use generated::{BACKUP_SOCKET_ADDR, IDENTITY_SOCKET_ADDR};

	#[cfg(not(target_os = "android"))]
	pub const DEVICE_TYPE: DeviceType = DeviceType::Ios;
	#[cfg(target_os = "android")]
	pub const DEVICE_TYPE: DeviceType = DeviceType::Android;

	lazy_static! {
	static ref RUNTIME: Arc<Runtime> =
	Arc::new(Builder::new_multi_thread().enable_all().build().unwrap());
	}

	// ffi uses
	use backup::ffi::*;
	use identity::ffi::*;
	use utils::future_manager::ffi::*;

	#[allow(clippy::too_many_arguments)]
	#[cxx::bridge]
	mod ffi {

	// Identity Service APIs
	extern "Rust" {
	#[cxx_name = "identityRegisterPasswordUser"]
	fn register_password_user(
	username: String,
	password: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	content_one_time_keys: Vec<String>,
	notif_one_time_keys: Vec<String>,
	farcaster_id: String,
	initial_device_list: String,
	promise_id: u32,
	);

	#[cxx_name = "identityRegisterReservedPasswordUser"]
	fn register_reserved_password_user(
	username: String,
	password: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	content_one_time_keys: Vec<String>,
	notif_one_time_keys: Vec<String>,
	keyserver_message: String,
	keyserver_signature: String,
	initial_device_list: String,
	promise_id: u32,
	);

	#[cxx_name = "identityLogInPasswordUser"]
	fn log_in_password_user(
	username: String,
	password: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	+ content_one_time_keys: Vec<String>,
	+ notif_one_time_keys: Vec<String>,
	promise_id: u32,
	);

	#[cxx_name = "identityRegisterWalletUser"]
	fn register_wallet_user(
	siwe_message: String,
	siwe_signature: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	content_one_time_keys: Vec<String>,
	notif_one_time_keys: Vec<String>,
	farcaster_id: String,
	initial_device_list: String,
	promise_id: u32,
	);

	#[cxx_name = "identityLogInWalletUser"]
	fn log_in_wallet_user(
	siwe_message: String,
	siwe_signature: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	+ content_one_time_keys: Vec<String>,
	+ notif_one_time_keys: Vec<String>,
	promise_id: u32,
	);

	#[cxx_name = "identityRestoreUser"]
	fn restore_user(
	user_id: String,
	siwe_message: String,
	siwe_signature: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	content_one_time_keys: Vec<String>,
	notif_one_time_keys: Vec<String>,
	device_list: String,
	promise_id: u32,
	);

	#[cxx_name = "identityUpdateUserPassword"]
	fn update_user_password(
	user_id: String,
	device_id: String,
	access_token: String,
	old_password: String,
	new_password: String,
	promise_id: u32,
	);

	#[cxx_name = "identityDeleteWalletUser"]
	fn delete_wallet_user(
	user_id: String,
	device_id: String,
	access_token: String,
	promise_id: u32,
	);

	#[cxx_name = "identityDeletePasswordUser"]
	fn delete_password_user(
	user_id: String,
	device_id: String,
	access_token: String,
	password: String,
	promise_id: u32,
	);

	#[cxx_name = "identityLogOut"]
	fn log_out(
	user_id: String,
	device_id: String,
	access_token: String,
	promise_id: u32,
	);

	#[cxx_name = "identityLogOutPrimaryDevice"]
	fn log_out_primary_device(
	user_id: String,
	device_id: String,
	access_token: String,
	signed_device_list: String,
	promise_id: u32,
	);

	#[cxx_name = "identityLogOutSecondaryDevice"]
	fn log_out_secondary_device(
	user_id: String,
	device_id: String,
	access_token: String,
	promise_id: u32,
	);

	#[cxx_name = "identityGetOutboundKeysForUser"]
	fn get_outbound_keys_for_user(
	auth_user_id: String,
	auth_device_id: String,
	auth_access_token: String,
	user_id: String,
	promise_id: u32,
	);

	#[cxx_name = "identityGetInboundKeysForUser"]
	fn get_inbound_keys_for_user(
	auth_user_id: String,
	auth_device_id: String,
	auth_access_token: String,
	user_id: String,
	promise_id: u32,
	);

	#[cxx_name = "identityRefreshUserPrekeys"]
	fn refresh_user_prekeys(
	auth_user_id: String,
	auth_device_id: String,
	auth_access_token: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	promise_id: u32,
	);

	#[cxx_name = "identityGenerateNonce"]
	fn generate_nonce(promise_id: u32);

	#[cxx_name = "identityVersionSupported"]
	fn version_supported(promise_id: u32);

	#[cxx_name = "identityUploadOneTimeKeys"]
	fn upload_one_time_keys(
	auth_user_id: String,
	auth_device_id: String,
	auth_access_token: String,
	content_one_time_keys: Vec<String>,
	notif_one_time_keys: Vec<String>,
	promise_id: u32,
	);

	#[cxx_name = "identityGetKeyserverKeys"]
	fn get_keyserver_keys(
	user_id: String,
	device_id: String,
	access_token: String,
	keyserver_id: String,
	promise_id: u32,
	);

	#[cxx_name = "identityGetDeviceListForUser"]
	fn get_device_list_for_user(
	auth_user_id: String,
	auth_device_id: String,
	auth_access_token: String,
	user_id: String,
	since_timestamp: i64,
	promise_id: u32,
	);

	#[cxx_name = "identityGetDeviceListsForUsers"]
	fn get_device_lists_for_users(
	auth_user_id: String,
	auth_device_id: String,
	auth_access_token: String,
	user_ids: Vec<String>,
	promise_id: u32,
	);

	#[cxx_name = "identityUpdateDeviceList"]
	fn update_device_list(
	auth_user_id: String,
	auth_device_id: String,
	auth_access_token: String,
	update_payload: String,
	promise_id: u32,
	);

	#[cxx_name = "identitySyncPlatformDetails"]
	fn sync_platform_details(
	auth_user_id: String,
	auth_device_id: String,
	auth_access_token: String,
	promise_id: u32,
	);

	#[cxx_name = "identityUploadSecondaryDeviceKeysAndLogIn"]
	fn upload_secondary_device_keys_and_log_in(
	user_id: String,
	nonce: String,
	nonce_signature: String,
	key_payload: String,
	key_payload_signature: String,
	content_prekey: String,
	content_prekey_signature: String,
	notif_prekey: String,
	notif_prekey_signature: String,
	content_one_time_keys: Vec<String>,
	notif_one_time_keys: Vec<String>,
	promise_id: u32,
	);

	#[cxx_name = "identityLogInExistingDevice"]
	fn log_in_existing_device(
	user_id: String,
	device_id: String,
	nonce: String,
	nonce_signature: String,
	promise_id: u32,
	);

	#[cxx_name = "identityFindUserIDForWalletAddress"]
	fn find_user_id_for_wallet_address(wallet_address: String, promise_id: u32);

	#[cxx_name = "identityFindUserIDForUsername"]
	fn find_user_id_for_username(username: String, promise_id: u32);

	// Farcaster
	#[cxx_name = "identityGetFarcasterUsers"]
	fn get_farcaster_users(farcaster_ids: Vec<String>, promise_id: u32);

	#[cxx_name = "identityLinkFarcasterAccount"]
	fn link_farcaster_account(
	user_id: String,
	device_id: String,
	access_token: String,
	farcaster_id: String,
	promise_id: u32,
	);

	#[cxx_name = "identityUnlinkFarcasterAccount"]
	fn unlink_farcaster_account(
	user_id: String,
	device_id: String,
	access_token: String,
	promise_id: u32,
	);

	#[cxx_name = "identityFindUserIdentities"]
	fn find_user_identities(
	user_id: String,
	device_id: String,
	access_token: String,
	user_ids: Vec<String>,
	promise_id: u32,
	);

	// Argon2
	#[cxx_name = "compute_backup_key"]
	fn compute_backup_key_str(
	password: &str,
	backup_id: &str,
	) -> Result<[u8; 32]>;
	}

	unsafe extern "C++" {
	include!("RustCallback.h");
	#[namespace = "comm"]
	#[cxx_name = "stringCallback"]
	fn string_callback(error: String, promise_id: u32, ret: String);

	#[namespace = "comm"]
	#[cxx_name = "voidCallback"]
	fn void_callback(error: String, promise_id: u32);

	#[namespace = "comm"]
	#[cxx_name = "boolCallback"]
	fn bool_callback(error: String, promise_id: u32, ret: bool);
	}

	// AES cryptography
	#[namespace = "comm"]
	unsafe extern "C++" {
	include!("RustAESCrypto.h");

	#[allow(unused)]
	#[cxx_name = "aesGenerateKey"]
	fn generate_key(buffer: &mut [u8]) -> Result<()>;

	/// The first two argument aren't mutated but creation of Java ByteBuffer
	/// requires the underlying bytes to be mutable.
	#[allow(unused)]
	#[cxx_name = "aesEncrypt"]
	fn encrypt(
	key: &mut [u8],
	plaintext: &mut [u8],
	sealed_data: &mut [u8],
	) -> Result<()>;

	/// The first two argument aren't mutated but creation of Java ByteBuffer
	/// requires the underlying bytes to be mutable.
	#[allow(unused)]
	#[cxx_name = "aesDecrypt"]
	fn decrypt(
	key: &mut [u8],
	sealed_data: &mut [u8],
	plaintext: &mut [u8],
	) -> Result<()>;
	}

	// Comm Services Auth Metadata Emission
	#[namespace = "comm"]
	unsafe extern "C++" {
	include!("RustCSAMetadataEmitter.h");

	#[allow(unused)]
	#[cxx_name = "sendAuthMetadataToJS"]
	fn send_auth_metadata_to_js(
	access_token: String,
	user_id: String,
	) -> Result<()>;
	}

	// Backup
	extern "Rust" {
	#[cxx_name = "startBackupHandler"]
	fn start_backup_handler() -> Result<()>;
	#[cxx_name = "stopBackupHandler"]
	fn stop_backup_handler() -> Result<()>;

	#[cxx_name = "triggerBackupFileUpload"]
	fn trigger_backup_file_upload();

	#[cxx_name = "createBackup"]
	fn create_backup(
	backup_id: String,
	backup_secret: String,
	pickle_key: String,
	pickled_account: String,
	siwe_backup_msg: String,
	promise_id: u32,
	);

	#[cxx_name = "restoreBackup"]
	fn restore_backup(
	backup_secret: String,
	backup_id: String,
	max_version: String,
	promise_id: u32,
	);

	#[cxx_name = "restoreBackupData"]
	fn restore_backup_data(
	backup_id: String,
	backup_data_key: String,
	backup_log_data_key: String,
	max_version: String,
	promise_id: u32,
	);

	#[cxx_name = "retrieveBackupKeys"]
	fn retrieve_backup_keys(backup_secret: String, promise_id: u32);

	#[cxx_name = "retrieveLatestSIWEBackupData"]
	fn retrieve_latest_siwe_backup_data(promise_id: u32);
	}

	// Secure store
	#[namespace = "comm"]
	unsafe extern "C++" {
	include!("RustSecureStore.h");

	#[allow(unused)]
	#[cxx_name = "secureStoreSet"]
	fn secure_store_set(key: &str, value: String) -> Result<()>;

	#[cxx_name = "secureStoreGet"]
	fn secure_store_get(key: &str) -> Result<String>;
	}

	// C++ Backup creation
	#[namespace = "comm"]
	unsafe extern "C++" {
	include!("RustBackupExecutor.h");

	#[cxx_name = "getBackupDirectoryPath"]
	fn get_backup_directory_path() -> Result<String>;

	#[cxx_name = "getBackupFilePath"]
	fn get_backup_file_path(
	backup_id: &str,
	is_attachments: bool,
	) -> Result<String>;

	#[cxx_name = "getBackupLogFilePath"]
	fn get_backup_log_file_path(
	backup_id: &str,
	log_id: &str,
	is_attachments: bool,
	) -> Result<String>;

	#[cxx_name = "getBackupUserKeysFilePath"]
	fn get_backup_user_keys_file_path(backup_id: &str) -> Result<String>;

	#[cxx_name = "getSIWEBackupMessagePath"]
	fn get_siwe_backup_message_path(backup_id: &str) -> Result<String>;

	#[cxx_name = "createMainCompaction"]
	fn create_main_compaction(backup_id: &str, future_id: usize);

	#[cxx_name = "restoreFromMainCompaction"]
	fn restore_from_main_compaction(
	main_compaction_path: &str,
	main_compaction_encryption_key: &str,
	max_version: &str,
	future_id: usize,
	);

	#[cxx_name = "restoreFromBackupLog"]
	fn restore_from_backup_log(backup_log: Vec<u8>, future_id: usize);
	}

	// Future handling from C++
	extern "Rust" {
	#[cxx_name = "resolveUnitFuture"]
	fn resolve_unit_future(future_id: usize);

	#[cxx_name = "rejectFuture"]
	fn reject_future(future_id: usize, error: String);
	}
	}

	#[derive(
	Debug, derive_more::Display, derive_more::From, derive_more::Error,
	)]
	pub enum Error {
	#[display(fmt = "{}", "_0.message()")]
	TonicGRPC(Status),
	#[display(fmt = "{}", "_0")]
	SerdeJson(serde_json::Error),
	#[display(fmt = "Missing response data")]
	MissingResponseData,
	#[display(fmt = "{}", "_0")]
	GRPClient(grpc_clients::error::Error),
	}

	#[cfg(test)]
	#[allow(clippy::assertions_on_constants)]
	mod tests {
	use super::{BACKUP_SOCKET_ADDR, CODE_VERSION, IDENTITY_SOCKET_ADDR};

	#[test]
	fn test_code_version_exists() {
	assert!(CODE_VERSION > 0);
	}

	#[test]
	fn test_identity_socket_addr_exists() {
	assert!(!IDENTITY_SOCKET_ADDR.is_empty());
	assert!(!BACKUP_SOCKET_ADDR.is_empty());
	}
	}
	diff --git a/native/schema/CommRustModuleSchema.js b/native/schema/CommRustModuleSchema.js
	index 024836238..238189434 100644
	--- a/native/schema/CommRustModuleSchema.js
	+++ b/native/schema/CommRustModuleSchema.js
	@@ -1,214 +1,218 @@
	// @flow

	'use strict';

	import { TurboModuleRegistry } from 'react-native';
	import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport.js';

	export interface Spec extends TurboModule {
	+generateNonce: () => Promise<string>;
	+registerPasswordUser: (
	username: string,
	password: string,
	keyPayload: string,
	keyPayloadSignature: string,
	contentPrekey: string,
	contentPrekeySignature: string,
	notifPrekey: string,
	notifPrekeySignature: string,
	contentOneTimeKeys: $ReadOnlyArray<string>,
	notifOneTimeKeys: $ReadOnlyArray<string>,
	farcasterID: string,
	initialDeviceList: string,
	) => Promise<string>;
	+registerReservedPasswordUser: (
	username: string,
	password: string,
	keyPayload: string,
	keyPayloadSignature: string,
	contentPrekey: string,
	contentPrekeySignature: string,
	notifPrekey: string,
	notifPrekeySignature: string,
	contentOneTimeKeys: $ReadOnlyArray<string>,
	notifOneTimeKeys: $ReadOnlyArray<string>,
	keyserverMessage: string,
	keyserverSignature: string,
	initialDeviceList: string,
	) => Promise<string>;
	+logInPasswordUser: (
	username: string,
	password: string,
	keyPayload: string,
	keyPayloadSignature: string,
	contentPrekey: string,
	contentPrekeySignature: string,
	notifPrekey: string,
	notifPrekeySignature: string,
	+ contentOneTimeKeys: $ReadOnlyArray<string>,
	+ notifOneTimeKeys: $ReadOnlyArray<string>,
	) => Promise<string>;
	+registerWalletUser: (
	siweMessage: string,
	siweSignature: string,
	keyPayload: string,
	keyPayloadSignature: string,
	contentPrekey: string,
	contentPrekeySignature: string,
	notifPrekey: string,
	notifPrekeySignature: string,
	contentOneTimeKeys: $ReadOnlyArray<string>,
	notifOneTimeKeys: $ReadOnlyArray<string>,
	farcasterID: string,
	initialDeviceList: string,
	) => Promise<string>;
	+logInWalletUser: (
	siweMessage: string,
	siweSignature: string,
	keyPayload: string,
	keyPayloadSignature: string,
	contentPrekey: string,
	contentPrekeySignature: string,
	notifPrekey: string,
	notifPrekeySignature: string,
	+ contentOneTimeKeys: $ReadOnlyArray<string>,
	+ notifOneTimeKeys: $ReadOnlyArray<string>,
	) => Promise<string>;
	+restoreUser: (
	userID: string,
	siweMessage: ?string,
	siweSignature: ?string,
	keyPayload: string,
	keyPayloadSignature: string,
	contentPrekey: string,
	contentPrekeySignature: string,
	notifPrekey: string,
	notifPrekeySignature: string,
	contentOneTimeKeys: $ReadOnlyArray<string>,
	notifOneTimeKeys: $ReadOnlyArray<string>,
	deviceList: string,
	) => Promise<string>;
	+updatePassword: (
	userID: string,
	deviceID: string,
	accessToken: string,
	oldPassword: string,
	newPassword: string,
	) => Promise<void>;
	+deletePasswordUser: (
	userID: string,
	deviceID: string,
	accessToken: string,
	password: string,
	) => Promise<void>;
	+deleteWalletUser: (
	userID: string,
	deviceID: string,
	accessToken: string,
	) => Promise<void>;
	+logOut: (
	userID: string,
	deviceID: string,
	accessToken: string,
	) => Promise<void>;
	+logOutPrimaryDevice: (
	userID: string,
	deviceID: string,
	accessToken: string,
	signedDeviceList: string,
	) => Promise<void>;
	+logOutSecondaryDevice: (
	userID: string,
	deviceID: string,
	accessToken: string,
	) => Promise<void>;
	+getOutboundKeysForUser: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	userID: string,
	) => Promise<string>;
	+getInboundKeysForUser: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	userID: string,
	) => Promise<string>;
	+versionSupported: () => Promise<boolean>;
	+uploadOneTimeKeys: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	contentOneTimePreKeys: $ReadOnlyArray<string>,
	notifOneTimePreKeys: $ReadOnlyArray<string>,
	) => Promise<void>;
	+getKeyserverKeys: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	keyserverID: string,
	) => Promise<string>;
	+getDeviceListForUser: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	userID: string,
	sinceTimestamp: ?number,
	) => Promise<string>;
	+getDeviceListsForUsers: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	userIDs: $ReadOnlyArray<string>,
	) => Promise<string>;
	+updateDeviceList: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	updatePayload: string,
	) => Promise<void>;
	+syncPlatformDetails: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	) => Promise<void>;
	+uploadSecondaryDeviceKeysAndLogIn: (
	userID: string,
	nonce: string,
	nonceSignature: string,
	keyPayload: string,
	keyPayloadSignature: string,
	contentPrekey: string,
	contentPrekeySignature: string,
	notifPrekey: string,
	notifPrekeySignature: string,
	contentOneTimeKeys: $ReadOnlyArray<string>,
	notifOneTimeKeys: $ReadOnlyArray<string>,
	) => Promise<string>;
	+logInExistingDevice: (
	userID: string,
	deviceID: string,
	nonce: string,
	nonceSignature: string,
	) => Promise<string>;
	+findUserIDForWalletAddress: (walletAddress: string) => Promise<string>;
	+findUserIDForUsername: (username: string) => Promise<string>;
	+getFarcasterUsers: (farcasterIDs: $ReadOnlyArray<string>) => Promise<string>;
	+linkFarcasterAccount: (
	userID: string,
	deviceID: string,
	accessToken: string,
	farcasterID: string,
	) => Promise<void>;
	+unlinkFarcasterAccount: (
	userID: string,
	deviceID: string,
	accessToken: string,
	) => Promise<void>;
	+findUserIdentities: (
	authUserID: string,
	authDeviceID: string,
	authAccessToken: string,
	userIDs: $ReadOnlyArray<string>,
	) => Promise<string>;
	}

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

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 8:49 AM (16 h, 3 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2690665
Default Alt Text: (149 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions