diff --git a/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp b/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
index 9e6bd5ad3..d6c4f5e1b 100644
--- a/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
+++ b/native/cpp/CommonCpp/NativeModules/CommRustModule.cpp
@@ -1,321 +1,361 @@
 #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::registerUser(
     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) {
   return createPromiseAsJSIValue(
       rt,
       [this,
        &username,
        &password,
        &keyPayload,
        &keyPayloadSignature,
        &contentPrekey,
        &contentPrekeySignature,
        &notifPrekey,
        &notifPrekeySignature,
        &contentOneTimeKeys,
        &notifOneTimeKeys](
           jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               promise, this->jsInvoker_, innerRt);
           identityRegisterUser(
               jsiStringToRustString(username, innerRt),
               jsiStringToRustString(password, innerRt),
               jsiStringToRustString(keyPayload, innerRt),
               jsiStringToRustString(keyPayloadSignature, innerRt),
               jsiStringToRustString(contentPrekey, innerRt),
               jsiStringToRustString(contentPrekeySignature, innerRt),
               jsiStringToRustString(notifPrekey, innerRt),
               jsiStringToRustString(notifPrekeySignature, innerRt),
               jsiStringArrayToRustVec(contentOneTimeKeys, innerRt),
               jsiStringArrayToRustVec(notifOneTimeKeys, innerRt),
               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::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys) {
   return createPromiseAsJSIValue(
       rt,
       [this,
        &username,
        &password,
        &keyPayload,
        &keyPayloadSignature,
        &contentPrekey,
        &contentPrekeySignature,
        &notifPrekey,
        &notifPrekeySignature,
        &contentOneTimeKeys,
        &notifOneTimeKeys](
           jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               promise, this->jsInvoker_, innerRt);
           identityLoginPasswordUser(
               jsiStringToRustString(username, innerRt),
               jsiStringToRustString(password, innerRt),
               jsiStringToRustString(keyPayload, innerRt),
               jsiStringToRustString(keyPayloadSignature, innerRt),
               jsiStringToRustString(contentPrekey, innerRt),
               jsiStringToRustString(contentPrekeySignature, innerRt),
               jsiStringToRustString(notifPrekey, innerRt),
               jsiStringToRustString(notifPrekeySignature, innerRt),
               jsiStringArrayToRustVec(contentOneTimeKeys, innerRt),
               jsiStringArrayToRustVec(notifOneTimeKeys, innerRt),
               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::Array contentOneTimeKeys,
     jsi::Array notifOneTimeKeys,
     jsi::String socialProof) {
   return createPromiseAsJSIValue(
       rt,
       [this,
        &siweMessage,
        &siweSignature,
        &keyPayload,
        &keyPayloadSignature,
        &contentPrekey,
        &contentPrekeySignature,
        &notifPrekey,
        &notifPrekeySignature,
        &contentOneTimeKeys,
        &notifOneTimeKeys,
        &socialProof](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               promise, this->jsInvoker_, innerRt);
           identityLoginWalletUser(
               jsiStringToRustString(siweMessage, innerRt),
               jsiStringToRustString(siweSignature, innerRt),
               jsiStringToRustString(keyPayload, innerRt),
               jsiStringToRustString(keyPayloadSignature, innerRt),
               jsiStringToRustString(contentPrekey, innerRt),
               jsiStringToRustString(contentPrekeySignature, innerRt),
               jsiStringToRustString(notifPrekey, innerRt),
               jsiStringToRustString(notifPrekeySignature, innerRt),
               jsiStringArrayToRustVec(contentOneTimeKeys, innerRt),
               jsiStringArrayToRustVec(notifOneTimeKeys, innerRt),
               jsiStringToRustString(socialProof, innerRt),
               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 password) {
   return createPromiseAsJSIValue(
       rt,
       [this, &userID, &deviceID, &accessToken, &password](
           jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               promise, this->jsInvoker_, innerRt);
           identityUpdateUserPassword(
               jsiStringToRustString(userID, innerRt),
               jsiStringToRustString(deviceID, innerRt),
               jsiStringToRustString(accessToken, innerRt),
               jsiStringToRustString(password, innerRt),
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
+        if (!error.empty()) {
+          this->jsInvoker_->invokeAsync(
+              [error, promise]() { promise->reject(error); });
+        }
       });
 }
 
 jsi::Value CommRustModule::deleteUser(
     jsi::Runtime &rt,
     jsi::String userID,
     jsi::String deviceID,
     jsi::String accessToken) {
   return createPromiseAsJSIValue(
       rt,
       [this, &userID, &deviceID, &accessToken](
           jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               promise, this->jsInvoker_, innerRt);
           identityDeleteUser(
               jsiStringToRustString(userID, innerRt),
               jsiStringToRustString(deviceID, innerRt),
               jsiStringToRustString(accessToken, innerRt),
               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) {
   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(
               jsiStringToRustString(authUserID, innerRt),
               jsiStringToRustString(authDeviceID, innerRt),
               jsiStringToRustString(authAccessToken, innerRt),
               jsiStringToRustString(userID, innerRt),
               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) {
   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(
               jsiStringToRustString(authUserID, innerRt),
               jsiStringToRustString(authDeviceID, innerRt),
               jsiStringToRustString(authAccessToken, innerRt),
               jsiStringToRustString(userID, innerRt),
               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) {
   return createPromiseAsJSIValue(
       rt,
       [this,
        &authUserID,
        &authDeviceID,
        &authAccessToken,
        &contentOneTimePreKeys,
        &notifOneTimePreKeys](
           jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
         std::string error;
         try {
           auto currentID = RustPromiseManager::instance.addPromise(
               promise, this->jsInvoker_, innerRt);
           identityUploadOneTimeKeys(
               jsiStringToRustString(authUserID, innerRt),
               jsiStringToRustString(authDeviceID, innerRt),
               jsiStringToRustString(authAccessToken, innerRt),
               jsiStringArrayToRustVec(contentOneTimePreKeys, innerRt),
               jsiStringArrayToRustVec(notifOneTimePreKeys, innerRt),
               currentID);
         } catch (const std::exception &e) {
           error = e.what();
         };
+        if (!error.empty()) {
+          this->jsInvoker_->invokeAsync(
+              [error, promise]() { promise->reject(error); });
+        }
       });
 }
 
 } // namespace comm