Method createUserKeysBackup

native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp:2440–2492

}

jsi::Value CommCoreModule::createUserKeysBackup(
    jsi::Runtime &rt,
    jsi::String backupSecret) {
  std::string backupSecretStr = backupSecret.utf8(rt);
  return createPromiseAsJSIValue(
      rt, [=](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
        std::string backupMessage;
        try {
          backupMessage = getSIWEBackupMessage();
        } catch (std::system_error &e) {
          this->jsInvoker_->invokeAsync(
              [=, &innerRt]() { promise->reject(e.what()); });
          return;
        }

        this->cryptoThread->scheduleTask([=, &innerRt]() {
          std::string error;
          std::string backupID;
          try {
            backupID = crypto::Tools::generateRandomURLSafeString(32);
          } catch (const std::exception &e) {
            error = "Failed to generate backupID";
          }

          std::string pickleKey;
          std::string pickledAccount;
          if (!error.size()) {
            try {
              pickleKey = crypto::Tools::generateRandomString(64);
              pickledAccount =
                  this->contentCryptoModule->pickleAccountToString(pickleKey);
            } catch (const std::exception &e) {
              error = "Failed to pickle crypto account";
            }
          }

          if (!error.size()) {
            auto currentID = RustPromiseManager::instance.addPromise(
                {promise, this->jsInvoker_, innerRt});
            ::createUserKeysBackup(
                rust::string(backupID),
                rust::string(backupSecretStr),
                rust::string(pickleKey),
                rust::string(pickledAccount),
                rust::string(backupMessage),
                currentID);
          } else {
            this->jsInvoker_->invokeAsync(
                [=, &innerRt]() { promise->reject(error); });
          }
        });
      });
}

jsi::Value CommCoreModule::restoreBackupData(
    jsi::Runtime &rt,