Allow to pass error code and message directly to Promise::set_error.

81 files changed, 1468 insertions, 1472 deletions

diff --git a/td/telegram/AccountManager.cpp b/td/telegram/AccountManager.cpp
index 163a03842..784d8e20f 100644
--- a/td/telegram/AccountManager.cpp
+++ b/td/telegram/AccountManager.cpp
@@ -860,11 +860,11 @@ void AccountManager::confirm_qr_code_authentication(const string &link,
                                                     Promise<td_api::object_ptr<td_api::session>> &&promise) {
   Slice prefix("tg://login?token=");
   if (!begins_with(to_lower(link), prefix)) {
-    return promise.set_error(Status::Error(400, "AUTH_TOKEN_INVALID"));
+    return promise.set_error(400, "AUTH_TOKEN_INVALID");
   }
   auto r_token = base64url_decode(Slice(link).substr(prefix.size()));
   if (r_token.is_error()) {
-    return promise.set_error(Status::Error(400, "AUTH_TOKEN_INVALID"));
+    return promise.set_error(400, "AUTH_TOKEN_INVALID");
   }
   td_->create_handler<AcceptLoginTokenQuery>(std::move(promise))->send(r_token.ok());
 }
diff --git a/td/telegram/AlarmManager.cpp b/td/telegram/AlarmManager.cpp
index ab59f4fb2..d237d0896 100644
--- a/td/telegram/AlarmManager.cpp
+++ b/td/telegram/AlarmManager.cpp
@@ -47,7 +47,7 @@ void AlarmManager::on_alarm_timeout(int64 alarm_id) {
 
 void AlarmManager::set_alarm(double seconds, Promise<Unit> &&promise) {
   if (seconds < 0 || seconds > 3e9) {
-    return promise.set_error(Status::Error(400, "Wrong parameter seconds specified"));
+    return promise.set_error(400, "Wrong parameter seconds specified");
   }
 
   auto alarm_id = alarm_id_++;
diff --git a/td/telegram/AnimationsManager.cpp b/td/telegram/AnimationsManager.cpp
index 7309b0c97..2d6acf5d4 100644
--- a/td/telegram/AnimationsManager.cpp
+++ b/td/telegram/AnimationsManager.cpp
@@ -107,7 +107,7 @@ class SaveGifQuery final : public Td::ResultHandler {
           file_id_, PromiseCreator::lambda([animation_id = file_id_, unsave = unsave_,
                                             promise = std::move(promise_)](Result<Unit> result) mutable {
             if (result.is_error()) {
-              return promise.set_error(Status::Error(400, "Failed to find the animation"));
+              return promise.set_error(400, "Failed to find the animation");
             }
 
             send_closure(G()->animations_manager(), &AnimationsManager::send_save_gif_query, animation_id, unsave,
@@ -479,7 +479,7 @@ void AnimationsManager::reload_saved_animations(bool force) {
 
 void AnimationsManager::repair_saved_animations(Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Bots have no saved animations"));
+    return promise.set_error(400, "Bots have no saved animations");
   }
 
   repair_saved_animations_queries_.push_back(std::move(promise));
@@ -672,7 +672,7 @@ void AnimationsManager::add_saved_animation_impl(FileId animation_id, bool add_o
 
   auto file_view = td_->file_manager_->get_file_view(animation_id);
   if (file_view.empty()) {
-    return promise.set_error(Status::Error(400, "Animation file not found"));
+    return promise.set_error(400, "Animation file not found");
   }
 
   LOG(INFO) << "Add saved animation " << animation_id << " with main file " << file_view.get_main_file_id();
@@ -706,21 +706,21 @@ void AnimationsManager::add_saved_animation_impl(FileId animation_id, bool add_o
 
   auto animation = get_animation(animation_id);
   if (animation == nullptr) {
-    return promise.set_error(Status::Error(400, "Animation not found"));
+    return promise.set_error(400, "Animation not found");
   }
   if (animation->mime_type != "video/mp4") {
-    return promise.set_error(Status::Error(400, "Only MPEG4 animations can be saved"));
+    return promise.set_error(400, "Only MPEG4 animations can be saved");
   }
 
   const auto *full_remote_location = file_view.get_full_remote_location();
   if (full_remote_location == nullptr) {
-    return promise.set_error(Status::Error(400, "Can save only sent animations"));
+    return promise.set_error(400, "Can save only sent animations");
   }
   if (full_remote_location->is_web()) {
-    return promise.set_error(Status::Error(400, "Can't save web animations"));
+    return promise.set_error(400, "Can't save web animations");
   }
   if (!full_remote_location->is_document()) {
-    return promise.set_error(Status::Error(400, "Can't save encrypted animations"));
+    return promise.set_error(400, "Can't save encrypted animations");
   }
 
   add_to_top_if(saved_animation_ids_, static_cast<size_t>(saved_animations_limit_), animation_id, is_equal);
@@ -756,7 +756,7 @@ void AnimationsManager::remove_saved_animation(const tl_object_ptr<td_api::Input
 
   auto animation = get_animation(file_id);
   if (animation == nullptr) {
-    return promise.set_error(Status::Error(400, "Animation not found"));
+    return promise.set_error(400, "Animation not found");
   }
 
   send_save_gif_query(file_id, true, std::move(promise));
diff --git a/td/telegram/AttachMenuManager.cpp b/td/telegram/AttachMenuManager.cpp
index f2d59adaf..9218c5530 100644
--- a/td/telegram/AttachMenuManager.cpp
+++ b/td/telegram/AttachMenuManager.cpp
@@ -594,7 +594,7 @@ Result<AttachMenuManager::AttachMenuBot> AttachMenuManager::get_attach_menu_bot(
 
 void AttachMenuManager::reload_attach_menu_bots(Promise<Unit> &&promise) {
   if (!is_active()) {
-    return promise.set_error(Status::Error(400, "Can't reload attachment menu bots"));
+    return promise.set_error(400, "Can't reload attachment menu bots");
   }
 
   reload_attach_menu_bots_queries_.push_back(std::move(promise));
@@ -678,7 +678,7 @@ void AttachMenuManager::get_attach_menu_bot(UserId user_id,
 
   TRY_RESULT_PROMISE(promise, bot_data, td_->user_manager_->get_bot_data(user_id));
   if (!bot_data.can_be_added_to_attach_menu) {
-    return promise.set_error(Status::Error(400, "The bot can't be added to attachment menu"));
+    return promise.set_error(400, "The bot can't be added to attachment menu");
   }
 
   auto query_promise =
@@ -692,7 +692,7 @@ void AttachMenuManager::get_attach_menu_bot(UserId user_id,
 
 void AttachMenuManager::reload_attach_menu_bot(UserId user_id, Promise<Unit> &&promise) {
   if (!is_active()) {
-    return promise.set_error(Status::Error(400, "Can't reload attachment menu bot"));
+    return promise.set_error(400, "Can't reload attachment menu bot");
   }
 
   TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(user_id));
@@ -725,11 +725,11 @@ void AttachMenuManager::on_get_attach_menu_bot(
   auto r_attach_menu_bot = get_attach_menu_bot(std::move(bot->bot_));
   if (r_attach_menu_bot.is_error()) {
     LOG(ERROR) << r_attach_menu_bot.error().message();
-    return promise.set_error(Status::Error(500, "Receive invalid response"));
+    return promise.set_error(500, "Receive invalid response");
   }
   auto attach_menu_bot = r_attach_menu_bot.move_as_ok();
   if (attach_menu_bot.user_id_ != user_id) {
-    return promise.set_error(Status::Error(500, "Receive wrong bot"));
+    return promise.set_error(500, "Receive wrong bot");
   }
   if (attach_menu_bot.is_added_) {
     bool is_found = false;
@@ -782,7 +782,7 @@ void AttachMenuManager::toggle_bot_is_added_to_attach_menu(UserId user_id, bool
   if (is_added) {
     TRY_RESULT_PROMISE(promise, bot_data, td_->user_manager_->get_bot_data(user_id));
     if (!bot_data.can_be_added_to_attach_menu) {
-      return promise.set_error(Status::Error(400, "The bot can't be added to attachment menu"));
+      return promise.set_error(400, "The bot can't be added to attachment menu");
     }
   } else {
     remove_bot_from_attach_menu(user_id);
diff --git a/td/telegram/AutosaveManager.cpp b/td/telegram/AutosaveManager.cpp
index 85c2e2d77..388192549 100644
--- a/td/telegram/AutosaveManager.cpp
+++ b/td/telegram/AutosaveManager.cpp
@@ -440,10 +440,10 @@ void AutosaveManager::set_autosave_settings(td_api::object_ptr<td_api::AutosaveS
                                             td_api::object_ptr<td_api::scopeAutosaveSettings> &&settings,
                                             Promise<Unit> &&promise) {
   if (scope == nullptr) {
-    return promise.set_error(Status::Error(400, "Scope must be non-empty"));
+    return promise.set_error(400, "Scope must be non-empty");
   }
   if (!settings_.are_inited_) {
-    return promise.set_error(Status::Error(400, "Autosave settings must be loaded first"));
+    return promise.set_error(400, "Autosave settings must be loaded first");
   }
   auto new_settings = DialogAutosaveSettings(settings.get());
   DialogAutosaveSettings *old_settings = nullptr;
@@ -497,7 +497,7 @@ void AutosaveManager::set_autosave_settings(td_api::object_ptr<td_api::AutosaveS
 
 void AutosaveManager::clear_autosave_settings_exceptions(Promise<Unit> &&promise) {
   if (!settings_.are_inited_) {
-    return promise.set_error(Status::Error(400, "Autosave settings must be loaded first"));
+    return promise.set_error(400, "Autosave settings must be loaded first");
   }
   for (const auto &exception : settings_.exceptions_) {
     send_update_autosave_settings(td_api::make_object<td_api::autosaveSettingsScopeChat>(exception.first.get()),
diff --git a/td/telegram/BackgroundManager.cpp b/td/telegram/BackgroundManager.cpp
index c8dce7e15..eab448e86 100644
--- a/td/telegram/BackgroundManager.cpp
+++ b/td/telegram/BackgroundManager.cpp
@@ -550,7 +550,7 @@ std::pair<BackgroundId, BackgroundType> BackgroundManager::search_background(con
   }
 
   if (slug.empty()) {
-    promise.set_error(Status::Error(400, "Background name must be non-empty"));
+    promise.set_error(400, "Background name must be non-empty");
     return {};
   }
 
@@ -694,10 +694,10 @@ void BackgroundManager::set_background(const td_api::InputBackground *input_back
 
   if (input_background == nullptr) {
     if (type.has_file() || background_type == nullptr) {
-      return promise.set_error(Status::Error(400, "Input background must be non-empty for the background type"));
+      return promise.set_error(400, "Input background must be non-empty for the background type");
     }
     if (background_type->get_id() == td_api::backgroundTypeChatTheme::ID) {
-      return promise.set_error(Status::Error(400, "Background type isn't supported"));
+      return promise.set_error(400, "Background type isn't supported");
     }
 
     auto background_id = add_local_background(type);
@@ -712,7 +712,7 @@ void BackgroundManager::set_background(const td_api::InputBackground *input_back
   switch (input_background->get_id()) {
     case td_api::inputBackgroundLocal::ID: {
       if (!type.has_file()) {
-        return promise.set_error(Status::Error(400, "Can't specify local file for the background type"));
+        return promise.set_error(400, "Can't specify local file for the background type");
       }
       CHECK(background_type != nullptr);
 
@@ -735,7 +735,7 @@ void BackgroundManager::set_background(const td_api::InputBackground *input_back
                             std::move(promise));
     }
     case td_api::inputBackgroundPrevious::ID:
-      return promise.set_error(Status::Error(400, "Can't use a previous background"));
+      return promise.set_error(400, "Can't use a previous background");
     default:
       UNREACHABLE();
   }
@@ -784,7 +784,7 @@ void BackgroundManager::set_dialog_background(DialogId dialog_id, const td_api::
 
   if (input_background == nullptr) {
     if (type.has_file() || background_type == nullptr) {
-      return promise.set_error(Status::Error(400, "Input background must be non-empty for the background type"));
+      return promise.set_error(400, "Input background must be non-empty for the background type");
     }
     return send_set_dialog_background_query(dialog_id, telegram_api::make_object<telegram_api::inputWallPaperNoFile>(0),
                                             type.get_input_wallpaper_settings(), MessageId(), for_both,
@@ -794,7 +794,7 @@ void BackgroundManager::set_dialog_background(DialogId dialog_id, const td_api::
   switch (input_background->get_id()) {
     case td_api::inputBackgroundLocal::ID: {
       if (!type.has_file()) {
-        return promise.set_error(Status::Error(400, "Can't specify local file for the background type"));
+        return promise.set_error(400, "Can't specify local file for the background type");
       }
       CHECK(background_type != nullptr);
 
@@ -829,7 +829,7 @@ void BackgroundManager::set_dialog_background(DialogId dialog_id, const td_api::
       auto background_previous = static_cast<const td_api::inputBackgroundPrevious *>(input_background);
       MessageId message_id(background_previous->message_id_);
       if (!message_id.is_valid() || !message_id.is_server()) {
-        return promise.set_error(Status::Error(400, "Invalid message identifier specified"));
+        return promise.set_error(400, "Invalid message identifier specified");
       }
       return send_set_dialog_background_query(
           dialog_id, nullptr, background_type == nullptr ? nullptr : type.get_input_wallpaper_settings(), message_id,
@@ -851,12 +851,12 @@ void BackgroundManager::do_set_dialog_background(DialogId dialog_id, BackgroundI
   TRY_STATUS_PROMISE(promise, G()->close_status());
   const auto *background = get_background(background_id);
   if (background == nullptr) {
-    return promise.set_error(Status::Error(400, "Background to set not found"));
+    return promise.set_error(400, "Background to set not found");
   }
   if (!type.has_file()) {
     type = background->type;
   } else if (!background->type.has_equal_type(type)) {
-    return promise.set_error(Status::Error(400, "Background type mismatch"));
+    return promise.set_error(400, "Background type mismatch");
   }
 
   send_set_dialog_background_query(
@@ -877,12 +877,12 @@ void BackgroundManager::set_background(BackgroundId background_id, BackgroundTyp
   LOG(INFO) << "Set " << background_id << " with " << type;
   const auto *background = get_background(background_id);
   if (background == nullptr) {
-    return promise.set_error(Status::Error(400, "Background to set not found"));
+    return promise.set_error(400, "Background to set not found");
   }
   if (!type.has_file()) {
     type = background->type;
   } else if (!background->type.has_equal_type(type)) {
-    return promise.set_error(Status::Error(400, "Background type mismatch"));
+    return promise.set_error(400, "Background type mismatch");
   }
   if (set_background_id_[for_dark_theme] == background_id && set_background_type_[for_dark_theme] == type) {
     return promise.set_value(get_background_object(background_id, for_dark_theme, nullptr));
@@ -1025,8 +1025,8 @@ void BackgroundManager::on_upload_background_file_error(FileUploadId file_upload
 
   being_uploaded_files_.erase(it);
 
-  promise.set_error(Status::Error(status.code() > 0 ? status.code() : 500,
-                                  status.message()));  // TODO CHECK that status has always a code
+  promise.set_error(status.code() > 0 ? status.code() : 500,
+                    status.message());  // TODO CHECK that status has always a code
 }
 
 void BackgroundManager::do_upload_background_file(FileUploadId file_upload_id, const BackgroundType &type,
@@ -1044,7 +1044,7 @@ void BackgroundManager::do_upload_background_file(FileUploadId file_upload_id, c
       }
       return set_background(it->second, type, for_dark_theme, std::move(promise));
     }
-    return promise.set_error(Status::Error(500, "Failed to reupload background"));
+    return promise.set_error(500, "Failed to reupload background");
   }
 
   td_->create_handler<UploadBackgroundQuery>(std::move(promise))
@@ -1061,7 +1061,7 @@ void BackgroundManager::on_uploaded_background_file(FileUploadId file_upload_id,
   auto background_id = added_background.first;
   if (!background_id.is_valid()) {
     td_->file_manager_->cancel_upload(file_upload_id);
-    return promise.set_error(Status::Error(500, "Receive wrong uploaded background"));
+    return promise.set_error(500, "Receive wrong uploaded background");
   }
   LOG_IF(ERROR, added_background.second != type)
       << "Type of uploaded background has changed from " << type << " to " << added_background.second;
@@ -1070,7 +1070,7 @@ void BackgroundManager::on_uploaded_background_file(FileUploadId file_upload_id,
   CHECK(background != nullptr);
   if (!background->file_id.is_valid()) {
     td_->file_manager_->cancel_upload(file_upload_id);
-    return promise.set_error(Status::Error(500, "Receive wrong uploaded background without file"));
+    return promise.set_error(500, "Receive wrong uploaded background without file");
   }
   LOG_STATUS(td_->file_manager_->merge(background->file_id, file_upload_id.get_file_id()));
   td_->file_manager_->cancel_upload(file_upload_id);
@@ -1083,7 +1083,7 @@ void BackgroundManager::on_uploaded_background_file(FileUploadId file_upload_id,
 void BackgroundManager::remove_background(BackgroundId background_id, Promise<Unit> &&promise) {
   const auto *background = get_background(background_id);
   if (background == nullptr) {
-    return promise.set_error(Status::Error(400, "Background not found"));
+    return promise.set_error(400, "Background not found");
   }
 
   auto query_promise = PromiseCreator::lambda(
diff --git a/td/telegram/BoostManager.cpp b/td/telegram/BoostManager.cpp
index fc41e1ea4..a9be45b28 100644
--- a/td/telegram/BoostManager.cpp
+++ b/td/telegram/BoostManager.cpp
@@ -458,7 +458,7 @@ Result<std::pair<string, bool>> BoostManager::get_dialog_boost_link(DialogId dia
 void BoostManager::get_dialog_boost_link_info(Slice url, Promise<DialogBoostLinkInfo> &&promise) {
   auto r_dialog_boost_link_info = LinkManager::get_dialog_boost_link_info(url);
   if (r_dialog_boost_link_info.is_error()) {
-    return promise.set_error(Status::Error(400, r_dialog_boost_link_info.error().message()));
+    return promise.set_error(400, r_dialog_boost_link_info.error().message());
   }
 
   auto info = r_dialog_boost_link_info.move_as_ok();
@@ -483,7 +483,7 @@ void BoostManager::get_dialog_boosts(DialogId dialog_id, bool only_gift_codes, c
   TRY_STATUS_PROMISE(
       promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Read, "get_dialog_boosts"));
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
 
   td_->create_handler<GetBoostsListQuery>(std::move(promise))->send(dialog_id, only_gift_codes, offset, limit);
@@ -494,7 +494,7 @@ void BoostManager::get_user_dialog_boosts(DialogId dialog_id, UserId user_id,
   TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Read,
                                                                         "get_user_dialog_boosts"));
   if (!user_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "User not found"));
+    return promise.set_error(400, "User not found");
   }
 
   td_->create_handler<GetUserBoostsQuery>(std::move(promise))->send(dialog_id, user_id);
diff --git a/td/telegram/BotCommand.cpp b/td/telegram/BotCommand.cpp
index 9f215acc4..d4b84c528 100644
--- a/td/telegram/BotCommand.cpp
+++ b/td/telegram/BotCommand.cpp
@@ -172,13 +172,13 @@ void set_commands(Td *td, td_api::object_ptr<td_api::BotCommandScope> &&scope_pt
   vector<BotCommand> new_commands;
   for (auto &command : commands) {
     if (command == nullptr) {
-      return promise.set_error(Status::Error(400, "Command must be non-empty"));
+      return promise.set_error(400, "Command must be non-empty");
     }
     if (!clean_input_string(command->command_)) {
-      return promise.set_error(Status::Error(400, "Command must be encoded in UTF-8"));
+      return promise.set_error(400, "Command must be encoded in UTF-8");
     }
     if (!clean_input_string(command->description_)) {
-      return promise.set_error(Status::Error(400, "Command description must be encoded in UTF-8"));
+      return promise.set_error(400, "Command description must be encoded in UTF-8");
     }
 
     const size_t MAX_COMMAND_TEXT_LENGTH = 32;
@@ -187,22 +187,21 @@ void set_commands(Td *td, td_api::object_ptr<td_api::BotCommandScope> &&scope_pt
       command->command_ = command->command_.substr(1);
     }
     if (command->command_.empty()) {
-      return promise.set_error(Status::Error(400, "Command must be non-empty"));
+      return promise.set_error(400, "Command must be non-empty");
     }
     if (utf8_length(command->command_) > MAX_COMMAND_TEXT_LENGTH) {
-      return promise.set_error(
-          Status::Error(400, PSLICE() << "Command length must not exceed " << MAX_COMMAND_TEXT_LENGTH));
+      return promise.set_error(400, PSLICE() << "Command length must not exceed " << MAX_COMMAND_TEXT_LENGTH);
     }
 
     const size_t MAX_COMMAND_DESCRIPTION_LENGTH = 256;
     command->description_ = trim(command->description_);
     auto description_length = utf8_length(command->description_);
     if (command->description_.empty()) {
-      return promise.set_error(Status::Error(400, "Command description must be non-empty"));
+      return promise.set_error(400, "Command description must be non-empty");
     }
     if (description_length > MAX_COMMAND_DESCRIPTION_LENGTH) {
-      return promise.set_error(Status::Error(
-          400, PSLICE() << "Command description length must not exceed " << MAX_COMMAND_DESCRIPTION_LENGTH));
+      return promise.set_error(
+          400, PSLICE() << "Command description length must not exceed " << MAX_COMMAND_DESCRIPTION_LENGTH);
     }
 
     new_commands.emplace_back(std::move(command->command_), std::move(command->description_));
diff --git a/td/telegram/BotInfoManager.cpp b/td/telegram/BotInfoManager.cpp
index d3b2c4fa0..fb048fea7 100644
--- a/td/telegram/BotInfoManager.cpp
+++ b/td/telegram/BotInfoManager.cpp
@@ -285,7 +285,7 @@ class BotInfoManager::AddPreviewMediaQuery final : public Td::ResultHandler {
     auto preview = convert_bot_media_preview(td_, std::move(ptr), bot_user_id, file_ids);
     if (preview == nullptr) {
       LOG(ERROR) << "Receive invalid sent media preview";
-      return pending_preview_->promise_.set_error(Status::Error(500, "Receive invalid preview"));
+      return pending_preview_->promise_.set_error(500, "Receive invalid preview");
     }
     if (!file_ids.empty()) {
       auto file_source_id = td_->bot_info_manager_->get_bot_media_preview_info_file_source_id(
@@ -399,7 +399,7 @@ class CanBotSendMessageQuery final : public Td::ResultHandler {
     if (result_ptr.ok()) {
       promise_.set_value(Unit());
     } else {
-      promise_.set_error(Status::Error(404, "Not Found"));
+      promise_.set_error(404, "Not Found");
     }
   }
 
@@ -861,7 +861,7 @@ void BotInfoManager::edit_bot_media_preview(UserId bot_user_id, const string &la
   TRY_RESULT_PROMISE(promise, content, get_input_story_content(td_, std::move(input_content), DialogId(bot_user_id)));
   auto input_media = get_fake_input_media(file_id);
   if (input_media == nullptr) {
-    return promise.set_error(Status::Error(400, "Wrong media to edit specified"));
+    return promise.set_error(400, "Wrong media to edit specified");
   }
   auto pending_preview = make_unique<PendingBotMediaPreview>();
   pending_preview->edited_file_id_ = file_id;
@@ -914,10 +914,10 @@ void BotInfoManager::on_upload_bot_media_preview(FileUploadId file_upload_id,
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (input_file == nullptr && main_remote_location != nullptr) {
     if (main_remote_location->is_web()) {
-      return pending_preview->promise_.set_error(Status::Error(400, "Can't use web photo as a preview"));
+      return pending_preview->promise_.set_error(400, "Can't use web photo as a preview");
     }
     if (pending_preview->was_reuploaded_) {
-      return pending_preview->promise_.set_error(Status::Error(500, "Failed to reupload preview"));
+      return pending_preview->promise_.set_error(500, "Failed to reupload preview");
     }
     pending_preview->was_reuploaded_ = true;
 
@@ -983,7 +983,7 @@ void BotInfoManager::reorder_bot_media_previews(UserId bot_user_id, const string
   for (auto file_id : file_ids) {
     auto input_media = get_fake_input_media(FileId(file_id, 0));
     if (input_media == nullptr) {
-      return promise.set_error(Status::Error(400, "Wrong media to delete specified"));
+      return promise.set_error(400, "Wrong media to delete specified");
     }
     input_medias.push_back(std::move(input_media));
   }
@@ -1002,7 +1002,7 @@ void BotInfoManager::delete_bot_media_previews(UserId bot_user_id, const string
   for (auto file_id : file_ids) {
     auto input_media = get_fake_input_media(FileId(file_id, 0));
     if (input_media == nullptr) {
-      return promise.set_error(Status::Error(400, "Wrong media to delete specified"));
+      return promise.set_error(400, "Wrong media to delete specified");
     }
     input_medias.push_back(std::move(input_media));
   }
@@ -1067,7 +1067,7 @@ void BotInfoManager::set_custom_bot_verification(UserId bot_user_id, DialogId di
     TRY_RESULT_PROMISE_ASSIGN(promise, bot_input_user, td_->user_manager_->get_input_user(bot_user_id));
   }
   if (!td_->dialog_manager_->have_input_peer(dialog_id, false, AccessRights::Read)) {
-    return promise.set_error(Status::Error(400, "Can't access the verified entity"));
+    return promise.set_error(400, "Can't access the verified entity");
   }
   td_->create_handler<SetCustomVerificationQuery>(std::move(promise))
       ->send(std::move(bot_input_user), dialog_id, is_verified, custom_description);
diff --git a/td/telegram/BotMenuButton.cpp b/td/telegram/BotMenuButton.cpp
index af77eb204..f42ae5df9 100644
--- a/td/telegram/BotMenuButton.cpp
+++ b/td/telegram/BotMenuButton.cpp
@@ -126,7 +126,7 @@ td_api::object_ptr<td_api::botMenuButton> get_bot_menu_button_object(Td *td, con
 void set_menu_button(Td *td, UserId user_id, td_api::object_ptr<td_api::botMenuButton> &&menu_button,
                      Promise<Unit> &&promise) {
   if (!user_id.is_valid() && user_id != UserId()) {
-    return promise.set_error(Status::Error(400, "User not found"));
+    return promise.set_error(400, "User not found");
   }
 
   telegram_api::object_ptr<telegram_api::BotMenuButton> input_bot_menu_button;
@@ -134,19 +134,19 @@ void set_menu_button(Td *td, UserId user_id, td_api::object_ptr<td_api::botMenuB
     input_bot_menu_button = telegram_api::make_object<telegram_api::botMenuButtonCommands>();
   } else if (menu_button->text_.empty()) {
     if (menu_button->url_ != "default") {
-      return promise.set_error(Status::Error(400, "Menu button text must be non-empty"));
+      return promise.set_error(400, "Menu button text must be non-empty");
     }
     input_bot_menu_button = telegram_api::make_object<telegram_api::botMenuButtonDefault>();
   } else {
     if (!clean_input_string(menu_button->text_)) {
-      return promise.set_error(Status::Error(400, "Menu button text must be encoded in UTF-8"));
+      return promise.set_error(400, "Menu button text must be encoded in UTF-8");
     }
     if (!clean_input_string(menu_button->url_)) {
-      return promise.set_error(Status::Error(400, "Menu button URL must be encoded in UTF-8"));
+      return promise.set_error(400, "Menu button URL must be encoded in UTF-8");
     }
     auto r_url = LinkManager::check_link(menu_button->url_, true, !G()->is_test_dc());
     if (r_url.is_error()) {
-      return promise.set_error(Status::Error(400, PSLICE() << "Menu button Web App " << r_url.error().message()));
+      return promise.set_error(400, PSLICE() << "Menu button Web App " << r_url.error().message());
     }
     input_bot_menu_button = telegram_api::make_object<telegram_api::botMenuButton>(menu_button->text_, r_url.ok());
   }
@@ -156,7 +156,7 @@ void set_menu_button(Td *td, UserId user_id, td_api::object_ptr<td_api::botMenuB
 
 void get_menu_button(Td *td, UserId user_id, Promise<td_api::object_ptr<td_api::botMenuButton>> &&promise) {
   if (!user_id.is_valid() && user_id != UserId()) {
-    return promise.set_error(Status::Error(400, "User not found"));
+    return promise.set_error(400, "User not found");
   }
 
   td->create_handler<GetBotMenuButtonQuery>(std::move(promise))->send(user_id);
diff --git a/td/telegram/BotRecommendationManager.cpp b/td/telegram/BotRecommendationManager.cpp
index 2832854a5..80f7ebcbc 100644
--- a/td/telegram/BotRecommendationManager.cpp
+++ b/td/telegram/BotRecommendationManager.cpp
@@ -139,10 +139,10 @@ void BotRecommendationManager::get_bot_recommendations(UserId bot_user_id, bool
   }
   if (!td_->user_manager_->is_user_bot(bot_user_id)) {
     if (users_promise) {
-      users_promise.set_error(Status::Error(400, "Bot not found"));
+      users_promise.set_error(400, "Bot not found");
     }
     if (count_promise) {
-      count_promise.set_error(Status::Error(400, "Bot not found"));
+      count_promise.set_error(400, "Bot not found");
     }
     return;
   }
@@ -354,7 +354,7 @@ void BotRecommendationManager::on_get_bot_recommendations(
 void BotRecommendationManager::open_bot_recommended_bot(UserId bot_user_id, UserId opened_bot_user_id,
                                                         Promise<Unit> &&promise) {
   if (!td_->user_manager_->is_user_bot(bot_user_id) || !td_->user_manager_->is_user_bot(opened_bot_user_id)) {
-    return promise.set_error(Status::Error(400, "Bot not found"));
+    return promise.set_error(400, "Bot not found");
   }
   vector<telegram_api::object_ptr<telegram_api::jsonObjectValue>> data;
   data.push_back(telegram_api::make_object<telegram_api::jsonObjectValue>(
diff --git a/td/telegram/BusinessConnectionManager.cpp b/td/telegram/BusinessConnectionManager.cpp
index 43873edf7..594deba6a 100644
--- a/td/telegram/BusinessConnectionManager.cpp
+++ b/td/telegram/BusinessConnectionManager.cpp
@@ -864,13 +864,13 @@ class GetBusinessStarTransferPaymentFormQuery final : public Td::ResultHandler {
     switch (payment_form_ptr->get_id()) {
       case telegram_api::payments_paymentForm::ID:
         LOG(ERROR) << "Receive " << to_string(payment_form_ptr);
-        promise_.set_error(Status::Error(500, "Unsupported"));
+        promise_.set_error(500, "Unsupported");
         break;
       case telegram_api::payments_paymentFormStars::ID: {
         auto payment_form = static_cast<const telegram_api::payments_paymentFormStars *>(payment_form_ptr.get());
         if (payment_form->invoice_->prices_.size() != 1u ||
             payment_form->invoice_->prices_[0]->amount_ != star_count_) {
-          return promise_.set_error(Status::Error(400, "Wrong transfer price specified"));
+          return promise_.set_error(400, "Wrong transfer price specified");
         }
         td_->create_handler<TransferBusinessStarsQuery>(std::move(promise_))
             ->send(business_connection_id_, payment_form->form_id_, star_count_);
@@ -880,7 +880,7 @@ class GetBusinessStarTransferPaymentFormQuery final : public Td::ResultHandler {
         auto payment_form = static_cast<const telegram_api::payments_paymentFormStarGift *>(payment_form_ptr.get());
         if (payment_form->invoice_->prices_.size() != 1u ||
             payment_form->invoice_->prices_[0]->amount_ != star_count_) {
-          return promise_.set_error(Status::Error(400, "Wrong transfer price specified"));
+          return promise_.set_error(400, "Wrong transfer price specified");
         }
         td_->create_handler<TransferBusinessStarsQuery>(std::move(promise_))
             ->send(business_connection_id_, payment_form->form_id_, star_count_);
@@ -1075,7 +1075,7 @@ void BusinessConnectionManager::get_business_connection(
   }
 
   if (connection_id.is_empty()) {
-    return promise.set_error(Status::Error(400, "Connection iedntifier must be non-empty"));
+    return promise.set_error(400, "Connection iedntifier must be non-empty");
   }
 
   auto &queries = get_business_connection_queries_[connection_id];
@@ -1298,7 +1298,7 @@ void BusinessConnectionManager::do_send_message(unique_ptr<PendingMessage> &&mes
   }
   if (content_type == MessageContentType::Game || content_type == MessageContentType::Poll ||
       content_type == MessageContentType::Story) {
-    return promise.set_error(Status::Error(400, "Message has no file"));
+    return promise.set_error(400, "Message has no file");
   }
   upload_media(std::move(message), PromiseCreator::lambda([actor_id = actor_id(this), promise = std::move(promise)](
                                                               Result<UploadMediaResult> &&result) mutable {
@@ -1317,13 +1317,13 @@ void BusinessConnectionManager::process_sent_business_message(
     Promise<td_api::object_ptr<td_api::businessMessage>> &&promise) {
   if (updates_ptr->get_id() != telegram_api::updates::ID) {
     LOG(ERROR) << "Receive " << to_string(updates_ptr);
-    return promise.set_error(Status::Error(500, "Receive invalid business connection messages"));
+    return promise.set_error(500, "Receive invalid business connection messages");
   }
   auto updates = telegram_api::move_object_as<telegram_api::updates>(updates_ptr);
   if (updates->updates_.size() != 1 ||
       updates->updates_[0]->get_id() != telegram_api::updateBotNewBusinessMessage::ID) {
     LOG(ERROR) << "Receive " << to_string(updates);
-    return promise.set_error(Status::Error(500, "Receive invalid business connection messages"));
+    return promise.set_error(500, "Receive invalid business connection messages");
   }
   auto update = telegram_api::move_object_as<telegram_api::updateBotNewBusinessMessage>(updates->updates_[0]);
 
@@ -1341,11 +1341,11 @@ void BusinessConnectionManager::upload_media(unique_ptr<PendingMessage> &&messag
   CHECK(file_id.is_valid());
   FileView file_view = td_->file_manager_->get_file_view(file_id);
   if (file_view.is_encrypted()) {
-    return promise.set_error(Status::Error(400, "Can't use encrypted file"));
+    return promise.set_error(400, "Can't use encrypted file");
   }
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (main_remote_location != nullptr && main_remote_location->is_web()) {
-    return promise.set_error(Status::Error(400, "Can't use a web file"));
+    return promise.set_error(400, "Can't use a web file");
   }
 
   BeingUploadedMedia media;
@@ -1489,7 +1489,7 @@ void BusinessConnectionManager::complete_upload_media(unique_ptr<PendingMessage>
   auto input_media =
       get_message_content_input_media(message->content_.get(), td_, message->ttl_, message->send_emoji_, true);
   if (input_media == nullptr) {
-    return promise.set_error(Status::Error(400, "Failed to upload file"));
+    return promise.set_error(400, "Failed to upload file");
   }
   UploadMediaResult result;
   result.message_ = std::move(message);
@@ -1635,13 +1635,13 @@ void BusinessConnectionManager::process_sent_business_message_album(
     Promise<td_api::object_ptr<td_api::businessMessages>> &&promise) {
   if (updates_ptr->get_id() != telegram_api::updates::ID) {
     LOG(ERROR) << "Receive " << to_string(updates_ptr);
-    return promise.set_error(Status::Error(500, "Receive invalid business connection messages"));
+    return promise.set_error(500, "Receive invalid business connection messages");
   }
   auto updates = telegram_api::move_object_as<telegram_api::updates>(updates_ptr);
   for (auto &update : updates->updates_) {
     if (update->get_id() != telegram_api::updateBotNewBusinessMessage::ID) {
       LOG(ERROR) << "Receive " << to_string(updates);
-      return promise.set_error(Status::Error(500, "Receive invalid business connection messages"));
+      return promise.set_error(500, "Receive invalid business connection messages");
     }
   }
   td_->user_manager_->on_get_users(std::move(updates->users_), "process_sent_business_message_album");
@@ -1719,11 +1719,11 @@ void BusinessConnectionManager::edit_business_message_text(
   TRY_STATUS_PROMISE(promise, check_business_message_id(message_id));
 
   if (input_message_content == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't edit message without new content"));
+    return promise.set_error(400, "Can't edit message without new content");
   }
   int32 new_message_content_type = input_message_content->get_id();
   if (new_message_content_type != td_api::inputMessageText::ID) {
-    return promise.set_error(Status::Error(400, "Input message content type must be InputMessageText"));
+    return promise.set_error(400, "Input message content type must be InputMessageText");
   }
 
   TRY_RESULT_PROMISE(
@@ -1751,7 +1751,7 @@ void BusinessConnectionManager::edit_business_message_live_location(
 
   Location location(input_location);
   if (location.empty() && input_location != nullptr) {
-    return promise.set_error(Status::Error(400, "Invalid location specified"));
+    return promise.set_error(400, "Invalid location specified");
   }
 
   TRY_RESULT_PROMISE(promise, new_reply_markup,
@@ -1783,7 +1783,7 @@ void BusinessConnectionManager::edit_business_message_media(
   TRY_STATUS_PROMISE(promise, check_business_message_id(message_id));
 
   if (input_message_content == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't edit message without new content"));
+    return promise.set_error(400, "Can't edit message without new content");
   }
   int32 new_message_content_type = input_message_content->get_id();
   if (new_message_content_type != td_api::inputMessageAnimation::ID &&
@@ -1791,14 +1791,14 @@ void BusinessConnectionManager::edit_business_message_media(
       new_message_content_type != td_api::inputMessageDocument::ID &&
       new_message_content_type != td_api::inputMessagePhoto::ID &&
       new_message_content_type != td_api::inputMessageVideo::ID) {
-    return promise.set_error(Status::Error(400, "Unsupported input message content type"));
+    return promise.set_error(400, "Unsupported input message content type");
   }
 
   bool is_premium = td_->option_manager_->get_option_boolean("is_premium");
   TRY_RESULT_PROMISE(promise, content,
                      get_input_message_content(DialogId(), std::move(input_message_content), td_, is_premium));
   if (!content.ttl.is_empty()) {
-    return promise.set_error(Status::Error(400, "Can't enable self-destruction for media"));
+    return promise.set_error(400, "Can't enable self-destruction for media");
   }
 
   TRY_RESULT_PROMISE(promise, new_reply_markup,
@@ -1915,7 +1915,7 @@ void BusinessConnectionManager::delete_business_messages(BusinessConnectionId bu
     TRY_STATUS_PROMISE(promise, check_business_message_id(message_id));
   }
   if (message_ids.size() > 100u) {
-    return promise.set_error(Status::Error(400, "Too many messages identifiers specified"));
+    return promise.set_error(400, "Too many messages identifiers specified");
   }
 
   td_->create_handler<DeleteBusinessMessagesQuery>(std::move(promise))->send(business_connection_id, message_ids);
@@ -1951,7 +1951,7 @@ void BusinessConnectionManager::set_business_username(BusinessConnectionId busin
                                                       const string &username, Promise<Unit> &&promise) {
   TRY_STATUS_PROMISE(promise, check_business_connection(business_connection_id));
   if (!username.empty() && !is_allowed_username(username)) {
-    return promise.set_error(Status::Error(400, "Username is invalid"));
+    return promise.set_error(400, "Username is invalid");
   }
   auto user_id = get_business_connection_user_id(business_connection_id);
 
@@ -1977,7 +1977,7 @@ void BusinessConnectionManager::transfer_business_stars(BusinessConnectionId bus
                                                         Promise<Unit> &&promise) {
   TRY_STATUS_PROMISE(promise, check_business_connection(business_connection_id));
   if (star_count <= 0 || star_count > 1000000000) {
-    return promise.set_error(Status::Error(400, "Invalid amount of Telegram Stars to transfer specified"));
+    return promise.set_error(400, "Invalid amount of Telegram Stars to transfer specified");
   }
 
   td_->create_handler<GetBusinessStarTransferPaymentFormQuery>(std::move(promise))
diff --git a/td/telegram/BusinessManager.cpp b/td/telegram/BusinessManager.cpp
index 2933a1b9a..6a8fa51e9 100644
--- a/td/telegram/BusinessManager.cpp
+++ b/td/telegram/BusinessManager.cpp
@@ -541,7 +541,7 @@ void BusinessManager::get_business_connected_bot(Promise<td_api::object_ptr<td_a
 void BusinessManager::set_business_connected_bot(td_api::object_ptr<td_api::businessConnectedBot> &&bot,
                                                  Promise<Unit> &&promise) {
   if (bot == nullptr) {
-    return promise.set_error(Status::Error(400, "Bot must be non-empty"));
+    return promise.set_error(400, "Bot must be non-empty");
   }
   BusinessConnectedBot connected_bot(std::move(bot));
   TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(connected_bot.get_user_id()));
@@ -559,7 +559,7 @@ void BusinessManager::toggle_business_connected_bot_dialog_is_paused(DialogId di
                      td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Write,
                                                                "toggle_business_connected_bot_dialog_is_paused"));
   if (dialog_id.get_type() != DialogType::User) {
-    return promise.set_error(Status::Error(400, "The chat has no connected bot"));
+    return promise.set_error(400, "The chat has no connected bot");
   }
   td_->messages_manager_->on_update_dialog_business_bot_is_paused(dialog_id, is_paused);
   td_->create_handler<ToggleConnectedBotPausedQuery>(std::move(promise))->send(dialog_id, is_paused);
@@ -569,7 +569,7 @@ void BusinessManager::remove_business_connected_bot_from_dialog(DialogId dialog_
   TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Write,
                                                                         "remove_business_connected_bot_from_dialog"));
   if (dialog_id.get_type() != DialogType::User) {
-    return promise.set_error(Status::Error(400, "The chat has no connected bot"));
+    return promise.set_error(400, "The chat has no connected bot");
   }
   td_->messages_manager_->on_update_dialog_business_bot_removed(dialog_id);
   td_->create_handler<DisablePeerConnectedBotQuery>(std::move(promise))->send(dialog_id);
diff --git a/td/telegram/CallActor.cpp b/td/telegram/CallActor.cpp
index 8ff7ad73e..8bb4ba440 100644
--- a/td/telegram/CallActor.cpp
+++ b/td/telegram/CallActor.cpp
@@ -206,7 +206,7 @@ void CallActor::create_call(UserId user_id, CallProtocol &&protocol, bool is_vid
 
 void CallActor::accept_call(CallProtocol &&protocol, Promise<Unit> promise) {
   if (state_ != State::SendAcceptQuery) {
-    return promise.set_error(Status::Error(400, "Unexpected acceptCall"));
+    return promise.set_error(400, "Unexpected acceptCall");
   }
   is_accepted_ = true;
   call_state_.protocol = std::move(protocol);
@@ -229,7 +229,7 @@ void CallActor::update_call_signaling_data(string data) {
 void CallActor::send_call_signaling_data(string &&data, Promise<Unit> promise) {
   if (call_state_.type != CallState::Type::Ready &&
       call_state_.discard_reason.type_ != CallDiscardReason::Type::UpgradeToGroupCall) {
-    return promise.set_error(Status::Error(400, "Call is not active"));
+    return promise.set_error(400, "Call is not active");
   }
 
   auto query = G()->net_query_creator().create(
@@ -268,7 +268,7 @@ void CallActor::discard_call(bool is_disconnected, const string &invite_link, in
       if (!invite_link.empty()) {
         auto slug = LinkManager::get_group_call_invite_link_slug(invite_link);
         if (slug.empty()) {
-          return promise.set_error(Status::Error(400, "Invalid invite link specified"));
+          return promise.set_error(400, "Invalid invite link specified");
         }
         call_state_.discard_reason.type_ = CallDiscardReason::Type::UpgradeToGroupCall;
         call_state_.discard_reason.slug_ = std::move(slug);
@@ -305,7 +305,7 @@ void CallActor::discard_call(bool is_disconnected, const string &invite_link, in
 void CallActor::rate_call(int32 rating, string comment, vector<td_api::object_ptr<td_api::CallProblem>> &&problems,
                           Promise<Unit> promise) {
   if (!call_state_.need_rating) {
-    return promise.set_error(Status::Error(400, "Unexpected sendCallRating"));
+    return promise.set_error(400, "Unexpected sendCallRating");
   }
   promise.set_value(Unit());
 
@@ -379,7 +379,7 @@ void CallActor::on_set_rating_query_result(Result<NetQueryPtr> r_net_query) {
 
 void CallActor::send_call_debug_information(string data, Promise<Unit> promise) {
   if (!call_state_.need_debug_information) {
-    return promise.set_error(Status::Error(400, "Unexpected sendCallDebugInformation"));
+    return promise.set_error(400, "Unexpected sendCallDebugInformation");
   }
   promise.set_value(Unit());
   auto tl_query = telegram_api::phone_saveCallDebug(get_input_phone_call("send_call_debug_information"),
@@ -412,7 +412,7 @@ void CallActor::send_call_log(td_api::object_ptr<td_api::InputFile> log_file, Pr
   TRY_STATUS_PROMISE(promise, G()->close_status());
 
   if (!call_state_.need_log) {
-    return promise.set_error(Status::Error(400, "Unexpected sendCallLog"));
+    return promise.set_error(400, "Unexpected sendCallLog");
   }
 
   auto *file_manager = td_->file_manager_.get();
@@ -421,10 +421,10 @@ void CallActor::send_call_log(td_api::object_ptr<td_api::InputFile> log_file, Pr
 
   FileView file_view = file_manager->get_file_view(file_id);
   if (file_view.is_encrypted()) {
-    return promise.set_error(Status::Error(400, "Can't use encrypted file"));
+    return promise.set_error(400, "Can't use encrypted file");
   }
   if (!file_view.has_full_local_location() && !file_view.has_generate_location()) {
-    return promise.set_error(Status::Error(400, "Need local or generate location to upload call log"));
+    return promise.set_error(400, "Need local or generate location to upload call log");
   }
 
   upload_log_file({file_id, FileManager::get_internal_upload_id()}, std::move(promise));
@@ -472,15 +472,15 @@ void CallActor::on_upload_log_file_error(FileUploadId file_upload_id, Promise<Un
   LOG(WARNING) << "Log " << file_upload_id << " has upload error " << status;
   CHECK(status.is_error());
 
-  promise.set_error(Status::Error(status.code() > 0 ? status.code() : 500,
-                                  status.message()));  // TODO CHECK that status has always a code
+  promise.set_error(status.code() > 0 ? status.code() : 500,
+                    status.message());  // TODO CHECK that status has always a code
 }
 
 void CallActor::do_upload_log_file(FileUploadId file_upload_id,
                                    telegram_api::object_ptr<telegram_api::InputFile> &&input_file,
                                    Promise<Unit> &&promise) {
   if (input_file == nullptr) {
-    return promise.set_error(Status::Error(500, "Failed to reupload call log"));
+    return promise.set_error(500, "Failed to reupload call log");
   }
 
   auto tl_query = telegram_api::phone_saveCallLog(get_input_phone_call("do_upload_log_file"), std::move(input_file));
diff --git a/td/telegram/CallManager.cpp b/td/telegram/CallManager.cpp
index 6d8ff24a6..3123cedae 100644
--- a/td/telegram/CallManager.cpp
+++ b/td/telegram/CallManager.cpp
@@ -95,7 +95,7 @@ void CallManager::create_call(UserId user_id, CallProtocol &&protocol, bool is_v
 void CallManager::accept_call(CallId call_id, CallProtocol &&protocol, Promise<Unit> promise) {
   auto actor = get_call_actor(call_id);
   if (actor.empty()) {
-    return promise.set_error(Status::Error(400, "Call not found"));
+    return promise.set_error(400, "Call not found");
   }
   auto safe_promise = SafePromise<Unit>(std::move(promise), Status::Error(400, "Call not found"));
   send_closure(actor, &CallActor::accept_call, std::move(protocol), std::move(safe_promise));
@@ -104,7 +104,7 @@ void CallManager::accept_call(CallId call_id, CallProtocol &&protocol, Promise<U
 void CallManager::send_call_signaling_data(CallId call_id, string &&data, Promise<Unit> promise) {
   auto actor = get_call_actor(call_id);
   if (actor.empty()) {
-    return promise.set_error(Status::Error(400, "Call not found"));
+    return promise.set_error(400, "Call not found");
   }
   auto safe_promise = SafePromise<Unit>(std::move(promise), Status::Error(400, "Call not found"));
   send_closure(actor, &CallActor::send_call_signaling_data, std::move(data), std::move(safe_promise));
@@ -114,7 +114,7 @@ void CallManager::discard_call(CallId call_id, bool is_disconnected, const strin
                                bool is_video, int64 connection_id, Promise<Unit> promise) {
   auto actor = get_call_actor(call_id);
   if (actor.empty()) {
-    return promise.set_error(Status::Error(400, "Call not found"));
+    return promise.set_error(400, "Call not found");
   }
   auto safe_promise = SafePromise<Unit>(std::move(promise), Status::Error(400, "Call not found"));
   send_closure(actor, &CallActor::discard_call, is_disconnected, invite_link, duration, is_video, connection_id,
@@ -125,7 +125,7 @@ void CallManager::rate_call(CallId call_id, int32 rating, string comment,
                             vector<td_api::object_ptr<td_api::CallProblem>> &&problems, Promise<Unit> promise) {
   auto actor = get_call_actor(call_id);
   if (actor.empty()) {
-    return promise.set_error(Status::Error(400, "Call not found"));
+    return promise.set_error(400, "Call not found");
   }
   auto safe_promise = SafePromise<Unit>(std::move(promise), Status::Error(400, "Call not found"));
   send_closure(actor, &CallActor::rate_call, rating, std::move(comment), std::move(problems), std::move(safe_promise));
@@ -134,7 +134,7 @@ void CallManager::rate_call(CallId call_id, int32 rating, string comment,
 void CallManager::send_call_debug_information(CallId call_id, string data, Promise<Unit> promise) {
   auto actor = get_call_actor(call_id);
   if (actor.empty()) {
-    return promise.set_error(Status::Error(400, "Call not found"));
+    return promise.set_error(400, "Call not found");
   }
   auto safe_promise = SafePromise<Unit>(std::move(promise), Status::Error(400, "Call not found"));
   send_closure(actor, &CallActor::send_call_debug_information, std::move(data), std::move(safe_promise));
@@ -143,7 +143,7 @@ void CallManager::send_call_debug_information(CallId call_id, string data, Promi
 void CallManager::send_call_log(CallId call_id, td_api::object_ptr<td_api::InputFile> log_file, Promise<Unit> promise) {
   auto actor = get_call_actor(call_id);
   if (actor.empty()) {
-    return promise.set_error(Status::Error(400, "Call not found"));
+    return promise.set_error(400, "Call not found");
   }
   auto safe_promise = SafePromise<Unit>(std::move(promise), Status::Error(400, "Call not found"));
   send_closure(actor, &CallActor::send_call_log, std::move(log_file), std::move(safe_promise));
diff --git a/td/telegram/CallbackQueriesManager.cpp b/td/telegram/CallbackQueriesManager.cpp
index 0bd52cec6..7838fa0c2 100644
--- a/td/telegram/CallbackQueriesManager.cpp
+++ b/td/telegram/CallbackQueriesManager.cpp
@@ -257,11 +257,11 @@ void CallbackQueriesManager::send_callback_query(MessageFullId message_full_id,
                                                  tl_object_ptr<td_api::CallbackQueryPayload> &&payload,
                                                  Promise<td_api::object_ptr<td_api::callbackQueryAnswer>> &&promise) {
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Bot can't send callback queries to other bot"));
+    return promise.set_error(400, "Bot can't send callback queries to other bot");
   }
 
   if (payload == nullptr) {
-    return promise.set_error(Status::Error(400, "Payload must be non-empty"));
+    return promise.set_error(400, "Payload must be non-empty");
   }
 
   auto dialog_id = message_full_id.get_dialog_id();
@@ -269,13 +269,13 @@ void CallbackQueriesManager::send_callback_query(MessageFullId message_full_id,
       promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Read, "send_callback_query"));
 
   if (!td_->messages_manager_->have_message_force(message_full_id, "send_callback_query")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (message_full_id.get_message_id().is_valid_scheduled()) {
-    return promise.set_error(Status::Error(400, "Can't send callback queries from scheduled messages"));
+    return promise.set_error(400, "Can't send callback queries from scheduled messages");
   }
   if (!message_full_id.get_message_id().is_server()) {
-    return promise.set_error(Status::Error(400, "Bad message identifier"));
+    return promise.set_error(400, "Bad message identifier");
   }
 
   if (payload->get_id() == td_api::callbackQueryPayloadDataWithPassword::ID) {
@@ -304,7 +304,7 @@ void CallbackQueriesManager::send_get_callback_answer_query(
   TRY_STATUS_PROMISE(promise,
                      td_->dialog_manager_->check_dialog_access_in_memory(dialog_id, false, AccessRights::Read));
   if (!td_->messages_manager_->have_message_force(message_full_id, "send_get_callback_answer_query")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   td_->create_handler<GetBotCallbackAnswerQuery>(std::move(promise))
diff --git a/td/telegram/ChannelRecommendationManager.cpp b/td/telegram/ChannelRecommendationManager.cpp
index 0f890d485..f9d4e19f4 100644
--- a/td/telegram/ChannelRecommendationManager.cpp
+++ b/td/telegram/ChannelRecommendationManager.cpp
@@ -71,7 +71,7 @@ class GetChannelRecommendationsQuery final : public Td::ResultHandler {
       }
       default:
         UNREACHABLE();
-        return promise_.set_error(Status::Error("Unreachable"));
+        return promise_.set_error("Unreachable");
     }
   }
 
@@ -300,10 +300,10 @@ void ChannelRecommendationManager::get_channel_recommendations(
     Promise<int32> &&count_promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "get_channel_recommendations")) {
     if (chats_promise) {
-      chats_promise.set_error(Status::Error(400, "Chat not found"));
+      chats_promise.set_error(400, "Chat not found");
     }
     if (count_promise) {
-      count_promise.set_error(Status::Error(400, "Chat not found"));
+      count_promise.set_error(400, "Chat not found");
     }
     return;
   }
@@ -525,10 +525,10 @@ void ChannelRecommendationManager::open_channel_recommended_channel(DialogId dia
                                                                     Promise<Unit> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "open_channel_recommended_channel") ||
       !td_->dialog_manager_->have_dialog_force(opened_dialog_id, "open_channel_recommended_channel")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (dialog_id.get_type() != DialogType::Channel || opened_dialog_id.get_type() != DialogType::Channel) {
-    return promise.set_error(Status::Error(400, "Invalid chat specified"));
+    return promise.set_error(400, "Invalid chat specified");
   }
   vector<telegram_api::object_ptr<telegram_api::jsonObjectValue>> data;
   data.push_back(telegram_api::make_object<telegram_api::jsonObjectValue>(
diff --git a/td/telegram/ChatManager.cpp b/td/telegram/ChatManager.cpp
index 9e36335f8..8aa8ca409 100644
--- a/td/telegram/ChatManager.cpp
+++ b/td/telegram/ChatManager.cpp
@@ -1679,7 +1679,7 @@ ChatManager::ChatManager(Td *td, ActorShared<> parent) : td_(td), parent_(std::m
     CHECK(query_ids.size() == 1);
     auto input_channel = get_input_channel(ChannelId(query_ids[0]));
     if (input_channel == nullptr) {
-      return promise.set_error(Status::Error(400, "Channel not found"));
+      return promise.set_error(400, "Channel not found");
     }
     td_->create_handler<GetChannelsQuery>(std::move(promise))->send(std::move(input_channel));
   });
@@ -3058,10 +3058,10 @@ void ChatManager::set_chat_description(ChatId chat_id, const string &description
   auto new_description = strip_empty_characters(description, MAX_DESCRIPTION_LENGTH);
   auto c = get_chat(chat_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   if (!get_chat_permissions(c).can_change_info_and_settings()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to set chat description"));
+    return promise.set_error(400, "Not enough rights to set chat description");
   }
 
   td_->create_handler<EditChatAboutQuery>(std::move(promise))->send(DialogId(chat_id), new_description);
@@ -3070,14 +3070,14 @@ void ChatManager::set_chat_description(ChatId chat_id, const string &description
 void ChatManager::set_channel_username(ChannelId channel_id, const string &username, Promise<Unit> &&promise) {
   const auto *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!get_channel_status(c).is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to change supergroup username"));
+    return promise.set_error(400, "Not enough rights to change supergroup username");
   }
 
   if (!username.empty() && !is_allowed_username(username)) {
-    return promise.set_error(Status::Error(400, "Username is invalid"));
+    return promise.set_error(400, "Username is invalid");
   }
 
   td_->create_handler<UpdateChannelUsernameQuery>(std::move(promise))->send(channel_id, username);
@@ -3087,13 +3087,13 @@ void ChatManager::toggle_channel_username_is_active(ChannelId channel_id, string
                                                     Promise<Unit> &&promise) {
   const auto *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!get_channel_status(c).is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to change username"));
+    return promise.set_error(400, "Not enough rights to change username");
   }
   if (!c->usernames.can_toggle(username)) {
-    return promise.set_error(Status::Error(400, "Wrong username specified"));
+    return promise.set_error(400, "Wrong username specified");
   }
   td_->create_handler<ToggleChannelUsernameQuery>(std::move(promise))->send(channel_id, std::move(username), is_active);
 }
@@ -3101,10 +3101,10 @@ void ChatManager::toggle_channel_username_is_active(ChannelId channel_id, string
 void ChatManager::disable_all_channel_usernames(ChannelId channel_id, Promise<Unit> &&promise) {
   const auto *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!get_channel_status(c).is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to disable usernames"));
+    return promise.set_error(400, "Not enough rights to disable usernames");
   }
   td_->create_handler<DeactivateAllChannelUsernamesQuery>(std::move(promise))->send(channel_id);
 }
@@ -3112,13 +3112,13 @@ void ChatManager::disable_all_channel_usernames(ChannelId channel_id, Promise<Un
 void ChatManager::reorder_channel_usernames(ChannelId channel_id, vector<string> &&usernames, Promise<Unit> &&promise) {
   const auto *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!get_channel_status(c).is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to reorder usernames"));
+    return promise.set_error(400, "Not enough rights to reorder usernames");
   }
   if (!c->usernames.can_reorder_to(usernames)) {
-    return promise.set_error(Status::Error(400, "Invalid username order specified"));
+    return promise.set_error(400, "Invalid username order specified");
   }
   if (usernames.size() <= 1) {
     return promise.set_value(Unit());
@@ -3161,18 +3161,18 @@ void ChatManager::on_update_channel_active_usernames_order(ChannelId channel_id,
 void ChatManager::set_channel_accent_color(ChannelId channel_id, AccentColorId accent_color_id,
                                            CustomEmojiId background_custom_emoji_id, Promise<Unit> &&promise) {
   if (!accent_color_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid accent color identifier specified"));
+    return promise.set_error(400, "Invalid accent color identifier specified");
   }
 
   const auto *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Accent color can be changed only in channel chats"));
+    return promise.set_error(400, "Accent color can be changed only in channel chats");
   }
   if (!get_channel_permissions(channel_id, c).can_change_info_and_settings_as_administrator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights in the channel"));
+    return promise.set_error(400, "Not enough rights in the channel");
   }
 
   td_->create_handler<UpdateChannelColorQuery>(std::move(promise))
@@ -3184,10 +3184,10 @@ void ChatManager::set_channel_profile_accent_color(ChannelId channel_id, AccentC
                                                    Promise<Unit> &&promise) {
   const auto *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (!get_channel_permissions(channel_id, c).can_change_info_and_settings_as_administrator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights in the chat"));
+    return promise.set_error(400, "Not enough rights in the chat");
   }
 
   td_->create_handler<UpdateChannelColorQuery>(std::move(promise))
@@ -3198,10 +3198,10 @@ void ChatManager::set_channel_emoji_status(ChannelId channel_id, const unique_pt
                                            Promise<Unit> &&promise) {
   const auto *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (!get_channel_permissions(channel_id, c).can_change_info_and_settings_as_administrator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights in the chat"));
+    return promise.set_error(400, "Not enough rights in the chat");
   }
 
   if (emoji_status != nullptr) {
@@ -3214,13 +3214,13 @@ void ChatManager::set_channel_emoji_status(ChannelId channel_id, const unique_pt
 void ChatManager::set_channel_sticker_set(ChannelId channel_id, StickerSetId sticker_set_id, Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Chat sticker set can be set only for supergroups"));
+    return promise.set_error(400, "Chat sticker set can be set only for supergroups");
   }
   if (!get_channel_permissions(channel_id, c).can_change_info_and_settings_as_administrator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to change supergroup sticker set"));
+    return promise.set_error(400, "Not enough rights to change supergroup sticker set");
   }
 
   telegram_api::object_ptr<telegram_api::InputStickerSet> input_sticker_set;
@@ -3229,13 +3229,13 @@ void ChatManager::set_channel_sticker_set(ChannelId channel_id, StickerSetId sti
   } else {
     input_sticker_set = td_->stickers_manager_->get_input_sticker_set(sticker_set_id);
     if (input_sticker_set == nullptr) {
-      return promise.set_error(Status::Error(400, "Sticker set not found"));
+      return promise.set_error(400, "Sticker set not found");
     }
   }
 
   auto channel_full = get_channel_full(channel_id, false, "set_channel_sticker_set");
   if (channel_full != nullptr && !channel_full->can_set_sticker_set) {
-    return promise.set_error(Status::Error(400, "Can't set supergroup sticker set"));
+    return promise.set_error(400, "Can't set supergroup sticker set");
   }
 
   td_->create_handler<SetChannelStickerSetQuery>(std::move(promise))
@@ -3246,14 +3246,13 @@ void ChatManager::set_channel_emoji_sticker_set(ChannelId channel_id, StickerSet
                                                 Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Cuctom emoji sticker set can be set only for supergroups"));
+    return promise.set_error(400, "Cuctom emoji sticker set can be set only for supergroups");
   }
   if (!get_channel_permissions(channel_id, c).can_change_info_and_settings_as_administrator()) {
-    return promise.set_error(
-        Status::Error(400, "Not enough rights to change custom emoji sticker set in the supergroup"));
+    return promise.set_error(400, "Not enough rights to change custom emoji sticker set in the supergroup");
   }
 
   telegram_api::object_ptr<telegram_api::InputStickerSet> input_sticker_set;
@@ -3262,7 +3261,7 @@ void ChatManager::set_channel_emoji_sticker_set(ChannelId channel_id, StickerSet
   } else {
     input_sticker_set = td_->stickers_manager_->get_input_sticker_set(sticker_set_id);
     if (input_sticker_set == nullptr) {
-      return promise.set_error(Status::Error(400, "Sticker set not found"));
+      return promise.set_error(400, "Sticker set not found");
     }
   }
 
@@ -3274,17 +3273,16 @@ void ChatManager::set_channel_unrestrict_boost_count(ChannelId channel_id, int32
                                                      Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Unrestrict boost count can be set only for supergroups"));
+    return promise.set_error(400, "Unrestrict boost count can be set only for supergroups");
   }
   if (!get_channel_status(c).can_restrict_members()) {
-    return promise.set_error(
-        Status::Error(400, "Not enough rights to change unrestrict boost count set in the supergroup"));
+    return promise.set_error(400, "Not enough rights to change unrestrict boost count set in the supergroup");
   }
   if (unrestrict_boost_count < 0 || unrestrict_boost_count > 8) {
-    return promise.set_error(Status::Error(400, "Invalid new value for the unrestrict boost count specified"));
+    return promise.set_error(400, "Invalid new value for the unrestrict boost count specified");
   }
 
   td_->create_handler<SetChannelBoostsToUnblockRestrictionsQuery>(std::move(promise))
@@ -3295,13 +3293,13 @@ void ChatManager::toggle_channel_sign_messages(ChannelId channel_id, bool sign_m
                                                Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (get_channel_type(c) == ChannelType::Megagroup) {
-    return promise.set_error(Status::Error(400, "Message signatures can't be toggled in supergroups"));
+    return promise.set_error(400, "Message signatures can't be toggled in supergroups");
   }
   if (!get_channel_permissions(channel_id, c).can_change_info_and_settings()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to toggle channel sign messages"));
+    return promise.set_error(400, "Not enough rights to toggle channel sign messages");
   }
 
   td_->create_handler<ToggleChannelSignaturesQuery>(std::move(promise))
@@ -3311,13 +3309,13 @@ void ChatManager::toggle_channel_sign_messages(ChannelId channel_id, bool sign_m
 void ChatManager::toggle_channel_join_to_send(ChannelId channel_id, bool join_to_send, Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (get_channel_type(c) == ChannelType::Broadcast || c->is_gigagroup) {
-    return promise.set_error(Status::Error(400, "The method can be called only for ordinary supergroups"));
+    return promise.set_error(400, "The method can be called only for ordinary supergroups");
   }
   if (!get_channel_status(c).can_restrict_members()) {
-    return promise.set_error(Status::Error(400, "Not enough rights"));
+    return promise.set_error(400, "Not enough rights");
   }
 
   td_->create_handler<ToggleChannelJoinToSendQuery>(std::move(promise))->send(channel_id, join_to_send);
@@ -3326,13 +3324,13 @@ void ChatManager::toggle_channel_join_to_send(ChannelId channel_id, bool join_to
 void ChatManager::toggle_channel_join_request(ChannelId channel_id, bool join_request, Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (get_channel_type(c) == ChannelType::Broadcast || c->is_gigagroup) {
-    return promise.set_error(Status::Error(400, "The method can be called only for ordinary supergroups"));
+    return promise.set_error(400, "The method can be called only for ordinary supergroups");
   }
   if (!get_channel_status(c).can_restrict_members()) {
-    return promise.set_error(Status::Error(400, "Not enough rights"));
+    return promise.set_error(400, "Not enough rights");
   }
 
   td_->create_handler<ToggleChannelJoinRequestQuery>(std::move(promise))->send(channel_id, join_request);
@@ -3342,20 +3340,19 @@ void ChatManager::toggle_channel_is_all_history_available(ChannelId channel_id,
                                                           Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!get_channel_permissions(channel_id, c).can_change_info_and_settings()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to toggle all supergroup history availability"));
+    return promise.set_error(400, "Not enough rights to toggle all supergroup history availability");
   }
   if (get_channel_type(c) != ChannelType::Megagroup) {
-    return promise.set_error(Status::Error(400, "Message history can be hidden in supergroups only"));
+    return promise.set_error(400, "Message history can be hidden in supergroups only");
   }
   if ((c->is_forum || c->is_monoforum) && !is_all_history_available) {
-    return promise.set_error(
-        Status::Error(400, "Message history can't be hidden in forum and channel direct messages supergroups"));
+    return promise.set_error(400, "Message history can't be hidden in forum and channel direct messages supergroups");
   }
   if (c->has_linked_channel && !is_all_history_available) {
-    return promise.set_error(Status::Error(400, "Message history can't be hidden in discussion supergroups"));
+    return promise.set_error(400, "Message history can't be hidden in discussion supergroups");
   }
   // it can be toggled in public chats, but will not affect them
 
@@ -3366,13 +3363,13 @@ void ChatManager::toggle_channel_can_have_sponsored_messages(ChannelId channel_i
                                                              Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!get_channel_status(c).is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to disable sponsored messages"));
+    return promise.set_error(400, "Not enough rights to disable sponsored messages");
   }
   if (get_channel_type(c) != ChannelType::Broadcast) {
-    return promise.set_error(Status::Error(400, "Sponsored messages can be disabled only in channels"));
+    return promise.set_error(400, "Sponsored messages can be disabled only in channels");
   }
 
   td_->create_handler<RestrictSponsoredMessagesQuery>(std::move(promise))
@@ -3383,13 +3380,13 @@ void ChatManager::toggle_channel_has_automatic_translation(ChannelId channel_id,
                                                            Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!c->status.can_change_info_and_settings_as_administrator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to change automatic translation"));
+    return promise.set_error(400, "Not enough rights to change automatic translation");
   }
   if (get_channel_type(c) != ChannelType::Broadcast) {
-    return promise.set_error(Status::Error(400, "Automatic translation can be enabled only in channels"));
+    return promise.set_error(400, "Automatic translation can be enabled only in channels");
   }
 
   td_->create_handler<ToggleAutotranslationQuery>(std::move(promise))->send(channel_id, has_automatic_translation);
@@ -3494,16 +3491,16 @@ void ChatManager::toggle_channel_is_forum(ChannelId channel_id, bool is_forum, b
                                           Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (c->is_forum == is_forum && c->is_forum_tabs == is_forum_tabs) {
     return promise.set_value(Unit());
   }
   if (!get_channel_status(c).is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to convert the group to a forum"));
+    return promise.set_error(400, "Not enough rights to convert the group to a forum");
   }
   if (get_channel_type(c) != ChannelType::Megagroup) {
-    return promise.set_error(Status::Error(400, "Forums can be enabled in supergroups only"));
+    return promise.set_error(400, "Forums can be enabled in supergroups only");
   }
 
   td_->create_handler<ToggleForumQuery>(std::move(promise))->send(channel_id, is_forum, is_forum_tabs);
@@ -3511,7 +3508,7 @@ void ChatManager::toggle_channel_is_forum(ChannelId channel_id, bool is_forum, b
 
 void ChatManager::convert_channel_to_gigagroup(ChannelId channel_id, Promise<Unit> &&promise) {
   if (!can_convert_channel_to_gigagroup(channel_id)) {
-    return promise.set_error(Status::Error(400, "Can't convert the chat to a broadcast group"));
+    return promise.set_error(400, "Can't convert the chat to a broadcast group");
   }
 
   td_->suggested_action_manager_->remove_dialog_suggested_action(
@@ -3524,10 +3521,10 @@ void ChatManager::set_channel_description(ChannelId channel_id, const string &de
   auto new_description = strip_empty_characters(description, MAX_DESCRIPTION_LENGTH);
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   if (!get_channel_permissions(channel_id, c).can_change_info_and_settings()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to set chat description"));
+    return promise.set_error(400, "Not enough rights to set chat description");
   }
 
   td_->create_handler<EditChatAboutQuery>(std::move(promise))->send(DialogId(channel_id), new_description);
@@ -3536,31 +3533,31 @@ void ChatManager::set_channel_description(ChannelId channel_id, const string &de
 void ChatManager::set_channel_discussion_group(DialogId dialog_id, DialogId discussion_dialog_id,
                                                Promise<Unit> &&promise) {
   if (!dialog_id.is_valid() && !discussion_dialog_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid chat identifiers specified"));
+    return promise.set_error(400, "Invalid chat identifiers specified");
   }
 
   ChannelId broadcast_channel_id;
   telegram_api::object_ptr<telegram_api::InputChannel> broadcast_input_channel;
   if (dialog_id.is_valid()) {
     if (!td_->dialog_manager_->have_dialog_force(dialog_id, "set_channel_discussion_group 1")) {
-      return promise.set_error(Status::Error(400, "Chat not found"));
+      return promise.set_error(400, "Chat not found");
     }
 
     if (dialog_id.get_type() != DialogType::Channel) {
-      return promise.set_error(Status::Error(400, "Chat is not a channel"));
+      return promise.set_error(400, "Chat is not a channel");
     }
 
     broadcast_channel_id = dialog_id.get_channel_id();
     const Channel *c = get_channel(broadcast_channel_id);
     if (c == nullptr) {
-      return promise.set_error(Status::Error(400, "Chat info not found"));
+      return promise.set_error(400, "Chat info not found");
     }
 
     if (c->is_megagroup) {
-      return promise.set_error(Status::Error(400, "Chat is not a channel"));
+      return promise.set_error(400, "Chat is not a channel");
     }
     if (!c->status.can_change_info_and_settings_as_administrator()) {
-      return promise.set_error(Status::Error(400, "Not enough rights in the channel"));
+      return promise.set_error(400, "Not enough rights in the channel");
     }
 
     broadcast_input_channel = get_input_channel(broadcast_channel_id);
@@ -3573,23 +3570,23 @@ void ChatManager::set_channel_discussion_group(DialogId dialog_id, DialogId disc
   telegram_api::object_ptr<telegram_api::InputChannel> group_input_channel;
   if (discussion_dialog_id.is_valid()) {
     if (!td_->dialog_manager_->have_dialog_force(discussion_dialog_id, "set_channel_discussion_group 2")) {
-      return promise.set_error(Status::Error(400, "Discussion chat not found"));
+      return promise.set_error(400, "Discussion chat not found");
     }
     if (discussion_dialog_id.get_type() != DialogType::Channel) {
-      return promise.set_error(Status::Error(400, "Discussion chat is not a supergroup"));
+      return promise.set_error(400, "Discussion chat is not a supergroup");
     }
 
     group_channel_id = discussion_dialog_id.get_channel_id();
     const Channel *c = get_channel(group_channel_id);
     if (c == nullptr) {
-      return promise.set_error(Status::Error(400, "Discussion chat info not found"));
+      return promise.set_error(400, "Discussion chat info not found");
     }
 
     if (!c->is_megagroup) {
-      return promise.set_error(Status::Error(400, "Discussion chat is not a supergroup"));
+      return promise.set_error(400, "Discussion chat is not a supergroup");
     }
     if (!c->status.is_administrator() || !c->status.can_pin_messages()) {
-      return promise.set_error(Status::Error(400, "Not enough rights in the supergroup"));
+      return promise.set_error(400, "Not enough rights in the supergroup");
     }
 
     group_input_channel = get_input_channel(group_channel_id);
@@ -3606,31 +3603,31 @@ void ChatManager::set_channel_discussion_group(DialogId dialog_id, DialogId disc
 void ChatManager::set_channel_monoforum_group(DialogId dialog_id, bool is_enabled, int64 paid_message_star_count,
                                               Promise<Unit> &&promise) {
   if (!dialog_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid chat identifier specified"));
+    return promise.set_error(400, "Invalid chat identifier specified");
   }
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "set_channel_monoforum_group")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   if (dialog_id.get_type() != DialogType::Channel) {
-    return promise.set_error(Status::Error(400, "Chat is not a supergroup"));
+    return promise.set_error(400, "Chat is not a supergroup");
   }
 
   auto channel_id = dialog_id.get_channel_id();
   const Channel *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   if (c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Chat is not a channel"));
+    return promise.set_error(400, "Chat is not a channel");
   }
   if (!c->status.is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights in the channel"));
+    return promise.set_error(400, "Not enough rights in the channel");
   }
   if (!is_enabled) {
     paid_message_star_count = 0;
   } else if (paid_message_star_count < 0 || paid_message_star_count > 1000000) {
-    return promise.set_error(Status::Error(400, "Invalid number of Telegram Stars specified"));
+    return promise.set_error(400, "Invalid number of Telegram Stars specified");
   }
 
   td_->create_handler<UpdatePaidMessagesPriceQuery>(std::move(promise))
@@ -3639,18 +3636,18 @@ void ChatManager::set_channel_monoforum_group(DialogId dialog_id, bool is_enable
 
 void ChatManager::set_channel_location(ChannelId channel_id, const DialogLocation &location, Promise<Unit> &&promise) {
   if (location.empty()) {
-    return promise.set_error(Status::Error(400, "Invalid chat location specified"));
+    return promise.set_error(400, "Invalid chat location specified");
   }
 
   const Channel *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   if (!c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Chat is not a supergroup"));
+    return promise.set_error(400, "Chat is not a supergroup");
   }
   if (!c->status.is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights in the supergroup"));
+    return promise.set_error(400, "Not enough rights in the supergroup");
   }
 
   td_->create_handler<EditLocationQuery>(std::move(promise))->send(channel_id, location);
@@ -3659,30 +3656,30 @@ void ChatManager::set_channel_location(ChannelId channel_id, const DialogLocatio
 void ChatManager::set_channel_slow_mode_delay(DialogId dialog_id, int32 slow_mode_delay, Promise<Unit> &&promise) {
   vector<int32> allowed_slow_mode_delays{0, 10, 30, 60, 300, 900, 3600};
   if (!td::contains(allowed_slow_mode_delays, slow_mode_delay)) {
-    return promise.set_error(Status::Error(400, "Invalid new value for slow mode delay"));
+    return promise.set_error(400, "Invalid new value for slow mode delay");
   }
 
   if (!dialog_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid chat identifier specified"));
+    return promise.set_error(400, "Invalid chat identifier specified");
   }
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "set_channel_slow_mode_delay")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   if (dialog_id.get_type() != DialogType::Channel) {
-    return promise.set_error(Status::Error(400, "Chat is not a supergroup"));
+    return promise.set_error(400, "Chat is not a supergroup");
   }
 
   auto channel_id = dialog_id.get_channel_id();
   const Channel *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   if (!c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Chat is not a supergroup"));
+    return promise.set_error(400, "Chat is not a supergroup");
   }
   if (!get_channel_status(c).can_restrict_members()) {
-    return promise.set_error(Status::Error(400, "Not enough rights in the supergroup"));
+    return promise.set_error(400, "Not enough rights in the supergroup");
   }
 
   td_->create_handler<ToggleSlowModeQuery>(std::move(promise))->send(channel_id, slow_mode_delay);
@@ -3690,20 +3687,20 @@ void ChatManager::set_channel_slow_mode_delay(DialogId dialog_id, int32 slow_mod
 
 void ChatManager::get_channel_statistics_dc_id(DialogId dialog_id, bool for_full_statistics, Promise<DcId> &&promise) {
   if (!dialog_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid chat identifier specified"));
+    return promise.set_error(400, "Invalid chat identifier specified");
   }
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "get_channel_statistics_dc_id")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   if (dialog_id.get_type() != DialogType::Channel) {
-    return promise.set_error(Status::Error(400, "Chat is not a channel"));
+    return promise.set_error(400, "Chat is not a channel");
   }
 
   auto channel_id = dialog_id.get_channel_id();
   const Channel *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
 
   auto channel_full = get_channel_full_force(channel_id, false, "get_channel_statistics_dc_id");
@@ -3727,11 +3724,11 @@ void ChatManager::get_channel_statistics_dc_id_impl(ChannelId channel_id, bool f
 
   auto channel_full = get_channel_full(channel_id, false, "get_channel_statistics_dc_id_impl");
   if (channel_full == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat full info not found"));
+    return promise.set_error(400, "Chat full info not found");
   }
 
   if (!channel_full->stats_dc_id.is_exact() || (for_full_statistics && !channel_full->can_view_statistics)) {
-    return promise.set_error(Status::Error(400, "Chat statistics are not available"));
+    return promise.set_error(400, "Chat statistics are not available");
   }
 
   promise.set_value(DcId(channel_full->stats_dc_id));
@@ -3780,13 +3777,13 @@ void ChatManager::report_channel_spam(ChannelId channel_id, const vector<Message
                                       Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Spam can be reported only in supergroups"));
+    return promise.set_error(400, "Spam can be reported only in supergroups");
   }
   if (!c->status.is_administrator()) {
-    return promise.set_error(Status::Error(400, "Spam can be reported only by chat administrators"));
+    return promise.set_error(400, "Spam can be reported only by chat administrators");
   }
 
   FlatHashMap<DialogId, vector<MessageId>, DialogIdHash> server_message_ids;
@@ -3818,18 +3815,17 @@ void ChatManager::report_channel_anti_spam_false_positive(ChannelId channel_id,
                                                           Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
   if (!c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "The chat is not a supergroup"));
+    return promise.set_error(400, "The chat is not a supergroup");
   }
   if (!c->status.is_administrator()) {
-    return promise.set_error(
-        Status::Error(400, "Anti-spam checks false positives can be reported only by chat administrators"));
+    return promise.set_error(400, "Anti-spam checks false positives can be reported only by chat administrators");
   }
 
   if (!message_id.is_valid() || !message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Invalid message identifier specified"));
+    return promise.set_error(400, "Invalid message identifier specified");
   }
 
   td_->create_handler<ReportChannelAntiSpamFalsePositiveQuery>(std::move(promise))->send(channel_id, message_id);
@@ -3838,29 +3834,29 @@ void ChatManager::report_channel_anti_spam_false_positive(ChannelId channel_id,
 void ChatManager::set_channel_send_paid_message_star_count(DialogId dialog_id, int64 send_paid_message_star_count,
                                                            Promise<Unit> &&promise) {
   if (!dialog_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid chat identifier specified"));
+    return promise.set_error(400, "Invalid chat identifier specified");
   }
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "set_channel_send_paid_message_star_count")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   if (dialog_id.get_type() != DialogType::Channel) {
-    return promise.set_error(Status::Error(400, "Chat is not a supergroup"));
+    return promise.set_error(400, "Chat is not a supergroup");
   }
 
   auto channel_id = dialog_id.get_channel_id();
   const Channel *c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   if (!c->is_megagroup) {
-    return promise.set_error(Status::Error(400, "Chat is not a supergroup"));
+    return promise.set_error(400, "Chat is not a supergroup");
   }
   if (!get_channel_status(c).can_restrict_members()) {
-    return promise.set_error(Status::Error(400, "Not enough rights in the supergroup"));
+    return promise.set_error(400, "Not enough rights in the supergroup");
   }
   if (send_paid_message_star_count < 0 || send_paid_message_star_count > 1000000) {
-    return promise.set_error(Status::Error(400, "Invalid number of Telegram Stars specified"));
+    return promise.set_error(400, "Invalid number of Telegram Stars specified");
   }
 
   td_->create_handler<UpdatePaidMessagesPriceQuery>(std::move(promise))
@@ -3870,13 +3866,13 @@ void ChatManager::set_channel_send_paid_message_star_count(DialogId dialog_id, i
 void ChatManager::delete_chat(ChatId chat_id, Promise<Unit> &&promise) {
   auto c = get_chat(chat_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   if (!get_chat_status(c).is_creator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to delete the chat"));
+    return promise.set_error(400, "Not enough rights to delete the chat");
   }
   if (!c->is_active) {
-    return promise.set_error(Status::Error(400, "Chat is already deactivated"));
+    return promise.set_error(400, "Chat is already deactivated");
   }
 
   td_->create_handler<DeleteChatQuery>(std::move(promise))->send(chat_id);
@@ -3885,10 +3881,10 @@ void ChatManager::delete_chat(ChatId chat_id, Promise<Unit> &&promise) {
 void ChatManager::delete_channel(ChannelId channel_id, Promise<Unit> &&promise) {
   auto c = get_channel(channel_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   if (!get_channel_can_be_deleted(c)) {
-    return promise.set_error(Status::Error(400, "The chat can't be deleted"));
+    return promise.set_error(400, "The chat can't be deleted");
   }
 
   td_->create_handler<DeleteChannelQuery>(std::move(promise))->send(channel_id);
@@ -7983,7 +7979,7 @@ void ChatManager::create_new_chat(const vector<UserId> &user_ids, const string &
                                   Promise<td_api::object_ptr<td_api::createdBasicGroupChat>> &&promise) {
   auto new_title = clean_name(title, MAX_TITLE_LENGTH);
   if (new_title.empty()) {
-    return promise.set_error(Status::Error(400, "Title must be non-empty"));
+    return promise.set_error(400, "Title must be non-empty");
   }
 
   vector<telegram_api::object_ptr<telegram_api::InputUser>> input_users;
@@ -8000,7 +7996,7 @@ void ChatManager::create_new_channel(const string &title, bool is_forum, bool is
                                      Promise<td_api::object_ptr<td_api::chat>> &&promise) {
   auto new_title = clean_name(title, MAX_TITLE_LENGTH);
   if (new_title.empty()) {
-    return promise.set_error(Status::Error(400, "Title must be non-empty"));
+    return promise.set_error(400, "Title must be non-empty");
   }
 
   td_->create_handler<CreateChannelQuery>(std::move(promise))
@@ -8031,7 +8027,7 @@ ChatManager::Chat *ChatManager::add_chat(ChatId chat_id) {
 
 bool ChatManager::get_chat(ChatId chat_id, int left_tries, Promise<Unit> &&promise) {
   if (!chat_id.is_valid()) {
-    promise.set_error(Status::Error(400, "Invalid basic group identifier"));
+    promise.set_error(400, "Invalid basic group identifier");
     return false;
   }
 
@@ -8046,7 +8042,7 @@ bool ChatManager::get_chat(ChatId chat_id, int left_tries, Promise<Unit> &&promi
       return false;
     }
 
-    promise.set_error(Status::Error(400, "Group not found"));
+    promise.set_error(400, "Group not found");
     return false;
   }
 
@@ -8058,7 +8054,7 @@ void ChatManager::reload_chat(ChatId chat_id, Promise<Unit> &&promise, const cha
   TRY_STATUS_PROMISE(promise, G()->close_status());
 
   if (!chat_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid basic group identifier"));
+    return promise.set_error(400, "Invalid basic group identifier");
   }
 
   get_chat_queries_.add_query(chat_id.get(), std::move(promise), source);
@@ -8114,7 +8110,7 @@ bool ChatManager::is_chat_full_outdated(const ChatFull *chat_full, const Chat *c
 void ChatManager::load_chat_full(ChatId chat_id, bool force, Promise<Unit> &&promise, const char *source) {
   auto c = get_chat(chat_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Group not found"));
+    return promise.set_error(400, "Group not found");
   }
 
   auto chat_full = get_chat_full_force(chat_id, source);
@@ -8148,7 +8144,7 @@ void ChatManager::reload_chat_full(ChatId chat_id, Promise<Unit> &&promise, cons
 void ChatManager::send_get_chat_full_query(ChatId chat_id, Promise<Unit> &&promise, const char *source) {
   LOG(INFO) << "Get full " << chat_id << " from " << source;
   if (!chat_id.is_valid()) {
-    return promise.set_error(Status::Error(500, "Invalid chat_id"));
+    return promise.set_error(500, "Invalid chat_id");
   }
   auto send_query = PromiseCreator::lambda([td = td_, chat_id](Result<Promise<Unit>> &&promise) {
     if (promise.is_ok() && !G()->close_flag()) {
@@ -8531,7 +8527,7 @@ ChatManager::Channel *ChatManager::add_channel(ChannelId channel_id, const char
 
 bool ChatManager::get_channel(ChannelId channel_id, int left_tries, Promise<Unit> &&promise) {
   if (!channel_id.is_valid()) {
-    promise.set_error(Status::Error(400, "Invalid supergroup identifier"));
+    promise.set_error(400, "Invalid supergroup identifier");
     return false;
   }
 
@@ -8547,7 +8543,7 @@ bool ChatManager::get_channel(ChannelId channel_id, int left_tries, Promise<Unit
       return false;
     }
 
-    promise.set_error(Status::Error(400, "Supergroup not found"));
+    promise.set_error(400, "Supergroup not found");
     return false;
   }
 
@@ -8559,7 +8555,7 @@ void ChatManager::reload_channel(ChannelId channel_id, Promise<Unit> &&promise,
   TRY_STATUS_PROMISE(promise, G()->close_status());
 
   if (!channel_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid supergroup identifier"));
+    return promise.set_error(400, "Invalid supergroup identifier");
   }
 
   have_channel_force(channel_id, source);
@@ -8639,11 +8635,11 @@ void ChatManager::send_get_channel_full_query(ChannelFull *channel_full, Channel
                                               const char *source) {
   auto input_channel = get_input_channel(channel_id);
   if (input_channel == nullptr) {
-    return promise.set_error(Status::Error(400, "Supergroup not found"));
+    return promise.set_error(400, "Supergroup not found");
   }
 
   if (!have_input_peer_channel(channel_id, AccessRights::Read)) {
-    return promise.set_error(Status::Error(400, "Can't access the chat"));
+    return promise.set_error(400, "Can't access the chat");
   }
 
   if (channel_full != nullptr) {
@@ -8673,7 +8669,7 @@ void ChatManager::get_chat_participant(ChatId chat_id, UserId user_id, Promise<D
 
   auto c = get_chat(chat_id);
   if (c == nullptr) {
-    return promise.set_error(Status::Error(400, "Group not found"));
+    return promise.set_error(400, "Group not found");
   }
 
   if (td_->auth_manager_->is_bot() && user_id == td_->user_manager_->get_my_id()) {
diff --git a/td/telegram/CommonDialogManager.cpp b/td/telegram/CommonDialogManager.cpp
index b83353b0b..3bdeedfcc 100644
--- a/td/telegram/CommonDialogManager.cpp
+++ b/td/telegram/CommonDialogManager.cpp
@@ -102,11 +102,11 @@ std::pair<int32, vector<DialogId>> CommonDialogManager::get_common_dialogs(UserI
   }
 
   if (user_id == td_->user_manager_->get_my_id()) {
-    promise.set_error(Status::Error(400, "Can't get common chats with self"));
+    promise.set_error(400, "Can't get common chats with self");
     return {};
   }
   if (limit <= 0) {
-    promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    promise.set_error(400, "Parameter limit must be positive");
     return {};
   }
   if (limit > MAX_GET_DIALOGS) {
@@ -128,7 +128,7 @@ std::pair<int32, vector<DialogId>> CommonDialogManager::get_common_dialogs(UserI
     // fallthrough
     case DialogType::User:
     case DialogType::SecretChat:
-      promise.set_error(Status::Error(400, "Wrong offset_chat_id"));
+      promise.set_error(400, "Wrong offset_chat_id");
       return {};
     default:
       UNREACHABLE();
@@ -147,7 +147,7 @@ std::pair<int32, vector<DialogId>> CommonDialogManager::get_common_dialogs(UserI
       if (offset_dialog_id != DialogId()) {
         offset_it = std::find(common_dialog_ids.begin(), common_dialog_ids.end(), offset_dialog_id);
         if (offset_it == common_dialog_ids.end()) {
-          promise.set_error(Status::Error(400, "Wrong offset_chat_id"));
+          promise.set_error(400, "Wrong offset_chat_id");
           return {};
         }
         ++offset_it;
diff --git a/td/telegram/ConfigManager.cpp b/td/telegram/ConfigManager.cpp
index 4a4106ebc..a14e9eee4 100644
--- a/td/telegram/ConfigManager.cpp
+++ b/td/telegram/ConfigManager.cpp
@@ -257,7 +257,7 @@ static string generate_firebase_remote_config_payload() {
 ActorOwn<> get_simple_config_firebase_remote_config(Promise<SimpleConfigResult> promise, bool prefer_ipv6,
                                                     Slice domain_name, bool is_test, int32 scheduler_id) {
   if (is_test) {
-    promise.set_error(Status::Error(400, "Test config is not supported"));
+    promise.set_error(400, "Test config is not supported");
     return ActorOwn<>();
   }
 
@@ -281,7 +281,7 @@ ActorOwn<> get_simple_config_firebase_remote_config(Promise<SimpleConfigResult>
 ActorOwn<> get_simple_config_firebase_realtime(Promise<SimpleConfigResult> promise, bool prefer_ipv6, Slice domain_name,
                                                bool is_test, int32 scheduler_id) {
   if (is_test) {
-    promise.set_error(Status::Error(400, "Test config is not supported"));
+    promise.set_error(400, "Test config is not supported");
     return ActorOwn<>();
   }
 
@@ -296,7 +296,7 @@ ActorOwn<> get_simple_config_firebase_realtime(Promise<SimpleConfigResult> promi
 ActorOwn<> get_simple_config_firebase_firestore(Promise<SimpleConfigResult> promise, bool prefer_ipv6,
                                                 Slice domain_name, bool is_test, int32 scheduler_id) {
   if (is_test) {
-    promise.set_error(Status::Error(400, "Test config is not supported"));
+    promise.set_error(400, "Test config is not supported");
     return ActorOwn<>();
   }
 
@@ -467,7 +467,7 @@ static ActorOwn<> get_full_config(DcOption option, Promise<tl_object_ptr<telegra
     void hangup_shared() final {
       if (get_link_token() == 1) {
         if (promise_) {
-          promise_.set_error(Status::Error("Failed"));
+          promise_.set_error("Failed");
         }
         stop();
       }
@@ -476,7 +476,7 @@ static ActorOwn<> get_full_config(DcOption option, Promise<tl_object_ptr<telegra
       session_.reset();
     }
     void timeout_expired() final {
-      promise_.set_error(Status::Error("Timeout expired"));
+      promise_.set_error("Timeout expired");
       session_.reset();
     }
 
diff --git a/td/telegram/CountryInfoManager.cpp b/td/telegram/CountryInfoManager.cpp
index d9f71f6f1..2953c11cd 100644
--- a/td/telegram/CountryInfoManager.cpp
+++ b/td/telegram/CountryInfoManager.cpp
@@ -203,10 +203,10 @@ void CountryInfoManager::do_get_countries(string language_code, bool is_recursiv
   }
 
   if (is_recursive) {
-    return promise.set_error(Status::Error(500, "Requested data is inaccessible"));
+    return promise.set_error(500, "Requested data is inaccessible");
   }
   if (language_code.empty()) {
-    return promise.set_error(Status::Error(400, "Invalid language code specified"));
+    return promise.set_error(400, "Invalid language code specified");
   }
   load_country_list(language_code, 0,
                     PromiseCreator::lambda([actor_id = actor_id(this), language_code,
@@ -246,10 +246,10 @@ void CountryInfoManager::do_get_phone_number_info(string phone_number_prefix, st
   }
 
   if (is_recursive) {
-    return promise.set_error(Status::Error(500, "Requested data is inaccessible"));
+    return promise.set_error(500, "Requested data is inaccessible");
   }
   if (language_code.empty()) {
-    return promise.set_error(Status::Error(400, "Invalid language code specified"));
+    return promise.set_error(400, "Invalid language code specified");
   }
   load_country_list(language_code, 0,
                     PromiseCreator::lambda([actor_id = actor_id(this), phone_number_prefix, language_code,
diff --git a/td/telegram/DeviceTokenManager.cpp b/td/telegram/DeviceTokenManager.cpp
index 361716e10..1e6deb152 100644
--- a/td/telegram/DeviceTokenManager.cpp
+++ b/td/telegram/DeviceTokenManager.cpp
@@ -134,7 +134,7 @@ void DeviceTokenManager::register_device(tl_object_ptr<td_api::DeviceToken> devi
                                          const vector<UserId> &other_user_ids,
                                          Promise<td_api::object_ptr<td_api::pushReceiverId>> promise) {
   if (device_token_ptr == nullptr) {
-    return promise.set_error(Status::Error(400, "Device token must be non-empty"));
+    return promise.set_error(400, "Device token must be non-empty");
   }
   TokenType token_type;
   string token;
@@ -196,16 +196,16 @@ void DeviceTokenManager::register_device(tl_object_ptr<td_api::DeviceToken> devi
     case td_api::deviceTokenWebPush::ID: {
       auto device_token = static_cast<td_api::deviceTokenWebPush *>(device_token_ptr.get());
       if (device_token->endpoint_.find(',') != string::npos) {
-        return promise.set_error(Status::Error(400, "Illegal endpoint value"));
+        return promise.set_error(400, "Illegal endpoint value");
       }
       if (!is_base64url(device_token->p256dh_base64url_)) {
-        return promise.set_error(Status::Error(400, "Public key must be base64url-encoded"));
+        return promise.set_error(400, "Public key must be base64url-encoded");
       }
       if (!is_base64url(device_token->auth_base64url_)) {
-        return promise.set_error(Status::Error(400, "Authentication secret must be base64url-encoded"));
+        return promise.set_error(400, "Authentication secret must be base64url-encoded");
       }
       if (!clean_input_string(device_token->endpoint_)) {
-        return promise.set_error(Status::Error(400, "Endpoint must be encoded in UTF-8"));
+        return promise.set_error(400, "Endpoint must be encoded in UTF-8");
       }
 
       if (!device_token->endpoint_.empty()) {
@@ -244,11 +244,11 @@ void DeviceTokenManager::register_device(tl_object_ptr<td_api::DeviceToken> devi
   }
 
   if (!clean_input_string(token)) {
-    return promise.set_error(Status::Error(400, "Device token must be encoded in UTF-8"));
+    return promise.set_error(400, "Device token must be encoded in UTF-8");
   }
   for (auto &other_user_id : other_user_ids) {
     if (!other_user_id.is_valid()) {
-      return promise.set_error(Status::Error(400, "Invalid user_id among other user_ids"));
+      return promise.set_error(400, "Invalid user_id among other user_ids");
     }
   }
   auto input_user_ids = UserId::get_input_user_ids(other_user_ids);
@@ -452,7 +452,7 @@ void DeviceTokenManager::on_result(NetQueryPtr net_query) {
       }
       info.promise.set_error(r_flag.move_as_error());
     } else {
-      info.promise.set_error(Status::Error(400, "Receive false as result of registerDevice server request"));
+      info.promise.set_error(400, "Receive false as result of registerDevice server request");
     }
     if (info.state == TokenInfo::State::Reregister) {
       // keep trying to reregister the token
diff --git a/td/telegram/DialogActionManager.cpp b/td/telegram/DialogActionManager.cpp
index c2633e18a..9d3e12fc9 100644
--- a/td/telegram/DialogActionManager.cpp
+++ b/td/telegram/DialogActionManager.cpp
@@ -304,11 +304,11 @@ void DialogActionManager::send_dialog_action(DialogId dialog_id, MessageId top_t
     TRY_STATUS_PROMISE(promise,
                        td_->business_connection_manager_->check_business_connection(business_connection_id, dialog_id));
   } else if (!td_->dialog_manager_->have_dialog_force(dialog_id, "send_dialog_action")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (top_thread_message_id != MessageId() &&
       (!top_thread_message_id.is_valid() || !top_thread_message_id.is_server())) {
-    return promise.set_error(Status::Error(400, "Invalid message thread specified"));
+    return promise.set_error(400, "Invalid message thread specified");
   }
 
   if (!as_business && td_->dialog_manager_->is_forum_channel(dialog_id) && !top_thread_message_id.is_valid()) {
@@ -318,18 +318,18 @@ void DialogActionManager::send_dialog_action(DialogId dialog_id, MessageId top_t
   tl_object_ptr<telegram_api::InputPeer> input_peer;
   if (action == DialogAction::get_speaking_action()) {
     if (as_business) {
-      return promise.set_error(Status::Error(400, "Can't use the action"));
+      return promise.set_error(400, "Can't use the action");
     }
     input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise.set_error(Status::Error(400, "Have no access to the chat"));
+      return promise.set_error(400, "Have no access to the chat");
     }
   } else if (as_business) {
     input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Know);
   } else {
     if (!td_->dialog_manager_->have_input_peer(dialog_id, true, AccessRights::Write)) {
       if (td_->auth_manager_->is_bot()) {
-        return promise.set_error(Status::Error(400, "Have no write access to the chat"));
+        return promise.set_error(400, "Have no write access to the chat");
       }
       return promise.set_value(Unit());
     }
diff --git a/td/telegram/DialogEventLog.cpp b/td/telegram/DialogEventLog.cpp
index 1b59cc308..9c5be8b35 100644
--- a/td/telegram/DialogEventLog.cpp
+++ b/td/telegram/DialogEventLog.cpp
@@ -629,20 +629,20 @@ void get_dialog_event_log(Td *td, DialogId dialog_id, const string &query, int64
                           const td_api::object_ptr<td_api::chatEventLogFilters> &filters,
                           const vector<UserId> &user_ids, Promise<td_api::object_ptr<td_api::chatEvents>> &&promise) {
   if (!td->dialog_manager_->have_dialog_force(dialog_id, "get_dialog_event_log")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   if (dialog_id.get_type() != DialogType::Channel) {
-    return promise.set_error(Status::Error(400, "Chat is not a supergroup chat"));
+    return promise.set_error(400, "Chat is not a supergroup chat");
   }
 
   auto channel_id = dialog_id.get_channel_id();
   if (!td->chat_manager_->have_channel(channel_id)) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
 
   if (!td->chat_manager_->get_channel_status(channel_id).is_administrator()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to get event log"));
+    return promise.set_error(400, "Not enough rights to get event log");
   }
 
   vector<tl_object_ptr<telegram_api::InputUser>> input_users;
diff --git a/td/telegram/DialogFilterManager.cpp b/td/telegram/DialogFilterManager.cpp
index 048c0a4f6..fe8bb413b 100644
--- a/td/telegram/DialogFilterManager.cpp
+++ b/td/telegram/DialogFilterManager.cpp
@@ -949,7 +949,7 @@ void DialogFilterManager::get_dialog_filter(DialogFilterId dialog_filter_id,
                                             Promise<td_api::object_ptr<td_api::chatFolder>> &&promise) {
   CHECK(!td_->auth_manager_->is_bot());
   if (!dialog_filter_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid chat folder identifier specified"));
+    return promise.set_error(400, "Invalid chat folder identifier specified");
   }
 
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
@@ -1543,10 +1543,10 @@ void DialogFilterManager::create_dialog_filter(td_api::object_ptr<td_api::chatFo
   auto max_dialog_filters = clamp(td_->option_manager_->get_option_integer("chat_folder_count_max"),
                                   static_cast<int64>(0), static_cast<int64>(100));
   if (dialog_filters_.size() >= narrow_cast<size_t>(max_dialog_filters)) {
-    return promise.set_error(Status::Error(400, "The maximum number of chat folders exceeded"));
+    return promise.set_error(400, "The maximum number of chat folders exceeded");
   }
   if (!is_update_chat_folders_sent_) {
-    return promise.set_error(Status::Error(400, "Chat folders are not synchronized yet"));
+    return promise.set_error(400, "Chat folders are not synchronized yet");
   }
 
   DialogFilterId dialog_filter_id;
@@ -1559,7 +1559,7 @@ void DialogFilterManager::create_dialog_filter(td_api::object_ptr<td_api::chatFo
   TRY_RESULT_PROMISE(promise, dialog_filter,
                      DialogFilter::create_dialog_filter(td_, dialog_filter_id, std::move(filter)));
   if (dialog_filter->is_shareable()) {
-    return promise.set_error(Status::Error(400, "Can't create shareable folder"));
+    return promise.set_error(400, "Can't create shareable folder");
   }
   auto chat_folder_info = dialog_filter->get_chat_folder_info_object();
 
@@ -1581,14 +1581,14 @@ void DialogFilterManager::edit_dialog_filter(DialogFilterId dialog_filter_id,
   CHECK(!td_->auth_manager_->is_bot());
   auto old_dialog_filter = get_dialog_filter(dialog_filter_id);
   if (old_dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   CHECK(is_update_chat_folders_sent_);
 
   TRY_RESULT_PROMISE(promise, new_dialog_filter,
                      DialogFilter::create_dialog_filter(td_, dialog_filter_id, std::move(filter)));
   if (new_dialog_filter->is_shareable() != old_dialog_filter->is_shareable()) {
-    return promise.set_error(Status::Error(400, "Can't convert a shareable folder to a non-shareable"));
+    return promise.set_error(400, "Can't convert a shareable folder to a non-shareable");
   }
   new_dialog_filter->update_from(*old_dialog_filter);
   auto chat_folder_info = new_dialog_filter->get_chat_folder_info_object();
@@ -1674,7 +1674,7 @@ void DialogFilterManager::delete_dialog_filter(DialogFilterId dialog_filter_id,
   }
   for (auto &leave_dialog_id : leave_dialog_ids) {
     if (!dialog_filter->is_dialog_included(leave_dialog_id)) {
-      return promise.set_error(Status::Error(400, "The chat doesn't included in the folder"));
+      return promise.set_error(400, "The chat doesn't included in the folder");
     }
   }
   if (!leave_dialog_ids.empty()) {
@@ -1744,7 +1744,7 @@ void DialogFilterManager::get_leave_dialog_filter_suggestions(DialogFilterId dia
                                                               Promise<td_api::object_ptr<td_api::chats>> &&promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   if (!dialog_filter->is_shareable()) {
     return promise.set_value(td_api::make_object<td_api::chats>());
@@ -1768,7 +1768,7 @@ void DialogFilterManager::on_get_leave_dialog_filter_suggestions(
 
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   if (!dialog_filter->is_shareable()) {
     return promise.set_value(td_api::make_object<td_api::chats>());
@@ -1786,16 +1786,16 @@ void DialogFilterManager::reorder_dialog_filters(vector<DialogFilterId> dialog_f
   for (auto dialog_filter_id : dialog_filter_ids) {
     auto dialog_filter = get_dialog_filter(dialog_filter_id);
     if (dialog_filter == nullptr) {
-      return promise.set_error(Status::Error(400, "Chat folder not found"));
+      return promise.set_error(400, "Chat folder not found");
     }
   }
   std::unordered_set<DialogFilterId, DialogFilterIdHash> new_dialog_filter_ids_set(dialog_filter_ids.begin(),
                                                                                    dialog_filter_ids.end());
   if (new_dialog_filter_ids_set.size() != dialog_filter_ids.size()) {
-    return promise.set_error(Status::Error(400, "Duplicate chat folders in the new list"));
+    return promise.set_error(400, "Duplicate chat folders in the new list");
   }
   if (main_dialog_list_position < 0 || main_dialog_list_position > static_cast<int32>(dialog_filters_.size())) {
-    return promise.set_error(Status::Error(400, "Invalid main chat list position specified"));
+    return promise.set_error(400, "Invalid main chat list position specified");
   }
   if (!td_->option_manager_->get_option_boolean("is_premium")) {
     main_dialog_list_position = 0;
@@ -1848,7 +1848,7 @@ void DialogFilterManager::toggle_dialog_filter_tags(bool are_tags_enabled, Promi
     if (!are_tags_enabled) {
       return promise.set_value(Unit());
     }
-    return promise.set_error(Status::Error(400, "Method not available"));
+    return promise.set_error(400, "Method not available");
   }
 
   if (are_tags_enabled_ != are_tags_enabled) {
@@ -1974,7 +1974,7 @@ void DialogFilterManager::get_dialogs_for_dialog_filter_invite_link(
     DialogFilterId dialog_filter_id, Promise<td_api::object_ptr<td_api::chats>> promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
 
   auto load_promise = PromiseCreator::lambda(
@@ -1992,7 +1992,7 @@ void DialogFilterManager::do_get_dialogs_for_dialog_filter_invite_link(
     DialogFilterId dialog_filter_id, Promise<td_api::object_ptr<td_api::chats>> promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
 
   promise.set_value(td_->dialog_manager_->get_chats_object(-1, dialog_filter->get_dialogs_for_invite_link(td_),
@@ -2004,22 +2004,22 @@ void DialogFilterManager::create_dialog_filter_invite_link(
     Promise<td_api::object_ptr<td_api::chatFolderInviteLink>> promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   vector<tl_object_ptr<telegram_api::InputPeer>> input_peers;
   input_peers.reserve(dialog_ids.size());
   for (auto &dialog_id : dialog_ids) {
     if (!td_->dialog_manager_->have_dialog_force(dialog_id, "create_dialog_filter_invite_link")) {
-      return promise.set_error(Status::Error(400, "Chat not found"));
+      return promise.set_error(400, "Chat not found");
     }
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Write);
     if (input_peer == nullptr) {
-      return promise.set_error(Status::Error(400, "Have no access to the chat"));
+      return promise.set_error(400, "Have no access to the chat");
     }
     input_peers.push_back(std::move(input_peer));
   }
   if (input_peers.empty()) {
-    return promise.set_error(Status::Error(400, "At least one chat must be included"));
+    return promise.set_error(400, "At least one chat must be included");
   }
   td_->create_handler<ExportChatlistInviteQuery>(std::move(promise))
       ->send(dialog_filter_id, invite_link_name, std::move(input_peers));
@@ -2029,7 +2029,7 @@ void DialogFilterManager::get_dialog_filter_invite_links(
     DialogFilterId dialog_filter_id, Promise<td_api::object_ptr<td_api::chatFolderInviteLinks>> promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   if (!dialog_filter->is_shareable()) {
     return promise.set_value(td_api::make_object<td_api::chatFolderInviteLinks>());
@@ -2042,22 +2042,22 @@ void DialogFilterManager::edit_dialog_filter_invite_link(
     Promise<td_api::object_ptr<td_api::chatFolderInviteLink>> promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   vector<tl_object_ptr<telegram_api::InputPeer>> input_peers;
   input_peers.reserve(dialog_ids.size());
   for (auto &dialog_id : dialog_ids) {
     if (!td_->dialog_manager_->have_dialog_force(dialog_id, "edit_dialog_filter_invite_link")) {
-      return promise.set_error(Status::Error(400, "Chat not found"));
+      return promise.set_error(400, "Chat not found");
     }
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Write);
     if (input_peer == nullptr) {
-      return promise.set_error(Status::Error(400, "Have no access to the chat"));
+      return promise.set_error(400, "Have no access to the chat");
     }
     input_peers.push_back(std::move(input_peer));
   }
   if (input_peers.empty()) {
-    return promise.set_error(Status::Error(400, "At least one chat must be included"));
+    return promise.set_error(400, "At least one chat must be included");
   }
   td_->create_handler<EditExportedChatlistInviteQuery>(std::move(promise))
       ->send(dialog_filter_id, invite_link, invite_link_name, std::move(input_peers));
@@ -2067,7 +2067,7 @@ void DialogFilterManager::delete_dialog_filter_invite_link(DialogFilterId dialog
                                                            Promise<Unit> promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   td_->create_handler<DeleteExportedChatlistInviteQuery>(std::move(promise))->send(dialog_filter_id, invite_link);
 }
@@ -2075,7 +2075,7 @@ void DialogFilterManager::delete_dialog_filter_invite_link(DialogFilterId dialog
 void DialogFilterManager::check_dialog_filter_invite_link(
     const string &invite_link, Promise<td_api::object_ptr<td_api::chatFolderInviteLinkInfo>> &&promise) {
   if (!DialogFilterInviteLink::is_valid_invite_link(invite_link)) {
-    return promise.set_error(Status::Error(400, "Wrong invite link"));
+    return promise.set_error(400, "Wrong invite link");
   }
 
   CHECK(!invite_link.empty());
@@ -2098,12 +2098,12 @@ void DialogFilterManager::on_get_chatlist_invite(
       auto invite = move_tl_object_as<telegram_api::chatlists_chatlistInviteAlready>(invite_ptr);
       DialogFilterId dialog_filter_id = DialogFilterId(invite->filter_id_);
       if (!dialog_filter_id.is_valid()) {
-        return promise.set_error(Status::Error(500, "Receive invalid chat folder identifier"));
+        return promise.set_error(500, "Receive invalid chat folder identifier");
       }
       auto dialog_filter = get_dialog_filter(dialog_filter_id);
       if (dialog_filter == nullptr) {
         reload_dialog_filters();
-        return promise.set_error(Status::Error(500, "Receive unknown chat folder"));
+        return promise.set_error(500, "Receive unknown chat folder");
       }
       info = dialog_filter->get_chat_folder_info_object();
       missing_peers = std::move(invite->missing_peers_);
@@ -2148,7 +2148,7 @@ void DialogFilterManager::on_get_chatlist_invite(
 void DialogFilterManager::add_dialog_filter_by_invite_link(const string &invite_link, vector<DialogId> dialog_ids,
                                                            Promise<Unit> &&promise) {
   if (!DialogFilterInviteLink::is_valid_invite_link(invite_link)) {
-    return promise.set_error(Status::Error(400, "Wrong invite link"));
+    return promise.set_error(400, "Wrong invite link");
   }
   for (auto dialog_id : dialog_ids) {
     TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Know,
@@ -2163,7 +2163,7 @@ void DialogFilterManager::get_dialog_filter_new_chats(DialogFilterId dialog_filt
                                                       Promise<td_api::object_ptr<td_api::chats>> &&promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   if (!dialog_filter->is_shareable()) {
     return promise.set_value(td_api::make_object<td_api::chats>());
@@ -2175,10 +2175,10 @@ void DialogFilterManager::add_dialog_filter_new_chats(DialogFilterId dialog_filt
                                                       Promise<Unit> &&promise) {
   auto dialog_filter = get_dialog_filter(dialog_filter_id);
   if (dialog_filter == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat folder not found"));
+    return promise.set_error(400, "Chat folder not found");
   }
   if (!dialog_filter->is_shareable()) {
-    return promise.set_error(Status::Error(400, "Chat folder must be shareable"));
+    return promise.set_error(400, "Chat folder must be shareable");
   }
   for (auto dialog_id : dialog_ids) {
     TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Know,
diff --git a/td/telegram/DialogInviteLinkManager.cpp b/td/telegram/DialogInviteLinkManager.cpp
index 9836c7b0b..2fdf6ea70 100644
--- a/td/telegram/DialogInviteLinkManager.cpp
+++ b/td/telegram/DialogInviteLinkManager.cpp
@@ -632,7 +632,7 @@ void DialogInviteLinkManager::check_dialog_invite_link(const string &invite_link
   }
 
   if (!DialogInviteLink::is_valid_invite_link(invite_link)) {
-    return promise.set_error(Status::Error(400, "Wrong invite link"));
+    return promise.set_error(400, "Wrong invite link");
   }
 
   CHECK(!invite_link.empty());
@@ -641,7 +641,7 @@ void DialogInviteLinkManager::check_dialog_invite_link(const string &invite_link
 
 void DialogInviteLinkManager::import_dialog_invite_link(const string &invite_link, Promise<DialogId> &&promise) {
   if (!DialogInviteLink::is_valid_invite_link(invite_link)) {
-    return promise.set_error(Status::Error(400, "Wrong invite link"));
+    return promise.set_error(400, "Wrong invite link");
   }
 
   td_->create_handler<ImportChatInviteQuery>(std::move(promise))->send(invite_link);
@@ -958,15 +958,14 @@ void DialogInviteLinkManager::export_dialog_invite_link(DialogId dialog_id, stri
                                                         Promise<td_api::object_ptr<td_api::chatInviteLink>> &&promise) {
   if (is_subscription) {
     if (subscription_pricing.is_empty()) {
-      return promise.set_error(Status::Error(400, "Invalid subscription pricing specified"));
+      return promise.set_error(400, "Invalid subscription pricing specified");
     }
     CHECK(expire_date == 0 && usage_limit == 0 && !creates_join_request);
   } else {
     CHECK(subscription_pricing.is_empty());
   }
   if (creates_join_request && usage_limit > 0) {
-    return promise.set_error(
-        Status::Error(400, "Member limit can't be specified for links requiring administrator approval"));
+    return promise.set_error(400, "Member limit can't be specified for links requiring administrator approval");
   }
 
   td_->user_manager_->get_me(PromiseCreator::lambda(
@@ -1000,12 +999,11 @@ void DialogInviteLinkManager::edit_dialog_invite_link(DialogId dialog_id, const
                                                       Promise<td_api::object_ptr<td_api::chatInviteLink>> &&promise) {
   TRY_STATUS_PROMISE(promise, can_manage_dialog_invite_links(dialog_id));
   if (creates_join_request && usage_limit > 0) {
-    return promise.set_error(
-        Status::Error(400, "Member limit can't be specified for links requiring administrator approval"));
+    return promise.set_error(400, "Member limit can't be specified for links requiring administrator approval");
   }
 
   if (invite_link.empty()) {
-    return promise.set_error(Status::Error(400, "Invite link must be non-empty"));
+    return promise.set_error(400, "Invite link must be non-empty");
   }
 
   auto new_title = clean_name(std::move(title), MAX_INVITE_LINK_TITLE_LENGTH);
@@ -1018,7 +1016,7 @@ void DialogInviteLinkManager::get_dialog_invite_link(DialogId dialog_id, const s
   TRY_STATUS_PROMISE(promise, can_manage_dialog_invite_links(dialog_id));
 
   if (invite_link.empty()) {
-    return promise.set_error(Status::Error(400, "Invite link must be non-empty"));
+    return promise.set_error(400, "Invite link must be non-empty");
   }
 
   td_->create_handler<GetExportedChatInviteQuery>(std::move(promise))->send(dialog_id, invite_link);
@@ -1039,7 +1037,7 @@ void DialogInviteLinkManager::get_dialog_invite_links(DialogId dialog_id, UserId
   TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(creator_user_id));
 
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
 
   td_->create_handler<GetExportedChatInvitesQuery>(std::move(promise))
@@ -1053,11 +1051,11 @@ void DialogInviteLinkManager::get_dialog_invite_link_users(
   TRY_STATUS_PROMISE(promise, can_manage_dialog_invite_links(dialog_id));
 
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
 
   if (invite_link.empty()) {
-    return promise.set_error(Status::Error(400, "Invite link must be non-empty"));
+    return promise.set_error(400, "Invite link must be non-empty");
   }
 
   UserId offset_user_id;
@@ -1076,7 +1074,7 @@ void DialogInviteLinkManager::revoke_dialog_invite_link(
   TRY_STATUS_PROMISE(promise, can_manage_dialog_invite_links(dialog_id));
 
   if (invite_link.empty()) {
-    return promise.set_error(Status::Error(400, "Invite link must be non-empty"));
+    return promise.set_error(400, "Invite link must be non-empty");
   }
 
   td_->create_handler<RevokeChatInviteLinkQuery>(std::move(promise))->send(dialog_id, invite_link);
@@ -1087,7 +1085,7 @@ void DialogInviteLinkManager::delete_revoked_dialog_invite_link(DialogId dialog_
   TRY_STATUS_PROMISE(promise, can_manage_dialog_invite_links(dialog_id));
 
   if (invite_link.empty()) {
-    return promise.set_error(Status::Error(400, "Invite link must be non-empty"));
+    return promise.set_error(400, "Invite link must be non-empty");
   }
 
   td_->create_handler<DeleteExportedChatInviteQuery>(std::move(promise))->send(dialog_id, invite_link);
diff --git a/td/telegram/DialogManager.cpp b/td/telegram/DialogManager.cpp
index 843ec120a..6c7163a9a 100644
--- a/td/telegram/DialogManager.cpp
+++ b/td/telegram/DialogManager.cpp
@@ -1575,7 +1575,7 @@ void DialogManager::reload_dialog_info(DialogId dialog_id, Promise<Unit> &&promi
     case DialogType::Channel:
       return td_->chat_manager_->reload_channel(dialog_id.get_channel_id(), std::move(promise), "reload_dialog_info");
     default:
-      return promise.set_error(Status::Error("Invalid chat identifier to reload"));
+      return promise.set_error("Invalid chat identifier to reload");
   }
 }
 
@@ -1598,7 +1598,7 @@ void DialogManager::get_dialog_info_full(DialogId dialog_id, Promise<Unit> &&pro
     case DialogType::None:
     default:
       UNREACHABLE();
-      return promise.set_error(Status::Error(500, "Wrong chat type"));
+      return promise.set_error(500, "Wrong chat type");
   }
 }
 
@@ -1704,15 +1704,15 @@ NotificationSettingsScope DialogManager::get_dialog_notification_setting_scope(D
 void DialogManager::migrate_dialog_to_megagroup(DialogId dialog_id,
                                                 Promise<td_api::object_ptr<td_api::chat>> &&promise) {
   if (!have_dialog_force(dialog_id, "migrate_dialog_to_megagroup")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (dialog_id.get_type() != DialogType::Chat) {
-    return promise.set_error(Status::Error(400, "Only basic group chats can be converted to supergroup"));
+    return promise.set_error(400, "Only basic group chats can be converted to supergroup");
   }
 
   auto chat_id = dialog_id.get_chat_id();
   if (!td_->chat_manager_->get_chat_status(chat_id).is_creator()) {
-    return promise.set_error(Status::Error(400, "Need creator rights in the chat"));
+    return promise.set_error(400, "Need creator rights in the chat");
   }
   if (td_->chat_manager_->get_chat_migrated_to_channel_id(chat_id).is_valid()) {
     return on_migrate_chat_to_megagroup(chat_id, std::move(promise));
@@ -1732,11 +1732,11 @@ void DialogManager::on_migrate_chat_to_megagroup(ChatId chat_id, Promise<td_api:
   auto channel_id = td_->chat_manager_->get_chat_migrated_to_channel_id(chat_id);
   if (!channel_id.is_valid()) {
     LOG(ERROR) << "Can't find the supergroup to which the basic group has migrated";
-    return promise.set_error(Status::Error(500, "Supergroup not found"));
+    return promise.set_error(500, "Supergroup not found");
   }
   if (!td_->chat_manager_->have_channel(channel_id)) {
     LOG(ERROR) << "Can't find info about the supergroup to which the basic group has migrated";
-    return promise.set_error(Status::Error(500, "Supergroup info is not found"));
+    return promise.set_error(500, "Supergroup info is not found");
   }
 
   auto dialog_id = DialogId(channel_id);
@@ -1901,7 +1901,7 @@ bool DialogManager::on_get_dialog_error(DialogId dialog_id, const Status &status
 
 void DialogManager::delete_dialog(DialogId dialog_id, Promise<Unit> &&promise) {
   if (!have_dialog_force(dialog_id, "delete_dialog")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
@@ -2144,35 +2144,35 @@ bool DialogManager::is_dialog_action_unneeded(DialogId dialog_id) const {
 
 void DialogManager::set_dialog_title(DialogId dialog_id, const string &title, Promise<Unit> &&promise) {
   if (!have_dialog_force(dialog_id, "set_dialog_title")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   auto new_title = clean_name(title, MAX_TITLE_LENGTH);
   if (new_title.empty()) {
-    return promise.set_error(Status::Error(400, "Title must be non-empty"));
+    return promise.set_error(400, "Title must be non-empty");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't change private chat title"));
+      return promise.set_error(400, "Can't change private chat title");
     case DialogType::Chat: {
       auto chat_id = dialog_id.get_chat_id();
       auto status = td_->chat_manager_->get_chat_permissions(chat_id);
       if (!status.can_change_info_and_settings() ||
           (td_->auth_manager_->is_bot() && !td_->chat_manager_->is_appointed_chat_administrator(chat_id))) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change chat title"));
+        return promise.set_error(400, "Not enough rights to change chat title");
       }
       break;
     }
     case DialogType::Channel: {
       auto status = td_->chat_manager_->get_channel_permissions(dialog_id.get_channel_id());
       if (!status.can_change_info_and_settings()) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change chat title"));
+        return promise.set_error(400, "Not enough rights to change chat title");
       }
       break;
     }
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't change secret chat title"));
+      return promise.set_error(400, "Can't change secret chat title");
     case DialogType::None:
     default:
       UNREACHABLE();
@@ -2189,30 +2189,30 @@ void DialogManager::set_dialog_title(DialogId dialog_id, const string &title, Pr
 void DialogManager::set_dialog_photo(DialogId dialog_id, const td_api::object_ptr<td_api::InputChatPhoto> &input_photo,
                                      Promise<Unit> &&promise) {
   if (!have_dialog_force(dialog_id, "set_dialog_photo")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't change private chat photo"));
+      return promise.set_error(400, "Can't change private chat photo");
     case DialogType::Chat: {
       auto chat_id = dialog_id.get_chat_id();
       auto status = td_->chat_manager_->get_chat_permissions(chat_id);
       if (!status.can_change_info_and_settings() ||
           (td_->auth_manager_->is_bot() && !td_->chat_manager_->is_appointed_chat_administrator(chat_id))) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change chat photo"));
+        return promise.set_error(400, "Not enough rights to change chat photo");
       }
       break;
     }
     case DialogType::Channel: {
       auto status = td_->chat_manager_->get_channel_permissions(dialog_id.get_channel_id());
       if (!status.can_change_info_and_settings()) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change chat photo"));
+        return promise.set_error(400, "Not enough rights to change chat photo");
       }
       break;
     }
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't change secret chat photo"));
+      return promise.set_error(400, "Can't change secret chat photo");
     case DialogType::None:
     default:
       UNREACHABLE();
@@ -2227,13 +2227,13 @@ void DialogManager::set_dialog_photo(DialogId dialog_id, const td_api::object_pt
         auto photo = static_cast<const td_api::inputChatPhotoPrevious *>(input_photo.get());
         auto file_id = td_->user_manager_->get_profile_photo_file_id(photo->chat_photo_id_);
         if (!file_id.is_valid()) {
-          return promise.set_error(Status::Error(400, "Unknown profile photo identifier specified"));
+          return promise.set_error(400, "Unknown profile photo identifier specified");
         }
 
         auto file_view = td_->file_manager_->get_file_view(file_id);
         const auto *main_remote_location = file_view.get_main_remote_location();
         if (main_remote_location == nullptr) {
-          return promise.set_error(Status::Error(400, "Invalid profile photo identifier specified"));
+          return promise.set_error(400, "Invalid profile photo identifier specified");
         }
         auto input_chat_photo =
             telegram_api::make_object<telegram_api::inputChatPhoto>(main_remote_location->as_input_photo());
@@ -2274,7 +2274,7 @@ void DialogManager::set_dialog_photo(DialogId dialog_id, const td_api::object_pt
 
   const double MAX_ANIMATION_DURATION = 10.0;
   if (main_frame_timestamp < 0.0 || main_frame_timestamp > MAX_ANIMATION_DURATION) {
-    return promise.set_error(Status::Error(400, "Wrong main frame timestamp specified"));
+    return promise.set_error(400, "Wrong main frame timestamp specified");
   }
 
   auto file_type = is_animation ? FileType::Animation : FileType::Photo;
@@ -2329,10 +2329,10 @@ void DialogManager::on_upload_dialog_photo(FileUploadId file_upload_id,
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (input_file == nullptr && main_remote_location != nullptr) {
     if (main_remote_location->is_web()) {
-      return promise.set_error(Status::Error(400, "Can't use web photo as profile photo"));
+      return promise.set_error(400, "Can't use web photo as profile photo");
     }
     if (is_reupload) {
-      return promise.set_error(Status::Error(400, "Failed to reupload the file"));
+      return promise.set_error(400, "Failed to reupload the file");
     }
 
     if (is_animation) {
@@ -2392,7 +2392,7 @@ void DialogManager::on_upload_dialog_photo_error(FileUploadId file_upload_id, St
 void DialogManager::set_dialog_accent_color(DialogId dialog_id, AccentColorId accent_color_id,
                                             CustomEmojiId background_custom_emoji_id, Promise<Unit> &&promise) {
   if (!have_dialog_force(dialog_id, "set_dialog_accent_color")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
@@ -2412,14 +2412,14 @@ void DialogManager::set_dialog_accent_color(DialogId dialog_id, AccentColorId ac
     default:
       UNREACHABLE();
   }
-  promise.set_error(Status::Error(400, "Can't change accent color in the chat"));
+  promise.set_error(400, "Can't change accent color in the chat");
 }
 
 void DialogManager::set_dialog_profile_accent_color(DialogId dialog_id, AccentColorId profile_accent_color_id,
                                                     CustomEmojiId profile_background_custom_emoji_id,
                                                     Promise<Unit> &&promise) {
   if (!have_dialog_force(dialog_id, "set_dialog_profile_accent_color")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
@@ -2440,7 +2440,7 @@ void DialogManager::set_dialog_profile_accent_color(DialogId dialog_id, AccentCo
     default:
       UNREACHABLE();
   }
-  promise.set_error(Status::Error(400, "Can't change profile accent color in the chat"));
+  promise.set_error(400, "Can't change profile accent color in the chat");
 }
 
 void DialogManager::set_dialog_permissions(DialogId dialog_id,
@@ -2449,28 +2449,28 @@ void DialogManager::set_dialog_permissions(DialogId dialog_id,
   TRY_STATUS_PROMISE(promise, check_dialog_access(dialog_id, false, AccessRights::Write, "set_dialog_permissions"));
 
   if (permissions == nullptr) {
-    return promise.set_error(Status::Error(400, "New permissions must be non-empty"));
+    return promise.set_error(400, "New permissions must be non-empty");
   }
 
   ChannelType channel_type = ChannelType::Unknown;
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't change private chat permissions"));
+      return promise.set_error(400, "Can't change private chat permissions");
     case DialogType::Chat: {
       auto chat_id = dialog_id.get_chat_id();
       auto status = td_->chat_manager_->get_chat_permissions(chat_id);
       if (!status.can_restrict_members()) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change chat permissions"));
+        return promise.set_error(400, "Not enough rights to change chat permissions");
       }
       break;
     }
     case DialogType::Channel: {
       if (is_broadcast_channel(dialog_id)) {
-        return promise.set_error(Status::Error(400, "Can't change channel chat permissions"));
+        return promise.set_error(400, "Can't change channel chat permissions");
       }
       auto status = td_->chat_manager_->get_channel_permissions(dialog_id.get_channel_id());
       if (!status.can_restrict_members()) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change chat permissions"));
+        return promise.set_error(400, "Not enough rights to change chat permissions");
       }
       channel_type = ChannelType::Megagroup;
       break;
@@ -2494,7 +2494,7 @@ void DialogManager::set_dialog_permissions(DialogId dialog_id,
 void DialogManager::set_dialog_emoji_status(DialogId dialog_id, const unique_ptr<EmojiStatus> &emoji_status,
                                             Promise<Unit> &&promise) {
   if (!have_dialog_force(dialog_id, "set_dialog_emoji_status")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
@@ -2513,7 +2513,7 @@ void DialogManager::set_dialog_emoji_status(DialogId dialog_id, const unique_ptr
     default:
       UNREACHABLE();
   }
-  promise.set_error(Status::Error(400, "Can't change emoji status in the chat"));
+  promise.set_error(400, "Can't change emoji status in the chat");
 }
 
 void DialogManager::toggle_dialog_has_protected_content(DialogId dialog_id, bool has_protected_content,
@@ -2523,19 +2523,19 @@ void DialogManager::toggle_dialog_has_protected_content(DialogId dialog_id, bool
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't restrict saving content in the chat"));
+      return promise.set_error(400, "Can't restrict saving content in the chat");
     case DialogType::Chat: {
       auto chat_id = dialog_id.get_chat_id();
       auto status = td_->chat_manager_->get_chat_status(chat_id);
       if (!status.is_creator()) {
-        return promise.set_error(Status::Error(400, "Only owner can restrict saving content"));
+        return promise.set_error(400, "Only owner can restrict saving content");
       }
       break;
     }
     case DialogType::Channel: {
       auto status = td_->chat_manager_->get_channel_status(dialog_id.get_channel_id());
       if (!status.is_creator()) {
-        return promise.set_error(Status::Error(400, "Only owner can restrict saving content"));
+        return promise.set_error(400, "Only owner can restrict saving content");
       }
       break;
     }
@@ -2555,18 +2555,18 @@ void DialogManager::toggle_dialog_has_protected_content(DialogId dialog_id, bool
 
 void DialogManager::set_dialog_description(DialogId dialog_id, const string &description, Promise<Unit> &&promise) {
   if (!have_dialog_force(dialog_id, "set_dialog_description")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't change private chat description"));
+      return promise.set_error(400, "Can't change private chat description");
     case DialogType::Chat:
       return td_->chat_manager_->set_chat_description(dialog_id.get_chat_id(), description, std::move(promise));
     case DialogType::Channel:
       return td_->chat_manager_->set_channel_description(dialog_id.get_channel_id(), description, std::move(promise));
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't change secret chat description"));
+      return promise.set_error(400, "Can't change secret chat description");
     case DialogType::None:
     default:
       UNREACHABLE();
@@ -2575,14 +2575,14 @@ void DialogManager::set_dialog_description(DialogId dialog_id, const string &des
 
 void DialogManager::set_dialog_location(DialogId dialog_id, const DialogLocation &location, Promise<Unit> &&promise) {
   if (!have_dialog_force(dialog_id, "set_dialog_location")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
     case DialogType::Chat:
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "The chat can't have location"));
+      return promise.set_error(400, "The chat can't have location");
     case DialogType::Channel:
       return td_->chat_manager_->set_channel_location(dialog_id.get_channel_id(), location, std::move(promise));
     case DialogType::None:
@@ -2633,7 +2633,7 @@ void DialogManager::report_dialog(DialogId dialog_id, const string &option_id, c
       return promise.set_value(td_api::make_object<td_api::reportChatResultOk>());
     }
 
-    return promise.set_error(Status::Error(400, "Chat can't be reported"));
+    return promise.set_error(400, "Chat can't be reported");
   }
 
   for (auto message_id : message_ids) {
@@ -2648,19 +2648,19 @@ void DialogManager::report_dialog_photo(DialogId dialog_id, FileId file_id, Repo
   TRY_STATUS_PROMISE(promise, check_dialog_access(dialog_id, false, AccessRights::Read, "report_dialog_photo"));
 
   if (!can_report_dialog(dialog_id)) {
-    return promise.set_error(Status::Error(400, "Chat photo can't be reported"));
+    return promise.set_error(400, "Chat photo can't be reported");
   }
 
   auto file_view = td_->file_manager_->get_file_view(file_id);
   if (file_view.empty()) {
-    return promise.set_error(Status::Error(400, "Unknown file identifier"));
+    return promise.set_error(400, "Unknown file identifier");
   }
   if (get_main_file_type(file_view.get_type()) != FileType::Photo) {
-    return promise.set_error(Status::Error(400, "Only full chat photos can be reported"));
+    return promise.set_error(400, "Only full chat photos can be reported");
   }
   const auto *full_remote_location = file_view.get_full_remote_location();
   if (full_remote_location == nullptr || !full_remote_location->is_photo()) {
-    return promise.set_error(Status::Error(400, "Invalid photo identifier specified"));
+    return promise.set_error(400, "Invalid photo identifier specified");
   }
 
   td_->create_handler<ReportProfilePhotoQuery>(std::move(promise))
@@ -2797,20 +2797,20 @@ void DialogManager::check_dialog_username(DialogId dialog_id, const string &user
                                           Promise<CheckDialogUsernameResult> &&promise) {
   if (dialog_id != DialogId() && dialog_id.get_type() != DialogType::User &&
       !have_dialog_force(dialog_id, "check_dialog_username")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User: {
       if (dialog_id != get_my_dialog_id()) {
-        return promise.set_error(Status::Error(400, "Can't check username for private chat with other user"));
+        return promise.set_error(400, "Can't check username for private chat with other user");
       }
       break;
     }
     case DialogType::Channel: {
       auto channel_id = dialog_id.get_channel_id();
       if (!td_->chat_manager_->get_channel_status(channel_id).is_creator()) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change username"));
+        return promise.set_error(400, "Not enough rights to change username");
       }
       if (username == td_->chat_manager_->get_channel_editable_username(channel_id)) {
         return promise.set_value(CheckDialogUsernameResult::Ok);
@@ -2822,7 +2822,7 @@ void DialogManager::check_dialog_username(DialogId dialog_id, const string &user
     case DialogType::Chat:
     case DialogType::SecretChat:
       if (!username.empty()) {
-        return promise.set_error(Status::Error(400, "The chat can't have a username"));
+        return promise.set_error(400, "The chat can't have a username");
       }
       break;
     default:
@@ -2979,7 +2979,7 @@ void DialogManager::on_resolve_dialog(const string &username, ChannelId channel_
   DialogId dialog_id;
   if (username.empty()) {
     if (!td_->chat_manager_->have_channel(channel_id)) {
-      return promise.set_error(Status::Error(500, "Chat info not found"));
+      return promise.set_error(500, "Chat info not found");
     }
 
     dialog_id = DialogId(channel_id);
@@ -2991,7 +2991,7 @@ void DialogManager::on_resolve_dialog(const string &username, ChannelId channel_
     }
   }
   if (!have_dialog_force(dialog_id, "on_resolve_dialog")) {
-    return promise.set_error(Status::Error(500, "Chat not found"));
+    return promise.set_error(500, "Chat not found");
   }
   promise.set_value(std::move(dialog_id));
 }
@@ -3028,7 +3028,7 @@ DialogId DialogManager::search_public_dialog(const string &username_to_search, b
     username = username.substr(1);
   }
   if (username.empty()) {
-    promise.set_error(Status::Error(200, "Username is invalid"));
+    promise.set_error(200, "Username is invalid");
     return DialogId();
   }
 
@@ -3139,7 +3139,7 @@ vector<DialogId> DialogManager::search_dialogs_on_server(const string &query, in
   LOG(INFO) << "Search chats on server with query \"" << query << "\" and limit " << limit;
 
   if (limit < 0) {
-    promise.set_error(Status::Error(400, "Limit must be non-negative"));
+    promise.set_error(400, "Limit must be non-negative");
     return {};
   }
   if (limit > MAX_GET_DIALOGS) {
@@ -3294,7 +3294,7 @@ void DialogManager::toggle_dialog_report_spam_state_on_server(DialogId dialog_id
       } else {
         auto user_id = td_->user_manager_->get_secret_chat_user_id(dialog_id.get_secret_chat_id());
         if (!user_id.is_valid()) {
-          return promise.set_error(Status::Error(400, "Peer user not found"));
+          return promise.set_error(400, "Peer user not found");
         }
         return td_->create_handler<UpdatePeerSettingsQuery>(std::move(promise))->send(DialogId(user_id), false);
       }
@@ -3308,16 +3308,16 @@ void DialogManager::toggle_dialog_report_spam_state_on_server(DialogId dialog_id
 void DialogManager::get_blocked_dialogs(const td_api::object_ptr<td_api::BlockList> &block_list, int32 offset,
                                         int32 limit, Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
   if (offset < 0) {
-    return promise.set_error(Status::Error(400, "Parameter offset must be non-negative"));
+    return promise.set_error(400, "Parameter offset must be non-negative");
   }
 
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
 
   auto block_list_id = BlockListId(block_list);
   if (!block_list_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Block list must be non-empty"));
+    return promise.set_error(400, "Block list must be non-empty");
   }
 
   td_->create_handler<GetBlockedDialogsQuery>(std::move(promise))->send(block_list_id, offset, limit);
diff --git a/td/telegram/DialogParticipantManager.cpp b/td/telegram/DialogParticipantManager.cpp
index cbeea539c..53c26c6a9 100644
--- a/td/telegram/DialogParticipantManager.cpp
+++ b/td/telegram/DialogParticipantManager.cpp
@@ -245,7 +245,7 @@ class GetChannelAdministratorsQuery final : public Td::ResultHandler {
   void send(ChannelId channel_id, int64 hash) {
     auto input_channel = td_->chat_manager_->get_input_channel(channel_id);
     if (input_channel == nullptr) {
-      return promise_.set_error(Status::Error(400, "Supergroup not found"));
+      return promise_.set_error(400, "Supergroup not found");
     }
 
     hash = 0;  // to load even only ranks or creator changed
@@ -318,7 +318,7 @@ class GetChannelParticipantQuery final : public Td::ResultHandler {
   void send(ChannelId channel_id, DialogId participant_dialog_id, tl_object_ptr<telegram_api::InputPeer> &&input_peer) {
     auto input_channel = td_->chat_manager_->get_input_channel(channel_id);
     if (input_channel == nullptr) {
-      return promise_.set_error(Status::Error(400, "Supergroup not found"));
+      return promise_.set_error(400, "Supergroup not found");
     }
 
     CHECK(input_peer != nullptr);
@@ -343,7 +343,7 @@ class GetChannelParticipantQuery final : public Td::ResultHandler {
     DialogParticipant result(std::move(participant->participant_), td_->chat_manager_->get_channel_type(channel_id_));
     if (!result.is_valid()) {
       LOG(ERROR) << "Receive invalid " << result;
-      return promise_.set_error(Status::Error(500, "Receive invalid chat member"));
+      return promise_.set_error(500, "Receive invalid chat member");
     }
     promise_.set_value(std::move(result));
   }
@@ -374,7 +374,7 @@ class GetChannelParticipantsQuery final : public Td::ResultHandler {
   void send(ChannelId channel_id, const ChannelParticipantFilter &filter, int32 offset, int32 limit) {
     auto input_channel = td_->chat_manager_->get_input_channel(channel_id);
     if (input_channel == nullptr) {
-      return promise_.set_error(Status::Error(400, "Supergroup not found"));
+      return promise_.set_error(400, "Supergroup not found");
     }
 
     channel_id_ = channel_id;
@@ -734,7 +734,7 @@ class CanEditChannelCreatorQuery final : public Td::ResultHandler {
 
     auto ptr = result_ptr.move_as_ok();
     LOG(ERROR) << "Receive result for CanEditChannelCreatorQuery: " << to_string(ptr);
-    promise_.set_error(Status::Error(500, "Server doesn't returned error"));
+    promise_.set_error(500, "Server doesn't returned error");
   }
 
   void on_error(Status status) final {
@@ -757,7 +757,7 @@ class EditChannelCreatorQuery final : public Td::ResultHandler {
     user_id_ = user_id;
     auto input_channel = td_->chat_manager_->get_input_channel(channel_id);
     if (input_channel == nullptr) {
-      return promise_.set_error(Status::Error(400, "Have no access to the chat"));
+      return promise_.set_error(400, "Have no access to the chat");
     }
     TRY_RESULT_PROMISE(promise_, input_user, td_->user_manager_->get_input_user(user_id));
     send_query(G()->net_query_creator().create(
@@ -1129,7 +1129,7 @@ void DialogParticipantManager::get_dialog_join_requests(
   TRY_STATUS_PROMISE(promise, can_manage_dialog_join_requests(dialog_id));
 
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
 
   UserId offset_user_id;
@@ -1207,7 +1207,7 @@ td_api::object_ptr<td_api::chatAdministrators> DialogParticipantManager::get_cha
 void DialogParticipantManager::get_dialog_administrators(
     DialogId dialog_id, Promise<td_api::object_ptr<td_api::chatAdministrators>> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "get_dialog_administrators")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
@@ -1362,7 +1362,7 @@ void DialogParticipantManager::reload_dialog_administrators(
       auto channel_id = dialog_id.get_channel_id();
       if (td_->chat_manager_->is_broadcast_channel(channel_id) &&
           !td_->chat_manager_->get_channel_status(channel_id).is_administrator()) {
-        return query_promise.set_error(Status::Error(400, "Administrator list is inaccessible"));
+        return query_promise.set_error(400, "Administrator list is inaccessible");
       }
       auto hash = get_vector_hash(transform(dialog_administrators, [](const DialogAdministrator &administrator) {
         return static_cast<uint64>(administrator.get_user_id().get());
@@ -1385,7 +1385,7 @@ void DialogParticipantManager::on_reload_dialog_administrators(
   }
 
   LOG(ERROR) << "Failed to load administrators in " << dialog_id;
-  promise.set_error(Status::Error(500, "Failed to find chat administrators"));
+  promise.set_error(500, "Failed to find chat administrators");
 }
 
 void DialogParticipantManager::send_update_chat_member(DialogId dialog_id, UserId agent_user_id, int32 date,
@@ -1587,7 +1587,7 @@ void DialogParticipantManager::finish_get_dialog_participant(
   bool is_user = participant_dialog_id.get_type() == DialogType::User;
   if ((is_user && !td_->user_manager_->have_user(participant_dialog_id.get_user_id())) ||
       (!is_user && !td_->messages_manager_->have_dialog(participant_dialog_id))) {
-    return promise.set_error(Status::Error(400, "Member not found"));
+    return promise.set_error(400, "Member not found");
   }
 
   promise.set_value(td_->chat_manager_->get_chat_member_object(dialog_participant, "finish_get_dialog_participant"));
@@ -1597,7 +1597,7 @@ void DialogParticipantManager::do_get_dialog_participant(DialogId dialog_id, Dia
                                                          Promise<DialogParticipant> &&promise) {
   LOG(INFO) << "Receive getChatMember request to get " << participant_dialog_id << " in " << dialog_id;
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "do_get_dialog_participant")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
@@ -1611,7 +1611,7 @@ void DialogParticipantManager::do_get_dialog_participant(DialogId dialog_id, Dia
         return promise.set_value(DialogParticipant::private_member(peer_user_id, my_user_id));
       }
 
-      return promise.set_error(Status::Error(400, "Member not found"));
+      return promise.set_error(400, "Member not found");
     }
     case DialogType::Chat:
       if (participant_dialog_id.get_type() != DialogType::User) {
@@ -1631,7 +1631,7 @@ void DialogParticipantManager::do_get_dialog_participant(DialogId dialog_id, Dia
         return promise.set_value(DialogParticipant::private_member(peer_user_id, my_user_id));
       }
 
-      return promise.set_error(Status::Error(400, "Member not found"));
+      return promise.set_error(400, "Member not found");
     }
     case DialogType::None:
     default:
@@ -1646,11 +1646,11 @@ void DialogParticipantManager::get_channel_participant(ChannelId channel_id, Dia
 
   auto input_peer = td_->dialog_manager_->get_input_peer(participant_dialog_id, AccessRights::Know);
   if (input_peer == nullptr) {
-    return promise.set_error(Status::Error(400, "Member not found"));
+    return promise.set_error(400, "Member not found");
   }
   if (td_->chat_manager_->is_broadcast_channel(channel_id) &&
       !td_->chat_manager_->get_channel_status(channel_id).is_administrator()) {
-    return promise.set_error(Status::Error(400, "Member list is inaccessible"));
+    return promise.set_error(400, "Member list is inaccessible");
   }
 
   if (have_channel_participant_cache(channel_id)) {
@@ -1690,7 +1690,7 @@ void DialogParticipantManager::finish_get_channel_participant(ChannelId channel_
   if (dialog_participant.dialog_id_ != participant_dialog_id) {
     LOG(ERROR) << "Receive " << dialog_participant.dialog_id_ << " in " << channel_id << " instead of requested "
                << participant_dialog_id;
-    return promise.set_error(Status::Error(500, "Data is unavailable"));
+    return promise.set_error(500, "Data is unavailable");
   }
 
   LOG(INFO) << "Receive " << dialog_participant.dialog_id_ << " as a member of a channel " << channel_id;
@@ -1750,7 +1750,7 @@ void DialogParticipantManager::search_chat_participants(ChatId chat_id, const st
                                                         DialogParticipantFilter filter,
                                                         Promise<DialogParticipants> &&promise) {
   if (limit < 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be non-negative"));
+    return promise.set_error(400, "Parameter limit must be non-negative");
   }
 
   auto load_chat_full_promise = PromiseCreator::lambda([actor_id = actor_id(this), chat_id, query, limit, filter,
@@ -1772,7 +1772,7 @@ void DialogParticipantManager::do_search_chat_participants(ChatId chat_id, const
 
   const auto *participants = td_->chat_manager_->get_chat_participants(chat_id);
   if (participants == nullptr) {
-    return promise.set_error(Status::Error(500, "Can't find basic group full info"));
+    return promise.set_error(500, "Can't find basic group full info");
   }
 
   vector<DialogId> dialog_ids;
@@ -1802,20 +1802,20 @@ void DialogParticipantManager::get_channel_participants(ChannelId channel_id,
                                                         string additional_query, int32 offset, int32 limit,
                                                         int32 additional_limit, Promise<DialogParticipants> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_GET_CHANNEL_PARTICIPANTS) {
     limit = MAX_GET_CHANNEL_PARTICIPANTS;
   }
 
   if (offset < 0) {
-    return promise.set_error(Status::Error(400, "Parameter offset must be non-negative"));
+    return promise.set_error(400, "Parameter offset must be non-negative");
   }
 
   if (td_->chat_manager_->is_monoforum_channel(channel_id) ||
       (td_->chat_manager_->is_broadcast_channel(channel_id) &&
        !td_->chat_manager_->get_channel_status(channel_id).is_administrator())) {
-    return promise.set_error(Status::Error(400, "Member list is inaccessible"));
+    return promise.set_error(400, "Member list is inaccessible");
   }
 
   ChannelParticipantFilter participant_filter(filter);
@@ -1992,10 +1992,10 @@ void DialogParticipantManager::search_dialog_participants(DialogId dialog_id, co
   LOG(INFO) << "Receive searchChatMembers request to search for \"" << query << "\" in " << dialog_id << " with filter "
             << filter;
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "search_dialog_participants")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (limit < 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be non-negative"));
+    return promise.set_error(400, "Parameter limit must be non-negative");
   }
 
   switch (dialog_id.get_type()) {
@@ -2020,7 +2020,7 @@ void DialogParticipantManager::search_dialog_participants(DialogId dialog_id, co
     case DialogType::None:
     default:
       UNREACHABLE();
-      promise.set_error(Status::Error(500, "Wrong chat type"));
+      promise.set_error(500, "Wrong chat type");
   }
 }
 
@@ -2028,19 +2028,19 @@ void DialogParticipantManager::add_dialog_participant(
     DialogId dialog_id, UserId user_id, int32 forward_limit,
     Promise<td_api::object_ptr<td_api::failedToAddMembers>> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "add_dialog_participant")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't add members to a private chat"));
+      return promise.set_error(400, "Can't add members to a private chat");
     case DialogType::Chat:
       return add_chat_participant(dialog_id.get_chat_id(), user_id, forward_limit, std::move(promise));
     case DialogType::Channel:
       return add_channel_participant(dialog_id.get_channel_id(), user_id, DialogParticipantStatus::Left(),
                                      std::move(promise));
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't add members to a secret chat"));
+      return promise.set_error(400, "Can't add members to a secret chat");
     case DialogType::None:
     default:
       UNREACHABLE();
@@ -2051,21 +2051,21 @@ void DialogParticipantManager::add_dialog_participants(
     DialogId dialog_id, const vector<UserId> &user_ids,
     Promise<td_api::object_ptr<td_api::failedToAddMembers>> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "add_dialog_participants")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't add members to a private chat"));
+      return promise.set_error(400, "Can't add members to a private chat");
     case DialogType::Chat:
       if (user_ids.size() == 1) {
         return add_chat_participant(dialog_id.get_chat_id(), user_ids[0], 0, std::move(promise));
       }
-      return promise.set_error(Status::Error(400, "Can't add many members at once to a basic group chat"));
+      return promise.set_error(400, "Can't add many members at once to a basic group chat");
     case DialogType::Channel:
       return add_channel_participants(dialog_id.get_channel_id(), user_ids, std::move(promise));
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't add members to a secret chat"));
+      return promise.set_error(400, "Can't add members to a secret chat");
     case DialogType::None:
     default:
       UNREACHABLE();
@@ -2076,19 +2076,19 @@ void DialogParticipantManager::set_dialog_participant_status(
     DialogId dialog_id, DialogId participant_dialog_id,
     td_api::object_ptr<td_api::ChatMemberStatus> &&chat_member_status, Promise<Unit> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "set_dialog_participant_status")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Chat member status can't be changed in private chats"));
+      return promise.set_error(400, "Chat member status can't be changed in private chats");
     case DialogType::Chat: {
       auto status = get_dialog_participant_status(chat_member_status, ChannelType::Unknown);
       if (participant_dialog_id.get_type() != DialogType::User) {
         if (status == DialogParticipantStatus::Left()) {
           return promise.set_value(Unit());
         } else {
-          return promise.set_error(Status::Error(400, "Chats can't be members of basic groups"));
+          return promise.set_error(400, "Chats can't be members of basic groups");
         }
       }
       return set_chat_participant_status(dialog_id.get_chat_id(), participant_dialog_id.get_user_id(), status, false,
@@ -2098,7 +2098,7 @@ void DialogParticipantManager::set_dialog_participant_status(
       return set_channel_participant_status(dialog_id.get_channel_id(), participant_dialog_id,
                                             std::move(chat_member_status), std::move(promise));
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Chat member status can't be changed in secret chats"));
+      return promise.set_error(400, "Chat member status can't be changed in secret chats");
     case DialogType::None:
     default:
       UNREACHABLE();
@@ -2109,15 +2109,15 @@ void DialogParticipantManager::ban_dialog_participant(DialogId dialog_id, Dialog
                                                       int32 banned_until_date, bool revoke_messages,
                                                       Promise<Unit> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "ban_dialog_participant")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't ban members in private chats"));
+      return promise.set_error(400, "Can't ban members in private chats");
     case DialogType::Chat:
       if (participant_dialog_id.get_type() != DialogType::User) {
-        return promise.set_error(Status::Error(400, "Can't ban chats in basic groups"));
+        return promise.set_error(400, "Can't ban chats in basic groups");
       }
       return delete_chat_participant(dialog_id.get_chat_id(), participant_dialog_id.get_user_id(), revoke_messages,
                                      std::move(promise));
@@ -2127,7 +2127,7 @@ void DialogParticipantManager::ban_dialog_participant(DialogId dialog_id, Dialog
                                             td_api::make_object<td_api::chatMemberStatusBanned>(banned_until_date),
                                             std::move(promise));
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't ban members in secret chats"));
+      return promise.set_error(400, "Can't ban members in secret chats");
     case DialogType::None:
     default:
       UNREACHABLE();
@@ -2136,12 +2136,12 @@ void DialogParticipantManager::ban_dialog_participant(DialogId dialog_id, Dialog
 
 void DialogParticipantManager::leave_dialog(DialogId dialog_id, Promise<Unit> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "leave_dialog")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't leave private chats"));
+      return promise.set_error(400, "Can't leave private chats");
     case DialogType::Chat:
       return delete_chat_participant(dialog_id.get_chat_id(), td_->user_manager_->get_my_id(), false,
                                      std::move(promise));
@@ -2154,7 +2154,7 @@ void DialogParticipantManager::leave_dialog(DialogId dialog_id, Promise<Unit> &&
                                           std::move(old_status), std::move(promise));
     }
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't leave secret chats"));
+      return promise.set_error(400, "Can't leave secret chats");
     case DialogType::None:
     default:
       UNREACHABLE();
@@ -2169,7 +2169,7 @@ Promise<td_api::object_ptr<td_api::failedToAddMembers>> DialogParticipantManager
           if (result.ok()->failed_to_add_members_.empty()) {
             promise.set_value(Unit());
           } else {
-            promise.set_error(Status::Error(403, "USER_PRIVACY_RESTRICTED"));
+            promise.set_error(403, "USER_PRIVACY_RESTRICTED");
           }
         } else {
           promise.set_error(result.move_as_error());
@@ -2181,20 +2181,20 @@ void DialogParticipantManager::add_chat_participant(ChatId chat_id, UserId user_
                                                     Promise<td_api::object_ptr<td_api::failedToAddMembers>> &&promise) {
   if (!td_->chat_manager_->get_chat_is_active(chat_id)) {
     if (!td_->chat_manager_->have_chat(chat_id)) {
-      return promise.set_error(Status::Error(400, "Chat info not found"));
+      return promise.set_error(400, "Chat info not found");
     }
-    return promise.set_error(Status::Error(400, "Chat is deactivated"));
+    return promise.set_error(400, "Chat is deactivated");
   }
   if (forward_limit < 0) {
-    return promise.set_error(Status::Error(400, "Can't forward negative number of messages"));
+    return promise.set_error(400, "Can't forward negative number of messages");
   }
   auto permissions = td_->chat_manager_->get_chat_permissions(chat_id);
   if (user_id != td_->user_manager_->get_my_id()) {
     if (!permissions.can_invite_users()) {
-      return promise.set_error(Status::Error(400, "Not enough rights to invite members to the group chat"));
+      return promise.set_error(400, "Not enough rights to invite members to the group chat");
     }
   } else if (permissions.is_banned()) {
-    return promise.set_error(Status::Error(400, "User was kicked from the chat"));
+    return promise.set_error(400, "User was kicked from the chat");
   }
   // TODO upper bound on forward_limit
 
@@ -2213,17 +2213,17 @@ void DialogParticipantManager::set_chat_participant_status(ChatId chat_id, UserI
     return delete_chat_participant(chat_id, user_id, false, std::move(promise));
   }
   if (status.is_creator()) {
-    return promise.set_error(Status::Error(400, "Can't change owner in basic group chats"));
+    return promise.set_error(400, "Can't change owner in basic group chats");
   }
   if (status.is_restricted()) {
-    return promise.set_error(Status::Error(400, "Can't restrict users in basic group chats"));
+    return promise.set_error(400, "Can't restrict users in basic group chats");
   }
 
   if (!td_->chat_manager_->get_chat_is_active(chat_id)) {
     if (!td_->chat_manager_->have_chat(chat_id)) {
-      return promise.set_error(Status::Error(400, "Chat info not found"));
+      return promise.set_error(400, "Chat info not found");
     }
-    return promise.set_error(Status::Error(400, "Chat is deactivated"));
+    return promise.set_error(400, "Chat is deactivated");
   }
 
   if (!is_recursive) {
@@ -2249,11 +2249,11 @@ void DialogParticipantManager::set_chat_participant_status(ChatId chat_id, UserI
 
   auto permissions = td_->chat_manager_->get_chat_permissions(chat_id);
   if (!permissions.can_promote_members()) {
-    return promise.set_error(Status::Error(400, "Need owner rights in the group chat"));
+    return promise.set_error(400, "Need owner rights in the group chat");
   }
 
   if (user_id == td_->user_manager_->get_my_id()) {
-    return promise.set_error(Status::Error(400, "Can't promote or demote self"));
+    return promise.set_error(400, "Can't promote or demote self");
   }
 
   if (participant == nullptr) {
@@ -2265,7 +2265,7 @@ void DialogParticipantManager::set_chat_participant_status(ChatId chat_id, UserI
           if (result.is_error()) {
             promise.set_error(result.move_as_error());
           } else if (!result.ok()->failed_to_add_members_.empty()) {
-            promise.set_error(Status::Error(403, "USER_PRIVACY_RESTRICTED"));
+            promise.set_error(403, "USER_PRIVACY_RESTRICTED");
           } else {
             send_closure(actor_id, &DialogParticipantManager::send_edit_chat_admin_query, chat_id, user_id, true,
                          std::move(promise));
@@ -2291,9 +2291,9 @@ void DialogParticipantManager::delete_chat_participant(ChatId chat_id, UserId us
                                                        Promise<Unit> &&promise) {
   if (!td_->chat_manager_->get_chat_is_active(chat_id)) {
     if (!td_->chat_manager_->have_chat(chat_id)) {
-      return promise.set_error(Status::Error(400, "Chat info not found"));
+      return promise.set_error(400, "Chat info not found");
     }
-    return promise.set_error(Status::Error(400, "Chat is deactivated"));
+    return promise.set_error(400, "Chat is deactivated");
   }
 
   auto my_id = td_->user_manager_->get_my_id();
@@ -2305,7 +2305,7 @@ void DialogParticipantManager::delete_chat_participant(ChatId chat_id, UserId us
       }
       return promise.set_value(Unit());
     } else {
-      return promise.set_error(Status::Error(400, "Not in the chat"));
+      return promise.set_error(400, "Not in the chat");
     }
   }
   /* TODO
@@ -2316,17 +2316,17 @@ void DialogParticipantManager::delete_chat_participant(ChatId chat_id, UserId us
         if (c->everyone_is_administrator) {
           // if all are administrators, only invited by me participants can be deleted
           if (participant->inviter_user_id_ != my_id) {
-            return promise.set_error(Status::Error(400, "Need to be inviter of a user to kick it from a basic group"));
+            return promise.set_error(400, "Need to be inviter of a user to kick it from a basic group");
           }
         } else {
           // otherwise, only creator can kick administrators
           if (participant->status_.is_administrator()) {
             return promise.set_error(
-                Status::Error(400, "Only the creator of a basic group can kick group administrators"));
+                400, "Only the creator of a basic group can kick group administrators");
           }
           // regular users can be kicked by administrators and their inviters
           if (!permissions.is_administrator() && participant->inviter_user_id_ != my_id) {
-            return promise.set_error(Status::Error(400, "Need to be inviter of a user to kick it from a basic group"));
+            return promise.set_error(400, "Need to be inviter of a user to kick it from a basic group");
           }
         }
       }
@@ -2344,11 +2344,11 @@ void DialogParticipantManager::add_channel_participant(
     Promise<td_api::object_ptr<td_api::failedToAddMembers>> &&promise) {
   TRY_STATUS_PROMISE(promise, G()->close_status());
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Bots can't add new chat members"));
+    return promise.set_error(400, "Bots can't add new chat members");
   }
 
   if (!td_->chat_manager_->have_channel(channel_id)) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(user_id));
 
@@ -2356,11 +2356,11 @@ void DialogParticipantManager::add_channel_participant(
     // join the channel
     if (td_->chat_manager_->is_monoforum_channel(channel_id) &&
         !td_->chat_manager_->is_admined_monoforum_channel(channel_id)) {
-      return promise.set_error(Status::Error(400, "The chat can't be joined explicitly; send a message instead"));
+      return promise.set_error(400, "The chat can't be joined explicitly; send a message instead");
     }
     auto my_status = td_->chat_manager_->get_channel_status(channel_id);
     if (my_status.is_banned()) {
-      return promise.set_error(Status::Error(400, "Can't return to kicked from chat"));
+      return promise.set_error(400, "Can't return to kicked from chat");
     }
     if (my_status.is_member()) {
       return promise.set_value(MissingInvitees().get_failed_to_add_members_object(td_->user_manager_.get()));
@@ -2387,11 +2387,11 @@ void DialogParticipantManager::add_channel_participant(
     return;
   }
   if (td_->chat_manager_->is_monoforum_channel(channel_id)) {
-    return promise.set_error(Status::Error(400, "Members can't be added to the chat explicitly"));
+    return promise.set_error(400, "Members can't be added to the chat explicitly");
   }
 
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_invite_users()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to invite members to the supergroup chat"));
+    return promise.set_error(400, "Not enough rights to invite members to the supergroup chat");
   }
 
   speculative_add_channel_user(channel_id, user_id, DialogParticipantStatus::Member(0), old_status);
@@ -2427,16 +2427,16 @@ void DialogParticipantManager::add_channel_participants(
     ChannelId channel_id, const vector<UserId> &user_ids,
     Promise<td_api::object_ptr<td_api::failedToAddMembers>> &&promise) {
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Bots can't add new chat members"));
+    return promise.set_error(400, "Bots can't add new chat members");
   }
 
   if (!td_->chat_manager_->have_channel(channel_id)) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
 
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_invite_users() ||
       td_->chat_manager_->is_monoforum_channel(channel_id)) {
-    return promise.set_error(Status::Error(400, "Not enough rights to invite members to the supergroup chat"));
+    return promise.set_error(400, "Not enough rights to invite members to the supergroup chat");
   }
 
   vector<tl_object_ptr<telegram_api::InputUser>> input_users;
@@ -2464,7 +2464,7 @@ void DialogParticipantManager::set_channel_participant_status(
     ChannelId channel_id, DialogId participant_dialog_id,
     td_api::object_ptr<td_api::ChatMemberStatus> &&chat_member_status, Promise<Unit> &&promise) {
   if (!td_->chat_manager_->have_channel(channel_id)) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   auto new_status = get_dialog_participant_status(chat_member_status, td_->chat_manager_->get_channel_type(channel_id));
 
@@ -2475,7 +2475,7 @@ void DialogParticipantManager::set_channel_participant_status(
   }
   if (participant_dialog_id.get_type() != DialogType::User) {
     if (new_status.is_administrator() || new_status.is_member() || new_status.is_restricted()) {
-      return promise.set_error(Status::Error(400, "Other chats can be only banned or unbanned"));
+      return promise.set_error(400, "Other chats can be only banned or unbanned");
     }
     // always pretend that old_status is different
     return restrict_channel_participant(
@@ -2515,17 +2515,17 @@ void DialogParticipantManager::set_channel_participant_status_impl(ChannelId cha
   bool need_restrict = false;
   if (new_status.is_creator() || old_status.is_creator()) {
     if (td_->chat_manager_->is_monoforum_channel(channel_id)) {
-      return promise.set_error(Status::Error(400, "Can't edit chat owner"));
+      return promise.set_error(400, "Can't edit chat owner");
     }
     if (!old_status.is_creator()) {
-      return promise.set_error(Status::Error(400, "Can't add another owner to the chat"));
+      return promise.set_error(400, "Can't add another owner to the chat");
     }
     if (!new_status.is_creator()) {
-      return promise.set_error(Status::Error(400, "Can't remove chat owner"));
+      return promise.set_error(400, "Can't remove chat owner");
     }
     auto user_id = td_->user_manager_->get_my_id();
     if (participant_dialog_id != DialogId(user_id)) {
-      return promise.set_error(Status::Error(400, "Not enough rights to edit chat owner rights"));
+      return promise.set_error(400, "Not enough rights to edit chat owner rights");
     }
     if (new_status.is_member() == old_status.is_member()) {
       // change rank and is_anonymous
@@ -2573,7 +2573,7 @@ void DialogParticipantManager::set_channel_participant_status_impl(ChannelId cha
 
   if (need_promote) {
     if (participant_dialog_id.get_type() != DialogType::User) {
-      return promise.set_error(Status::Error(400, "Can't promote chats to chat administrators"));
+      return promise.set_error(400, "Can't promote chats to chat administrators");
     }
     return promote_channel_participant(channel_id, participant_dialog_id.get_user_id(), new_status, old_status,
                                        std::move(promise));
@@ -2583,7 +2583,7 @@ void DialogParticipantManager::set_channel_participant_status_impl(ChannelId cha
   } else {
     CHECK(need_add);
     if (participant_dialog_id.get_type() != DialogType::User) {
-      return promise.set_error(Status::Error(400, "Can't add chats as chat members"));
+      return promise.set_error(400, "Can't add chats as chat members");
     }
     return add_channel_participant(channel_id, participant_dialog_id.get_user_id(), old_status,
                                    wrap_failed_to_add_members_promise(std::move(promise)));
@@ -2596,17 +2596,17 @@ void DialogParticipantManager::promote_channel_participant(ChannelId channel_id,
                                                            Promise<Unit> &&promise) {
   LOG(INFO) << "Promote " << user_id << " in " << channel_id << " from " << old_status << " to " << new_status;
   if (td_->chat_manager_->is_monoforum_channel(channel_id)) {
-    return promise.set_error(Status::Error(400, "Can't promote members in the chat"));
+    return promise.set_error(400, "Can't promote members in the chat");
   }
   if (user_id == td_->user_manager_->get_my_id()) {
     if (new_status.is_administrator()) {
-      return promise.set_error(Status::Error(400, "Can't promote self"));
+      return promise.set_error(400, "Can't promote self");
     }
     CHECK(new_status.is_member());
     // allow to demote self. TODO is it allowed server-side?
   } else {
     if (!td_->chat_manager_->get_channel_permissions(channel_id).can_promote_members()) {
-      return promise.set_error(Status::Error(400, "Not enough rights"));
+      return promise.set_error(400, "Not enough rights");
     }
 
     CHECK(!old_status.is_creator());
@@ -2629,30 +2629,30 @@ void DialogParticipantManager::restrict_channel_participant(ChannelId channel_id
   LOG(INFO) << "Restrict " << participant_dialog_id << " in " << channel_id << " from " << old_status << " to "
             << new_status;
   if (!td_->chat_manager_->have_channel(channel_id)) {
-    return promise.set_error(Status::Error(400, "Chat info not found"));
+    return promise.set_error(400, "Chat info not found");
   }
   auto my_status = td_->chat_manager_->get_channel_status(channel_id);
   if (!my_status.is_member() && !my_status.is_creator()) {
     if (participant_dialog_id == td_->dialog_manager_->get_my_dialog_id()) {
       if (new_status.is_member()) {
-        return promise.set_error(Status::Error(400, "Can't unrestrict self"));
+        return promise.set_error(400, "Can't unrestrict self");
       }
       return promise.set_value(Unit());
     } else {
-      return promise.set_error(Status::Error(400, "Not in the chat"));
+      return promise.set_error(400, "Not in the chat");
     }
   }
   auto input_peer = td_->dialog_manager_->get_input_peer(participant_dialog_id, AccessRights::Know);
   if (input_peer == nullptr) {
-    return promise.set_error(Status::Error(400, "Member not found"));
+    return promise.set_error(400, "Member not found");
   }
 
   if (participant_dialog_id == td_->dialog_manager_->get_my_dialog_id()) {
     if (new_status.is_restricted() || new_status.is_banned()) {
-      return promise.set_error(Status::Error(400, "Can't restrict self"));
+      return promise.set_error(400, "Can't restrict self");
     }
     if (new_status.is_member()) {
-      return promise.set_error(Status::Error(400, "Can't unrestrict self"));
+      return promise.set_error(400, "Can't unrestrict self");
     }
 
     // leave the channel
@@ -2667,22 +2667,22 @@ void DialogParticipantManager::restrict_channel_participant(ChannelId channel_id
       break;
     case DialogType::Channel:
       if (new_status.is_administrator() || new_status.is_member() || new_status.is_restricted()) {
-        return promise.set_error(Status::Error(400, "Other chats can be only banned or unbanned"));
+        return promise.set_error(400, "Other chats can be only banned or unbanned");
       }
       break;
     default:
-      return promise.set_error(Status::Error(400, "Can't restrict the chat"));
+      return promise.set_error(400, "Can't restrict the chat");
   }
 
   CHECK(!old_status.is_creator());
   CHECK(!new_status.is_creator());
 
   if (td_->chat_manager_->is_monoforum_channel(channel_id)) {
-    return promise.set_error(Status::Error(
-        400, "Can't restrict members in the chat; users must be banned in the corresponding channel chat"));
+    return promise.set_error(
+        400, "Can't restrict members in the chat; users must be banned in the corresponding channel chat");
   }
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_restrict_members()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to restrict/unrestrict chat member"));
+    return promise.set_error(400, "Not enough rights to restrict/unrestrict chat member");
   }
 
   if (old_status.is_member() && !new_status.is_member() && !new_status.is_banned()) {
@@ -3001,26 +3001,26 @@ DialogParticipantManager::get_can_transfer_ownership_result_object(CanTransferOw
 void DialogParticipantManager::transfer_dialog_ownership(DialogId dialog_id, UserId user_id, const string &password,
                                                          Promise<Unit> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "transfer_dialog_ownership")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (!td_->user_manager_->have_user_force(user_id, "transfer_dialog_ownership")) {
-    return promise.set_error(Status::Error(400, "User not found"));
+    return promise.set_error(400, "User not found");
   }
   if (td_->user_manager_->is_user_bot(user_id)) {
-    return promise.set_error(Status::Error(400, "User is a bot"));
+    return promise.set_error(400, "User is a bot");
   }
   if (td_->user_manager_->is_user_deleted(user_id)) {
-    return promise.set_error(Status::Error(400, "User is deleted"));
+    return promise.set_error(400, "User is deleted");
   }
   if (password.empty()) {
-    return promise.set_error(Status::Error(400, "PASSWORD_HASH_INVALID"));
+    return promise.set_error(400, "PASSWORD_HASH_INVALID");
   }
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
     case DialogType::Chat:
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't transfer chat ownership"));
+      return promise.set_error(400, "Can't transfer chat ownership");
     case DialogType::Channel:
       send_closure(
           td_->password_manager_, &PasswordManager::get_input_check_password_srp, password,
diff --git a/td/telegram/DownloadManager.cpp b/td/telegram/DownloadManager.cpp
index eaca24bd2..c23413e73 100644
--- a/td/telegram/DownloadManager.cpp
+++ b/td/telegram/DownloadManager.cpp
@@ -217,13 +217,13 @@ class DownloadManagerImpl final : public DownloadManager {
     }
 
     if (limit <= 0) {
-      return promise.set_error(Status::Error(400, "Limit must be positive"));
+      return promise.set_error(400, "Limit must be positive");
     }
     int64 offset_int64 = std::numeric_limits<int64>::max();
     if (!offset.empty()) {
       auto r_offset = to_integer_safe<int64>(offset);
       if (r_offset.is_error()) {
-        return promise.set_error(Status::Error(400, "Invalid offset"));
+        return promise.set_error(400, "Invalid offset");
       }
       offset_int64 = r_offset.move_as_ok();
     }
diff --git a/td/telegram/EmojiStatus.cpp b/td/telegram/EmojiStatus.cpp
index ddcff8f2f..6339763c3 100644
--- a/td/telegram/EmojiStatus.cpp
+++ b/td/telegram/EmojiStatus.cpp
@@ -185,7 +185,7 @@ class GetDefaultEmojiStatusesQuery final : public Td::ResultHandler {
 
     if (emoji_statuses_ptr->get_id() == telegram_api::account_emojiStatusesNotModified::ID) {
       if (promise_) {
-        promise_.set_error(Status::Error(500, "Receive wrong server response"));
+        promise_.set_error(500, "Receive wrong server response");
       }
       return;
     }
@@ -228,7 +228,7 @@ class GetChannelDefaultEmojiStatusesQuery final : public Td::ResultHandler {
 
     if (emoji_statuses_ptr->get_id() == telegram_api::account_emojiStatusesNotModified::ID) {
       if (promise_) {
-        promise_.set_error(Status::Error(500, "Receive wrong server response"));
+        promise_.set_error(500, "Receive wrong server response");
       }
       return;
     }
@@ -271,7 +271,7 @@ class GetRecentEmojiStatusesQuery final : public Td::ResultHandler {
 
     if (emoji_statuses_ptr->get_id() == telegram_api::account_emojiStatusesNotModified::ID) {
       if (promise_) {
-        promise_.set_error(Status::Error(500, "Receive wrong server response"));
+        promise_.set_error(500, "Receive wrong server response");
       }
       return;
     }
@@ -339,7 +339,7 @@ class GetCollectibleEmojiStatusesQuery final : public Td::ResultHandler {
 
     if (emoji_statuses_ptr->get_id() == telegram_api::account_emojiStatusesNotModified::ID) {
       if (promise_) {
-        promise_.set_error(Status::Error(500, "Receive wrong server response"));
+        promise_.set_error(500, "Receive wrong server response");
       }
       return;
     }
diff --git a/td/telegram/FileReferenceManager.cpp b/td/telegram/FileReferenceManager.cpp
index bfd74be86..be5b0d048 100644
--- a/td/telegram/FileReferenceManager.cpp
+++ b/td/telegram/FileReferenceManager.cpp
@@ -314,9 +314,9 @@ void FileReferenceManager::run_node(NodeId node_id) {
     VLOG(file_references) << "Have no more file sources to repair file reference for file " << node_id;
     for (auto &p : node.query->promises) {
       if (node.file_source_ids.empty()) {
-        p.set_error(Status::Error(400, "File source is not found"));
+        p.set_error(400, "File source is not found");
       } else {
-        p.set_error(Status::Error(429, "Too Many Requests: retry after 1"));
+        p.set_error(429, "Too Many Requests: retry after 1");
       }
     }
     node.query = {};
@@ -325,7 +325,7 @@ void FileReferenceManager::run_node(NodeId node_id) {
   if (node.last_successful_repair_time >= Time::now() - 60) {
     VLOG(file_references) << "Recently repaired file reference for file " << node_id << ", do not try again";
     for (auto &p : node.query->promises) {
-      p.set_error(Status::Error(429, "Too Many Requests: retry after 60"));
+      p.set_error(429, "Too Many Requests: retry after 60");
     }
     node.query = {};
     return;
@@ -372,7 +372,7 @@ void FileReferenceManager::send_query(Destination dest, FileSourceId file_source
         send_closure_later(G()->chat_manager(), &ChatManager::reload_channel, source.channel_id, std::move(promise),
                            "FileSourceChannelPhoto");
       },
-      [&](const FileSourceWallpapers &source) { promise.set_error(Status::Error("Can't repair old wallpapers")); },
+      [&](const FileSourceWallpapers &source) { promise.set_error("Can't repair old wallpapers"); },
       [&](const FileSourceWebPage &source) {
         send_closure_later(G()->web_pages_manager(), &WebPagesManager::reload_web_page_by_url, source.url, false,
                            PromiseCreator::lambda([promise = std::move(promise)](Result<WebPageId> &&result) mutable {
@@ -524,7 +524,7 @@ void FileReferenceManager::reload_photo(PhotoSizeSource source, Promise<Unit> pr
     case PhotoSizeSource::Type::Legacy:
     case PhotoSizeSource::Type::FullLegacy:
     case PhotoSizeSource::Type::Thumbnail:
-      promise.set_error(Status::Error("Unexpected PhotoSizeSource type"));
+      promise.set_error("Unexpected PhotoSizeSource type");
       break;
     default:
       UNREACHABLE();
@@ -540,7 +540,7 @@ void FileReferenceManager::get_file_search_text(FileSourceId file_source_id, str
         send_closure_later(G()->messages_manager(), &MessagesManager::get_message_file_search_text,
                            source.message_full_id, std::move(unique_file_id), std::move(promise));
       },
-      [&](const auto &source) { promise.set_error(Status::Error(500, "Unsupported file source")); }));
+      [&](const auto &source) { promise.set_error(500, "Unsupported file source"); }));
 }
 
 td_api::object_ptr<td_api::message> FileReferenceManager::get_message_object(FileSourceId file_source_id) const {
diff --git a/td/telegram/ForumTopicManager.cpp b/td/telegram/ForumTopicManager.cpp
index 6315dea60..cf9355c98 100644
--- a/td/telegram/ForumTopicManager.cpp
+++ b/td/telegram/ForumTopicManager.cpp
@@ -95,12 +95,12 @@ class CreateForumTopicQuery final : public Td::ResultHandler {
     auto message = UpdatesManager::get_message_by_random_id(ptr.get(), DialogId(channel_id_), random_id_);
     if (message == nullptr || message->get_id() != telegram_api::messageService::ID) {
       LOG(ERROR) << "Receive invalid result for CreateForumTopicQuery: " << to_string(ptr);
-      return promise_.set_error(Status::Error(400, "Invalid result received"));
+      return promise_.set_error(400, "Invalid result received");
     }
     auto service_message = static_cast<const telegram_api::messageService *>(message);
     if (service_message->action_->get_id() != telegram_api::messageActionTopicCreate::ID) {
       LOG(ERROR) << "Receive invalid result for CreateForumTopicQuery: " << to_string(ptr);
-      return promise_.set_error(Status::Error(400, "Invalid result received"));
+      return promise_.set_error(400, "Invalid result received");
     }
 
     auto action = static_cast<const telegram_api::messageActionTopicCreate *>(service_message->action_.get());
@@ -502,12 +502,12 @@ void ForumTopicManager::create_forum_topic(DialogId dialog_id, string &&title,
   auto channel_id = dialog_id.get_channel_id();
 
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_create_topics()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to create a topic"));
+    return promise.set_error(400, "Not enough rights to create a topic");
   }
 
   auto new_title = clean_name(std::move(title), MAX_FORUM_TOPIC_TITLE_LENGTH);
   if (new_title.empty()) {
-    return promise.set_error(Status::Error(400, "Title must be non-empty"));
+    return promise.set_error(400, "Title must be non-empty");
   }
 
   int32 icon_color = -1;
@@ -515,7 +515,7 @@ void ForumTopicManager::create_forum_topic(DialogId dialog_id, string &&title,
   if (icon != nullptr) {
     icon_color = icon->color_;
     if (icon_color < 0 || icon_color > 0xFFFFFF) {
-      return promise.set_error(Status::Error(400, "Invalid icon color specified"));
+      return promise.set_error(400, "Invalid icon color specified");
     }
     icon_custom_emoji_id = CustomEmojiId(icon->custom_emoji_id_);
   }
@@ -553,14 +553,14 @@ void ForumTopicManager::edit_forum_topic(DialogId dialog_id, MessageId top_threa
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_edit_topics()) {
     auto topic_info = get_topic_info(dialog_id, top_thread_message_id);
     if (topic_info != nullptr && !topic_info->is_outgoing()) {
-      return promise.set_error(Status::Error(400, "Not enough rights to edit the topic"));
+      return promise.set_error(400, "Not enough rights to edit the topic");
     }
   }
 
   bool edit_title = !title.empty();
   auto new_title = clean_name(std::move(title), MAX_FORUM_TOPIC_TITLE_LENGTH);
   if (edit_title && new_title.empty()) {
-    return promise.set_error(Status::Error(400, "Title must be non-empty"));
+    return promise.set_error(400, "Title must be non-empty");
   }
   if (!edit_title && !edit_icon_custom_emoji) {
     return promise.set_value(Unit());
@@ -772,7 +772,7 @@ void ForumTopicManager::on_get_forum_topic(ChannelId channel_id, MessageId expec
     return promise.set_value(nullptr);
   }
   if (top_thread_message_id != expected_top_thread_message_id) {
-    return promise.set_error(Status::Error(500, "Wrong forum topic received"));
+    return promise.set_error(500, "Wrong forum topic received");
   }
   promise.set_value(get_forum_topic_object(dialog_id, top_thread_message_id));
 }
@@ -806,16 +806,16 @@ void ForumTopicManager::get_forum_topics(DialogId dialog_id, string query, int32
   auto channel_id = dialog_id.get_channel_id();
 
   if (offset_date < 0) {
-    return promise.set_error(Status::Error(400, "Invalid offset date specified"));
+    return promise.set_error(400, "Invalid offset date specified");
   }
   if (offset_message_id != MessageId() && !offset_message_id.is_valid() && !offset_message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Invalid offset message identifier specified"));
+    return promise.set_error(400, "Invalid offset message identifier specified");
   }
   if (offset_top_thread_message_id != MessageId()) {
     TRY_STATUS_PROMISE(promise, can_be_message_thread_id(offset_top_thread_message_id));
   }
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Invalid limit specified"));
+    return promise.set_error(400, "Invalid limit specified");
   }
   td_->create_handler<GetForumTopicsQuery>(std::move(promise))
       ->send(channel_id, query, offset_date, offset_message_id, offset_top_thread_message_id, limit);
@@ -864,7 +864,7 @@ void ForumTopicManager::toggle_forum_topic_is_closed(DialogId dialog_id, Message
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_edit_topics()) {
     auto topic_info = get_topic_info(dialog_id, top_thread_message_id);
     if (topic_info != nullptr && !topic_info->is_outgoing()) {
-      return promise.set_error(Status::Error(400, "Not enough rights to close or open the topic"));
+      return promise.set_error(400, "Not enough rights to close or open the topic");
     }
   }
 
@@ -876,7 +876,7 @@ void ForumTopicManager::toggle_forum_topic_is_hidden(DialogId dialog_id, bool is
   auto channel_id = dialog_id.get_channel_id();
 
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_edit_topics()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to close or open the topic"));
+    return promise.set_error(400, "Not enough rights to close or open the topic");
   }
 
   td_->create_handler<EditForumTopicQuery>(std::move(promise))->send(channel_id, is_hidden);
@@ -889,7 +889,7 @@ void ForumTopicManager::toggle_forum_topic_is_pinned(DialogId dialog_id, Message
   auto channel_id = dialog_id.get_channel_id();
 
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_pin_topics()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to pin or unpin the topic"));
+    return promise.set_error(400, "Not enough rights to pin or unpin the topic");
   }
 
   td_->create_handler<UpdatePinnedForumTopicQuery>(std::move(promise))
@@ -905,7 +905,7 @@ void ForumTopicManager::set_pinned_forum_topics(DialogId dialog_id, vector<Messa
   auto channel_id = dialog_id.get_channel_id();
 
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_pin_topics()) {
-    return promise.set_error(Status::Error(400, "Not enough rights to reorder forum topics"));
+    return promise.set_error(400, "Not enough rights to reorder forum topics");
   }
 
   td_->create_handler<ReorderPinnedForumTopicsQuery>(std::move(promise))->send(channel_id, top_thread_message_ids);
@@ -920,7 +920,7 @@ void ForumTopicManager::delete_forum_topic(DialogId dialog_id, MessageId top_thr
   if (!td_->chat_manager_->get_channel_permissions(channel_id).can_delete_messages()) {
     auto topic_info = get_topic_info(dialog_id, top_thread_message_id);
     if (topic_info != nullptr && !topic_info->is_outgoing()) {
-      return promise.set_error(Status::Error(400, "Not enough rights to delete the topic"));
+      return promise.set_error(400, "Not enough rights to delete the topic");
     }
   }
 
diff --git a/td/telegram/GameManager.cpp b/td/telegram/GameManager.cpp
index 134c03b88..2d3b4d37a 100644
--- a/td/telegram/GameManager.cpp
+++ b/td/telegram/GameManager.cpp
@@ -119,13 +119,13 @@ void GameManager::set_game_score(MessageFullId message_full_id, bool edit_messag
   TRY_STATUS_PROMISE(promise,
                      td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Edit, "set_game_score"));
   if (!td_->messages_manager_->have_message_force(message_full_id, "set_game_score")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(user_id));
 
   if (!td_->messages_manager_->can_set_game_score(message_full_id)) {
-    return promise.set_error(Status::Error(400, "Game score can't be set"));
+    return promise.set_error(400, "Game score can't be set");
   }
 
   auto query_promise = PromiseCreator::lambda(
@@ -153,12 +153,12 @@ void GameManager::get_game_high_scores(MessageFullId message_full_id, UserId use
       promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Read, "get_game_high_scores"));
 
   if (!td_->messages_manager_->have_message_force(message_full_id, "get_game_high_scores")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   auto message_id = message_full_id.get_message_id();
   if (message_id.is_scheduled() || !message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Wrong message identifier specified"));
+    return promise.set_error(400, "Wrong message identifier specified");
   }
 
   TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(user_id));
diff --git a/td/telegram/GroupCallManager.cpp b/td/telegram/GroupCallManager.cpp
index 0df3bae34..12e9b77ea 100644
--- a/td/telegram/GroupCallManager.cpp
+++ b/td/telegram/GroupCallManager.cpp
@@ -1189,7 +1189,7 @@ class CheckGroupCallQuery final : public Td::ResultHandler {
     if (!active_audio_sources.empty()) {
       promise_.set_value(Unit());
     } else {
-      promise_.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+      promise_.set_error(400, "GROUPCALL_JOIN_MISSING");
     }
   }
 
@@ -1770,22 +1770,22 @@ void GroupCallManager::set_group_call_default_join_as(DialogId dialog_id, Dialog
   switch (as_dialog_id.get_type()) {
     case DialogType::User:
       if (as_dialog_id != td_->dialog_manager_->get_my_dialog_id()) {
-        return promise.set_error(Status::Error(400, "Can't join video chat as another user"));
+        return promise.set_error(400, "Can't join video chat as another user");
       }
       break;
     case DialogType::Chat:
     case DialogType::Channel:
       if (!td_->dialog_manager_->have_dialog_force(as_dialog_id, "set_group_call_default_join_as 2")) {
-        return promise.set_error(Status::Error(400, "Participant chat not found"));
+        return promise.set_error(400, "Participant chat not found");
       }
       break;
     case DialogType::SecretChat:
-      return promise.set_error(Status::Error(400, "Can't join video chat as a secret chat"));
+      return promise.set_error(400, "Can't join video chat as a secret chat");
     default:
-      return promise.set_error(Status::Error(400, "Invalid default participant identifier specified"));
+      return promise.set_error(400, "Invalid default participant identifier specified");
   }
   if (!td_->dialog_manager_->have_input_peer(as_dialog_id, false, AccessRights::Read)) {
-    return promise.set_error(Status::Error(400, "Can't access specified default participant chat"));
+    return promise.set_error(400, "Can't access specified default participant chat");
   }
 
   td_->create_handler<SaveDefaultGroupCallJoinAsQuery>(std::move(promise))->send(dialog_id, as_dialog_id);
@@ -1823,7 +1823,7 @@ void GroupCallManager::create_group_call(td_api::object_ptr<td_api::groupCallJoi
     data.is_join_ = true;
     auto r_private_key_id = tde2e_api::key_generate_temporary_private_key();
     if (r_private_key_id.is_error()) {
-      return promise.set_error(Status::Error(400, "Failed to generate encryption key"));
+      return promise.set_error(400, "Failed to generate encryption key");
     }
     data.private_key_id_ = tde2e_move_as_ok(r_private_key_id);
 
@@ -1903,7 +1903,7 @@ void GroupCallManager::on_create_group_call_finished(InputGroupCallId input_grou
   if (is_join) {
     auto it = group_call_join_payloads_.find(input_group_call_id);
     if (it == group_call_join_payloads_.end()) {
-      promise.set_error(Status::Error(500, "Receive no join payload"));
+      promise.set_error(500, "Receive no join payload");
       return finish_join_group_call(input_group_call_id, 1, Status::Error(500, "Receive no join payload"));
     }
     payload = std::move(it->second);
@@ -1980,10 +1980,10 @@ void GroupCallManager::on_update_group_call_rights(InputGroupCallId input_group_
 void GroupCallManager::reload_group_call(InputGroupCallId input_group_call_id,
                                          Promise<td_api::object_ptr<td_api::groupCall>> &&promise) {
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Bots can't get group call info"));
+    return promise.set_error(400, "Bots can't get group call info");
   }
   if (!input_group_call_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid group call identifier specified"));
+    return promise.set_error(400, "Invalid group call identifier specified");
   }
 
   auto &queries = load_group_call_queries_[input_group_call_id];
@@ -3032,7 +3032,7 @@ int32 GroupCallManager::cancel_join_group_call_request(InputGroupCallId input_gr
   }
   tde2e_api::key_destroy(it->second->private_key_id);
   tde2e_api::key_destroy(it->second->public_key_id);
-  it->second->promise.set_error(Status::Error(200, "Canceled"));
+  it->second->promise.set_error(200, "Canceled");
   auto audio_source = it->second->audio_source;
   pending_join_requests_.erase(it);
   return audio_source;
@@ -3048,7 +3048,7 @@ int32 GroupCallManager::cancel_join_group_call_presentation_request(InputGroupCa
   if (!it->second->query_ref.empty()) {
     cancel_query(it->second->query_ref);
   }
-  it->second->promise.set_error(Status::Error(200, "Canceled"));
+  it->second->promise.set_error(200, "Canceled");
   auto audio_source = it->second->audio_source;
   pending_join_presentation_requests_.erase(it);
   return audio_source;
@@ -3074,7 +3074,7 @@ void GroupCallManager::get_group_call_streams(GroupCallId group_call_id,
     return;
   }
   if (group_call->is_conference || !group_call->is_active || !group_call->stream_dc_id.is_exact()) {
-    return promise.set_error(Status::Error(400, "Group call can't be streamed"));
+    return promise.set_error(400, "Group call can't be streamed");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -3088,7 +3088,7 @@ void GroupCallManager::get_group_call_streams(GroupCallId group_call_id,
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   auto query_promise = PromiseCreator::lambda(
@@ -3137,7 +3137,7 @@ void GroupCallManager::get_group_call_stream_segment(GroupCallId group_call_id,
     return;
   }
   if (group_call->is_conference || !group_call->is_active || !group_call->stream_dc_id.is_exact()) {
-    return promise.set_error(Status::Error(400, "Group call can't be streamed"));
+    return promise.set_error(400, "Group call can't be streamed");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -3153,7 +3153,7 @@ void GroupCallManager::get_group_call_stream_segment(GroupCallId group_call_id,
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   int32 video_quality = 0;
@@ -3223,13 +3223,13 @@ void GroupCallManager::start_scheduled_group_call(GroupCallId group_call_id, Pro
     return;
   }
   if (group_call->is_conference) {
-    return promise.set_error(Status::Error(400, "The group call isn't scheduled"));
+    return promise.set_error(400, "The group call isn't scheduled");
   }
   if (!group_call->can_be_managed) {
-    return promise.set_error(Status::Error(400, "Not enough rights to start the group call"));
+    return promise.set_error(400, "Not enough rights to start the group call");
   }
   if (!group_call->is_active) {
-    return promise.set_error(Status::Error(400, "Group call already ended"));
+    return promise.set_error(400, "Group call already ended");
   }
   if (group_call->scheduled_start_date == 0) {
     return promise.set_value(Unit());
@@ -3278,33 +3278,33 @@ void GroupCallManager::do_join_group_call(InputGroupCall &&input_group_call, Gro
   auto *group_call = get_group_call(input_group_call_id);
   if (group_call != nullptr) {
     if (group_call->is_inited && !group_call->is_active) {
-      return promise.set_error(Status::Error(400, "Video chat is finished"));
+      return promise.set_error(400, "Video chat is finished");
     }
     if (group_call->is_inited && !group_call->is_conference) {
       // shouldn't happen
-      return promise.set_error(Status::Error(400, "The group call must be joined using joinVideoChat"));
+      return promise.set_error(400, "The group call must be joined using joinVideoChat");
     }
     if (group_call->is_joined) {
-      return promise.set_error(Status::Error(400, "The group call is already joined"));
+      return promise.set_error(400, "The group call is already joined");
     }
   }
 
   if (updates->get_id() != telegram_api::updates::ID) {
-    return promise.set_error(Status::Error(500, "Receive invalid block"));
+    return promise.set_error(500, "Receive invalid block");
   }
   auto &blocks = static_cast<telegram_api::updates *>(updates.get())->updates_;
   if (blocks.size() != 1u || blocks[0]->get_id() != telegram_api::updateGroupCallChainBlocks::ID) {
-    return promise.set_error(Status::Error(500, "Receive invalid block updates"));
+    return promise.set_error(500, "Receive invalid block updates");
   }
   auto update = telegram_api::move_object_as<telegram_api::updateGroupCallChainBlocks>(blocks[0]);
   if (update->blocks_.size() > 1u) {
-    return promise.set_error(Status::Error(500, "Receive invalid blocks"));
+    return promise.set_error(500, "Receive invalid blocks");
   }
   real_input_group_call_ids_[input_group_call] = InputGroupCallId(update->call_);
 
   auto r_private_key_id = tde2e_api::key_generate_temporary_private_key();
   if (r_private_key_id.is_error()) {
-    return promise.set_error(Status::Error(400, "Failed to generate encryption key"));
+    return promise.set_error(400, "Failed to generate encryption key");
   }
   auto private_key_id = tde2e_move_as_ok(r_private_key_id);
 
@@ -3330,7 +3330,7 @@ void GroupCallManager::do_join_group_call(InputGroupCall &&input_group_call, Gro
     if (r_block.is_error()) {
       tde2e_api::key_destroy(private_key_id);
       tde2e_api::key_destroy(public_key_id);
-      return promise.set_error(Status::Error(500, "Receive invalid previous block"));
+      return promise.set_error(500, "Receive invalid previous block");
     }
     block = tde2e_move_as_ok(std::move(r_block));
   }
@@ -3421,10 +3421,10 @@ void GroupCallManager::join_video_chat(GroupCallId group_call_id, DialogId as_di
   auto *group_call = get_group_call(input_group_call_id);
   CHECK(group_call != nullptr);
   if (group_call->is_inited && !group_call->is_active) {
-    return promise.set_error(Status::Error(400, "Video chat is finished"));
+    return promise.set_error(400, "Video chat is finished");
   }
   if (group_call->is_inited && group_call->is_conference) {
-    return promise.set_error(Status::Error(400, "The group call must be joined using joinGroupCall"));
+    return promise.set_error(400, "The group call must be joined using joinGroupCall");
   }
   bool need_update = false;
   bool old_is_joined = get_group_call_is_joined(group_call);
@@ -3445,18 +3445,18 @@ void GroupCallManager::join_video_chat(GroupCallId group_call_id, DialogId as_di
     auto dialog_type = as_dialog_id.get_type();
     if (dialog_type == DialogType::User) {
       if (as_dialog_id != my_dialog_id) {
-        return promise.set_error(Status::Error(400, "Can't join video chat as another user"));
+        return promise.set_error(400, "Can't join video chat as another user");
       }
       if (!td_->user_manager_->have_user_force(as_dialog_id.get_user_id(), "join_video_chat 1")) {
         have_as_dialog_id = false;
       }
     } else {
       if (!td_->dialog_manager_->have_dialog_force(as_dialog_id, "join_video_chat 2")) {
-        return promise.set_error(Status::Error(400, "Join as chat not found"));
+        return promise.set_error(400, "Join as chat not found");
       }
     }
     if (!td_->dialog_manager_->have_input_peer(as_dialog_id, false, AccessRights::Read)) {
-      return promise.set_error(Status::Error(400, "Can't access the join as participant"));
+      return promise.set_error(400, "Can't access the join as participant");
     }
   }
 
@@ -3541,10 +3541,10 @@ void GroupCallManager::encrypt_group_call_data(GroupCallId group_call_id,
   auto *group_call = get_group_call(input_group_call_id);
   CHECK(group_call != nullptr);
   if (!group_call->is_inited || !group_call->is_active) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_conference || group_call->call_id == tde2e_api::CallId()) {
-    return promise.set_error(Status::Error(400, "Group call doesn't support encryption"));
+    return promise.set_error(400, "Group call doesn't support encryption");
   }
   if (!group_call->is_joined || group_call->is_being_left) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -3552,7 +3552,7 @@ void GroupCallManager::encrypt_group_call_data(GroupCallId group_call_id,
           [actor_id = actor_id(this), group_call_id, data_channel = std::move(data_channel), data = std::move(data),
            unencrypted_prefix_size, promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::encrypt_group_call_data, group_call_id, std::move(data_channel),
                            std::move(data), unencrypted_prefix_size, std::move(promise));
@@ -3560,7 +3560,7 @@ void GroupCallManager::encrypt_group_call_data(GroupCallId group_call_id,
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   tde2e_api::CallChannelId channel_id{};
@@ -3569,7 +3569,7 @@ void GroupCallManager::encrypt_group_call_data(GroupCallId group_call_id,
   }
   auto r_data = tde2e_api::call_encrypt(group_call->call_id, channel_id, data, unencrypted_prefix_size);
   if (r_data.is_error()) {
-    return promise.set_error(Status::Error(400, r_data.error().message));
+    return promise.set_error(400, r_data.error().message);
   }
   promise.set_value(std::move(r_data.value()));
 }
@@ -3583,10 +3583,10 @@ void GroupCallManager::decrypt_group_call_data(GroupCallId group_call_id, Dialog
   auto *group_call = get_group_call(input_group_call_id);
   CHECK(group_call != nullptr);
   if (!group_call->is_inited || !group_call->is_active) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_conference || group_call->call_id == tde2e_api::CallId()) {
-    return promise.set_error(Status::Error(400, "Group call doesn't support decryption"));
+    return promise.set_error(400, "Group call doesn't support decryption");
   }
   if (!group_call->is_joined || group_call->is_being_left) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -3594,7 +3594,7 @@ void GroupCallManager::decrypt_group_call_data(GroupCallId group_call_id, Dialog
           [actor_id = actor_id(this), group_call_id, participant_dialog_id, data_channel = std::move(data_channel),
            data = std::move(data), promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::decrypt_group_call_data, group_call_id, participant_dialog_id,
                            std::move(data_channel), std::move(data), std::move(promise));
@@ -3602,7 +3602,7 @@ void GroupCallManager::decrypt_group_call_data(GroupCallId group_call_id, Dialog
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   tde2e_api::CallChannelId channel_id{};
@@ -3611,7 +3611,7 @@ void GroupCallManager::decrypt_group_call_data(GroupCallId group_call_id, Dialog
   }
   auto r_data = tde2e_api::call_decrypt(group_call->call_id, participant_dialog_id.get(), channel_id, data);
   if (r_data.is_error()) {
-    return promise.set_error(Status::Error(400, r_data.error().message));
+    return promise.set_error(400, r_data.error().message);
   }
   promise.set_value(std::move(r_data.value()));
 }
@@ -3624,7 +3624,7 @@ void GroupCallManager::start_group_call_screen_sharing(GroupCallId group_call_id
   auto *group_call = get_group_call(input_group_call_id);
   CHECK(group_call != nullptr);
   if (!group_call->is_inited || !group_call->is_active) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined || group_call->is_being_left) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -3632,7 +3632,7 @@ void GroupCallManager::start_group_call_screen_sharing(GroupCallId group_call_id
           PromiseCreator::lambda([actor_id = actor_id(this), group_call_id, audio_source, payload = std::move(payload),
                                   promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::start_group_call_screen_sharing, group_call_id, audio_source,
                            std::move(payload), std::move(promise));
@@ -3640,7 +3640,7 @@ void GroupCallManager::start_group_call_screen_sharing(GroupCallId group_call_id
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   cancel_join_group_call_presentation_request(input_group_call_id);
@@ -3668,14 +3668,14 @@ void GroupCallManager::end_group_call_screen_sharing(GroupCallId group_call_id,
   auto *group_call = get_group_call(input_group_call_id);
   CHECK(group_call != nullptr);
   if (!group_call->is_inited || !group_call->is_active) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined || group_call->is_being_left) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
       group_call->after_join.push_back(PromiseCreator::lambda(
           [actor_id = actor_id(this), group_call_id, promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::end_group_call_screen_sharing, group_call_id,
                            std::move(promise));
@@ -3683,7 +3683,7 @@ void GroupCallManager::end_group_call_screen_sharing(GroupCallId group_call_id,
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   cancel_join_group_call_presentation_request(input_group_call_id);
@@ -3766,7 +3766,7 @@ void GroupCallManager::process_join_video_chat_response(InputGroupCallId input_g
 
   td_->updates_manager_->on_get_updates(std::move(updates),
                                         PromiseCreator::lambda([promise = std::move(promise)](Unit) mutable {
-                                          promise.set_error(Status::Error(500, "Wrong join response received"));
+                                          promise.set_error(500, "Wrong join response received");
                                         }));
 }
 
@@ -3790,8 +3790,7 @@ void GroupCallManager::process_join_group_call_presentation_response(InputGroupC
 
   string params = UpdatesManager::extract_join_group_call_presentation_params(updates.get());
   if (params.empty()) {
-    return promise.set_error(
-        Status::Error(500, "Wrong start group call screen sharing response received: parameters are missing"));
+    return promise.set_error(500, "Wrong start group call screen sharing response received: parameters are missing");
   }
   td_->updates_manager_->on_get_updates(
       std::move(updates), PromiseCreator::lambda([params = std::move(params), promise = std::move(promise)](
@@ -3954,7 +3953,7 @@ void GroupCallManager::set_group_call_title(GroupCallId group_call_id, string ti
     return;
   }
   if (group_call->is_conference || !group_call->is_active || !group_call->can_be_managed) {
-    return promise.set_error(Status::Error(400, "Can't change group call title"));
+    return promise.set_error(400, "Can't change group call title");
   }
 
   title = clean_name(title, MAX_TITLE_LENGTH);
@@ -4014,7 +4013,7 @@ void GroupCallManager::toggle_group_call_is_my_video_paused(GroupCallId group_ca
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call)) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -4022,7 +4021,7 @@ void GroupCallManager::toggle_group_call_is_my_video_paused(GroupCallId group_ca
           PromiseCreator::lambda([actor_id = actor_id(this), group_call_id, is_my_video_paused,
                                   promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::toggle_group_call_is_my_video_paused, group_call_id,
                            is_my_video_paused, std::move(promise));
@@ -4030,7 +4029,7 @@ void GroupCallManager::toggle_group_call_is_my_video_paused(GroupCallId group_ca
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   if (is_my_video_paused == get_group_call_is_my_video_paused(group_call)) {
@@ -4098,7 +4097,7 @@ void GroupCallManager::toggle_group_call_is_my_video_enabled(GroupCallId group_c
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call)) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -4106,7 +4105,7 @@ void GroupCallManager::toggle_group_call_is_my_video_enabled(GroupCallId group_c
           PromiseCreator::lambda([actor_id = actor_id(this), group_call_id, is_my_video_enabled,
                                   promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::toggle_group_call_is_my_video_enabled, group_call_id,
                            is_my_video_enabled, std::move(promise));
@@ -4114,7 +4113,7 @@ void GroupCallManager::toggle_group_call_is_my_video_enabled(GroupCallId group_c
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   if (is_my_video_enabled == get_group_call_is_my_video_enabled(group_call)) {
@@ -4185,7 +4184,7 @@ void GroupCallManager::toggle_group_call_is_my_presentation_paused(GroupCallId g
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call)) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -4193,7 +4192,7 @@ void GroupCallManager::toggle_group_call_is_my_presentation_paused(GroupCallId g
           PromiseCreator::lambda([actor_id = actor_id(this), group_call_id, is_my_presentation_paused,
                                   promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::toggle_group_call_is_my_presentation_paused, group_call_id,
                            is_my_presentation_paused, std::move(promise));
@@ -4201,7 +4200,7 @@ void GroupCallManager::toggle_group_call_is_my_presentation_paused(GroupCallId g
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   if (is_my_presentation_paused == get_group_call_is_my_presentation_paused(group_call)) {
@@ -4286,7 +4285,7 @@ void GroupCallManager::toggle_group_call_start_subscribed(GroupCallId group_call
     return;
   }
   if (group_call->is_conference || !group_call->is_active || group_call->scheduled_start_date <= 0) {
-    return promise.set_error(Status::Error(400, "The group call isn't scheduled"));
+    return promise.set_error(400, "The group call isn't scheduled");
   }
 
   if (start_subscribed == get_group_call_start_subscribed(group_call)) {
@@ -4370,7 +4369,7 @@ void GroupCallManager::toggle_group_call_mute_new_participants(GroupCallId group
   }
   if (group_call->is_conference || !group_call->is_active || !group_call->can_be_managed ||
       !group_call->allowed_toggle_mute_new_participants) {
-    return promise.set_error(Status::Error(400, "Can't change mute_new_participants setting"));
+    return promise.set_error(400, "Can't change mute_new_participants setting");
   }
 
   if (mute_new_participants == get_group_call_mute_new_participants(group_call)) {
@@ -4454,7 +4453,7 @@ void GroupCallManager::revoke_group_call_invite_link(GroupCallId group_call_id,
     return;
   }
   if (!group_call->is_active || !(group_call->is_conference ? group_call->is_creator : group_call->can_be_managed)) {
-    return promise.set_error(Status::Error(400, "Can't revoke invite link in the group call"));
+    return promise.set_error(400, "Can't revoke invite link in the group call");
   }
 
   td_->create_handler<ToggleGroupCallSettingsQuery>(std::move(promise))->send(input_group_call_id, true, false, false);
@@ -4470,10 +4469,10 @@ void GroupCallManager::invite_group_call_participant(
   auto *group_call = get_group_call(input_group_call_id);
   CHECK(group_call != nullptr);
   if (!group_call->is_conference) {
-    return promise.set_error(Status::Error(400, "Use inviteVideoChatParticipants for video chats"));
+    return promise.set_error(400, "Use inviteVideoChatParticipants for video chats");
   }
   if (!is_group_call_active(group_call) || group_call->is_being_left) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -4481,7 +4480,7 @@ void GroupCallManager::invite_group_call_participant(
           PromiseCreator::lambda([actor_id = actor_id(this), group_call_id, user_id, is_video,
                                   promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::invite_group_call_participant, group_call_id, user_id, is_video,
                            std::move(promise));
@@ -4489,7 +4488,7 @@ void GroupCallManager::invite_group_call_participant(
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   td_->create_handler<InviteConferenceCallParticipantQuery>(std::move(promise))
@@ -4509,7 +4508,7 @@ void GroupCallManager::delete_group_call_participants(GroupCallId group_call_id,
   auto my_user_id = td_->user_manager_->get_my_id();
   for (auto &user_id : user_ids) {
     if (user_id == my_user_id.get()) {
-      return promise.set_error(Status::Error(400, "Use leaveGroupCall to leave the group call"));
+      return promise.set_error(400, "Use leaveGroupCall to leave the group call");
     }
   }
 
@@ -4521,11 +4520,11 @@ void GroupCallManager::do_delete_group_call_participants(InputGroupCallId input_
   TRY_STATUS_PROMISE(promise, G()->close_status());
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call) || group_call->is_being_left) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_conference) {
     return promise.set_error(
-        Status::Error(400, "Use setChatMemberStatus to ban participants from video chats and the corresponding chats"));
+        400, "Use setChatMemberStatus to ban participants from video chats and the corresponding chats");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -4541,7 +4540,7 @@ void GroupCallManager::do_delete_group_call_participants(InputGroupCallId input_
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   auto state = tde2e_move_as_ok(tde2e_api::call_get_state(group_call->call_id));
   if (!td::remove_if(state.participants,
@@ -4561,10 +4560,10 @@ void GroupCallManager::invite_group_call_participants(GroupCallId group_call_id,
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call)) {
-    return promise.set_error(Status::Error(400, "Group call is not active"));
+    return promise.set_error(400, "Group call is not active");
   }
   if (group_call->is_conference) {
-    return promise.set_error(Status::Error(400, "The call is not a video chat"));
+    return promise.set_error(400, "The call is not a video chat");
   }
 
   vector<telegram_api::object_ptr<telegram_api::InputUser>> input_users;
@@ -4607,11 +4606,11 @@ void GroupCallManager::get_group_call_invite_link(GroupCallId group_call_id, boo
     return;
   }
   if (group_call->is_conference || !group_call->is_active) {
-    return promise.set_error(Status::Error(400, "Can't get group call invite link"));
+    return promise.set_error(400, "Can't get group call invite link");
   }
 
   if (can_self_unmute && !group_call->can_be_managed) {
-    return promise.set_error(Status::Error(400, "Not enough rights in the group call"));
+    return promise.set_error(400, "Not enough rights in the group call");
   }
 
   td_->create_handler<ExportGroupCallInviteQuery>(std::move(promise))->send(input_group_call_id, can_self_unmute);
@@ -4640,7 +4639,7 @@ void GroupCallManager::toggle_group_call_recording(GroupCallId group_call_id, bo
     return;
   }
   if (group_call->is_conference || !group_call->is_active || !group_call->can_be_managed) {
-    return promise.set_error(Status::Error(400, "Can't manage group call recording"));
+    return promise.set_error(400, "Can't manage group call recording");
   }
 
   title = clean_name(title, MAX_TITLE_LENGTH);
@@ -4716,7 +4715,7 @@ void GroupCallManager::set_group_call_participant_is_speaking(
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call)) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -4732,12 +4731,12 @@ void GroupCallManager::set_group_call_participant_is_speaking(
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (audio_source == 0) {
     audio_source = group_call->audio_source;
     if (audio_source == 0) {
-      return promise.set_error(Status::Error(400, "Can't speak without joining the group call"));
+      return promise.set_error(400, "Can't speak without joining the group call");
     }
   }
 
@@ -4795,7 +4794,7 @@ void GroupCallManager::toggle_group_call_participant_is_muted(GroupCallId group_
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call) || group_call->is_being_left) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -4803,7 +4802,7 @@ void GroupCallManager::toggle_group_call_participant_is_muted(GroupCallId group_
           PromiseCreator::lambda([actor_id = actor_id(this), group_call_id, dialog_id, is_muted,
                                   promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::toggle_group_call_participant_is_muted, group_call_id,
                            dialog_id, is_muted, std::move(promise));
@@ -4811,13 +4810,13 @@ void GroupCallManager::toggle_group_call_participant_is_muted(GroupCallId group_
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   auto participants = add_group_call_participants(input_group_call_id, "toggle_group_call_participant_is_muted");
   auto participant = get_group_call_participant(participants, dialog_id);
   if (participant == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't find group call participant"));
+    return promise.set_error(400, "Can't find group call participant");
   }
   dialog_id = participant->dialog_id;
 
@@ -4827,7 +4826,7 @@ void GroupCallManager::toggle_group_call_participant_is_muted(GroupCallId group_
 
   auto participant_copy = *participant;
   if (!participant_copy.set_pending_is_muted(is_muted, can_manage, is_admin)) {
-    return promise.set_error(Status::Error(400, PSLICE() << "Can't " << (is_muted ? "" : "un") << "mute user"));
+    return promise.set_error(400, PSLICE() << "Can't " << (is_muted ? "" : "un") << "mute user");
   }
   if (participant_copy == *participant) {
     return promise.set_value(Unit());
@@ -4897,12 +4896,12 @@ void GroupCallManager::set_group_call_participant_volume_level(GroupCallId group
   TRY_STATUS_PROMISE(promise, G()->close_status());
   TRY_RESULT_PROMISE(promise, input_group_call_id, get_input_group_call_id(group_call_id));
   if (volume_level < GroupCallParticipant::MIN_VOLUME_LEVEL || volume_level > GroupCallParticipant::MAX_VOLUME_LEVEL) {
-    return promise.set_error(Status::Error(400, "Wrong volume level specified"));
+    return promise.set_error(400, "Wrong volume level specified");
   }
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call) || group_call->is_being_left) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -4910,7 +4909,7 @@ void GroupCallManager::set_group_call_participant_volume_level(GroupCallId group
           PromiseCreator::lambda([actor_id = actor_id(this), group_call_id, dialog_id, volume_level,
                                   promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::set_group_call_participant_volume_level, group_call_id,
                            dialog_id, volume_level, std::move(promise));
@@ -4918,18 +4917,18 @@ void GroupCallManager::set_group_call_participant_volume_level(GroupCallId group
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
 
   auto participant =
       get_group_call_participant(input_group_call_id, dialog_id, "set_group_call_participant_volume_level");
   if (participant == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't find group call participant"));
+    return promise.set_error(400, "Can't find group call participant");
   }
   dialog_id = participant->dialog_id;
 
   if (participant->is_self) {
-    return promise.set_error(Status::Error(400, "Can't change self volume level"));
+    return promise.set_error(400, "Can't change self volume level");
   }
 
   if (participant->get_volume_level() == volume_level) {
@@ -4996,7 +4995,7 @@ void GroupCallManager::toggle_group_call_participant_is_hand_raised(GroupCallId
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!is_group_call_active(group_call) || group_call->is_being_left) {
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (!group_call->is_joined) {
     if (group_call->is_being_joined || group_call->need_rejoin) {
@@ -5004,7 +5003,7 @@ void GroupCallManager::toggle_group_call_participant_is_hand_raised(GroupCallId
           PromiseCreator::lambda([actor_id = actor_id(this), group_call_id, dialog_id, is_hand_raised,
                                   promise = std::move(promise)](Result<Unit> &&result) mutable {
             if (result.is_error()) {
-              promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+              promise.set_error(400, "GROUPCALL_JOIN_MISSING");
             } else {
               send_closure(actor_id, &GroupCallManager::toggle_group_call_participant_is_hand_raised, group_call_id,
                            dialog_id, is_hand_raised, std::move(promise));
@@ -5012,16 +5011,16 @@ void GroupCallManager::toggle_group_call_participant_is_hand_raised(GroupCallId
           }));
       return;
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   if (group_call->is_conference) {
-    return promise.set_error(Status::Error(400, "The method can be used only in video chats"));
+    return promise.set_error(400, "The method can be used only in video chats");
   }
 
   auto participants = add_group_call_participants(input_group_call_id, "toggle_group_call_participant_is_hand_raised");
   auto participant = get_group_call_participant(participants, dialog_id);
   if (participant == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't find group call participant"));
+    return promise.set_error(400, "Can't find group call participant");
   }
   dialog_id = participant->dialog_id;
 
@@ -5031,10 +5030,10 @@ void GroupCallManager::toggle_group_call_participant_is_hand_raised(GroupCallId
 
   if (!participant->is_self) {
     if (is_hand_raised) {
-      return promise.set_error(Status::Error(400, "Can't raise others hand"));
+      return promise.set_error(400, "Can't raise others hand");
     } else {
       if (!can_manage_group_call(group_call, false)) {
-        return promise.set_error(Status::Error(400, "Have not enough rights in the group call"));
+        return promise.set_error(400, "Have not enough rights in the group call");
       }
     }
   }
@@ -5097,21 +5096,21 @@ void GroupCallManager::get_group_call_participants(
     Promise<td_api::object_ptr<td_api::groupCallParticipants>> &&promise) {
   TRY_RESULT_PROMISE(promise, group_call, InputGroupCall::get_input_group_call(td_, std::move(input_group_call)));
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   td_->create_handler<GetInputGroupCallParticipantsQuery>(std::move(promise))->send(group_call, limit);
 }
 
 void GroupCallManager::load_group_call_participants(GroupCallId group_call_id, int32 limit, Promise<Unit> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
 
   TRY_RESULT_PROMISE(promise, input_group_call_id, get_input_group_call_id(group_call_id));
 
   auto *group_call = get_group_call(input_group_call_id);
   if (!need_group_call_participants(input_group_call_id, group_call)) {
-    return promise.set_error(Status::Error(400, "Can't load group call participants"));
+    return promise.set_error(400, "Can't load group call participants");
   }
   CHECK(group_call != nullptr && group_call->is_inited);
   if (group_call->loaded_all_participants) {
@@ -5158,7 +5157,7 @@ void GroupCallManager::leave_group_call(GroupCallId group_call_id, Promise<Unit>
       process_group_call_after_join_requests(input_group_call_id, "leave_group_call 2");
       return promise.set_value(Unit());
     }
-    return promise.set_error(Status::Error(400, "GROUPCALL_JOIN_MISSING"));
+    return promise.set_error(400, "GROUPCALL_JOIN_MISSING");
   }
   auto audio_source = cancel_join_group_call_request(input_group_call_id, group_call);
   if (audio_source == 0) {
diff --git a/td/telegram/InlineMessageManager.cpp b/td/telegram/InlineMessageManager.cpp
index d932ef47c..918ee1874 100644
--- a/td/telegram/InlineMessageManager.cpp
+++ b/td/telegram/InlineMessageManager.cpp
@@ -215,11 +215,11 @@ void InlineMessageManager::edit_inline_message_text(
   CHECK(td_->auth_manager_->is_bot());
 
   if (input_message_content == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't edit message without new content"));
+    return promise.set_error(400, "Can't edit message without new content");
   }
   int32 new_message_content_type = input_message_content->get_id();
   if (new_message_content_type != td_api::inputMessageText::ID) {
-    return promise.set_error(Status::Error(400, "Input message content type must be InputMessageText"));
+    return promise.set_error(400, "Input message content type must be InputMessageText");
   }
 
   TRY_RESULT_PROMISE(
@@ -250,7 +250,7 @@ void InlineMessageManager::edit_inline_message_live_location(const string &inlin
 
   Location location(input_location);
   if (location.empty() && input_location != nullptr) {
-    return promise.set_error(Status::Error(400, "Invalid location specified"));
+    return promise.set_error(400, "Invalid location specified");
   }
 
   int32 flags = 0;
@@ -275,7 +275,7 @@ void InlineMessageManager::edit_inline_message_media(
   CHECK(td_->auth_manager_->is_bot());
 
   if (input_message_content == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't edit message without new content"));
+    return promise.set_error(400, "Can't edit message without new content");
   }
   int32 new_message_content_type = input_message_content->get_id();
   if (new_message_content_type != td_api::inputMessageAnimation::ID &&
@@ -283,14 +283,14 @@ void InlineMessageManager::edit_inline_message_media(
       new_message_content_type != td_api::inputMessageDocument::ID &&
       new_message_content_type != td_api::inputMessagePhoto::ID &&
       new_message_content_type != td_api::inputMessageVideo::ID) {
-    return promise.set_error(Status::Error(400, "Unsupported input message content type"));
+    return promise.set_error(400, "Unsupported input message content type");
   }
 
   bool is_premium = td_->option_manager_->get_option_boolean("is_premium");
   TRY_RESULT_PROMISE(promise, content,
                      get_input_message_content(DialogId(), std::move(input_message_content), td_, is_premium));
   if (!content.ttl.is_empty()) {
-    return promise.set_error(Status::Error(400, "Can't enable self-destruction for media"));
+    return promise.set_error(400, "Can't enable self-destruction for media");
   }
 
   TRY_RESULT_PROMISE(promise, new_reply_markup,
@@ -300,7 +300,7 @@ void InlineMessageManager::edit_inline_message_media(
   auto input_media =
       get_message_content_input_media(content.content.get(), td_, MessageSelfDestructType(), string(), true);
   if (input_media == nullptr) {
-    return promise.set_error(Status::Error(400, "Invalid message content specified"));
+    return promise.set_error(400, "Invalid message content specified");
   }
 
   const FormattedText *caption = get_message_content_caption(content.content.get());
diff --git a/td/telegram/InlineQueriesManager.cpp b/td/telegram/InlineQueriesManager.cpp
index 54fb31172..49929b477 100644
--- a/td/telegram/InlineQueriesManager.cpp
+++ b/td/telegram/InlineQueriesManager.cpp
@@ -580,22 +580,22 @@ void InlineQueriesManager::answer_inline_query(
   telegram_api::object_ptr<telegram_api::inlineBotWebView> web_view;
   if (button != nullptr) {
     if (!clean_input_string(button->text_)) {
-      return promise.set_error(Status::Error(400, "Strings must be encoded in UTF-8"));
+      return promise.set_error(400, "Strings must be encoded in UTF-8");
     }
     if (button->type_ == nullptr) {
-      return promise.set_error(Status::Error(400, "Button type must be non-empty"));
+      return promise.set_error(400, "Button type must be non-empty");
     }
     switch (button->type_->get_id()) {
       case td_api::inlineQueryResultsButtonTypeStartBot::ID: {
         auto type = td_api::move_object_as<td_api::inlineQueryResultsButtonTypeStartBot>(button->type_);
         if (type->parameter_.empty()) {
-          return promise.set_error(Status::Error(400, "Can't use empty start_parameter"));
+          return promise.set_error(400, "Can't use empty start_parameter");
         }
         if (type->parameter_.size() > 64) {
-          return promise.set_error(Status::Error(400, "Too long start_parameter specified"));
+          return promise.set_error(400, "Too long start_parameter specified");
         }
         if (!is_base64url_characters(type->parameter_)) {
-          return promise.set_error(Status::Error(400, "Unallowed characters in start_parameter are used"));
+          return promise.set_error(400, "Unallowed characters in start_parameter are used");
         }
         switch_pm = telegram_api::make_object<telegram_api::inlineBotSwitchPM>(button->text_, type->parameter_);
         break;
@@ -604,12 +604,11 @@ void InlineQueriesManager::answer_inline_query(
         auto type = td_api::move_object_as<td_api::inlineQueryResultsButtonTypeWebApp>(button->type_);
         auto user_id = LinkManager::get_link_user_id(type->url_);
         if (user_id.is_valid()) {
-          return promise.set_error(Status::Error(400, "Link to a user can't be used in the Web App button"));
+          return promise.set_error(400, "Link to a user can't be used in the Web App button");
         }
         auto r_url = LinkManager::check_link(type->url_, true, !G()->is_test_dc());
         if (r_url.is_error()) {
-          return promise.set_error(
-              Status::Error(400, PSLICE() << "Inline query button Web App " << r_url.error().message()));
+          return promise.set_error(400, PSLICE() << "Inline query button Web App " << r_url.error().message());
         }
         web_view = telegram_api::make_object<telegram_api::inlineBotWebView>(button->text_, type->url_);
         break;
@@ -660,7 +659,7 @@ void InlineQueriesManager::get_prepared_inline_message(
   auto it = inline_query_results_.find(query_hash);
   if (it != inline_query_results_.end()) {
     if (it->second.is_inline_query) {
-      return promise.set_error(Status::Error(500, "Request hash collision"));
+      return promise.set_error(500, "Request hash collision");
     }
     it->second.pending_request_count++;
     if (Time::now() < it->second.cache_expire_time) {
@@ -1111,12 +1110,12 @@ Result<tl_object_ptr<telegram_api::InputBotInlineResult>> InlineQueriesManager::
 void InlineQueriesManager::get_weather(Location location,
                                        Promise<td_api::object_ptr<td_api::currentWeather>> &&promise) {
   if (location.empty()) {
-    return promise.set_error(Status::Error(400, "Location must be non-empty"));
+    return promise.set_error(400, "Location must be non-empty");
   }
   auto bot_username = td_->option_manager_->get_option_string("weather_bot_username");
   if (bot_username.empty()) {
     LOG(ERROR) << "Have no weather bot";
-    return promise.set_error(Status::Error(500, "Not supported"));
+    return promise.set_error(500, "Not supported");
   }
   td_->dialog_manager_->resolve_dialog(
       bot_username, ChannelId(),
@@ -1135,14 +1134,14 @@ void InlineQueriesManager::do_get_weather(DialogId dialog_id, Location location,
   TRY_STATUS_PROMISE(promise, G()->close_status());
   if (dialog_id.get_type() != DialogType::User) {
     LOG(ERROR) << "Weather bot isn't a user";
-    return promise.set_error(Status::Error(500, "Not supported"));
+    return promise.set_error(500, "Not supported");
   }
   send_inline_query(
       dialog_id.get_user_id(), DialogId(), std::move(location), string(), string(),
       PromiseCreator::lambda([actor_id = actor_id(this), promise = std::move(promise)](
                                  Result<td_api::object_ptr<td_api::inlineQueryResults>> r_results) mutable {
         if (r_results.is_error()) {
-          return promise.set_error(Status::Error(500, "Not supported"));
+          return promise.set_error(500, "Not supported");
         }
         send_closure(actor_id, &InlineQueriesManager::on_get_weather, r_results.move_as_ok(), std::move(promise));
       }));
@@ -1153,12 +1152,12 @@ void InlineQueriesManager::on_get_weather(td_api::object_ptr<td_api::inlineQuery
   TRY_STATUS_PROMISE(promise, G()->close_status());
   if (results->results_.size() != 1u || results->results_[0]->get_id() != td_api::inlineQueryResultArticle::ID) {
     LOG(ERROR) << "Receive " << to_string(results);
-    return promise.set_error(Status::Error(500, "Not supported"));
+    return promise.set_error(500, "Not supported");
   }
   auto result = td_api::move_object_as<td_api::inlineQueryResultArticle>(results->results_[0]);
   if (!is_emoji(result->title_)) {
     LOG(ERROR) << "Receive " << to_string(results);
-    return promise.set_error(Status::Error(500, "Not supported"));
+    return promise.set_error(500, "Not supported");
   }
   promise.set_value(td_api::make_object<td_api::currentWeather>(to_double(result->description_), result->title_));
 }
@@ -1170,7 +1169,7 @@ void InlineQueriesManager::send_inline_query(UserId bot_user_id, DialogId dialog
 
   TRY_RESULT_PROMISE(promise, bot_data, td_->user_manager_->get_bot_data(bot_user_id));
   if (!bot_data.is_inline) {
-    return promise.set_error(Status::Error(400, "Bot doesn't support inline queries"));
+    return promise.set_error(400, "Bot doesn't support inline queries");
   }
 
   auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
@@ -1214,7 +1213,7 @@ void InlineQueriesManager::send_inline_query(UserId bot_user_id, DialogId dialog
   auto it = inline_query_results_.find(query_hash);
   if (it != inline_query_results_.end()) {
     if (!it->second.is_inline_query) {
-      return promise.set_error(Status::Error(500, "Request hash collision"));
+      return promise.set_error(500, "Request hash collision");
     }
     it->second.pending_request_count++;
     if (Time::now() < it->second.cache_expire_time) {
@@ -1228,7 +1227,7 @@ void InlineQueriesManager::send_inline_query(UserId bot_user_id, DialogId dialog
     LOG(INFO) << "Drop inline query " << pending_inline_query_->query_hash;
     on_get_inline_query_results(pending_inline_query_->dialog_id, pending_inline_query_->bot_user_id,
                                 pending_inline_query_->query_hash, nullptr, Auto());
-    pending_inline_query_->promise.set_error(Status::Error(406, "Request canceled"));
+    pending_inline_query_->promise.set_error(406, "Request canceled");
   }
 
   pending_inline_query_ = make_unique<PendingInlineQuery>(PendingInlineQuery{
@@ -2115,7 +2114,7 @@ void InlineQueriesManager::on_get_inline_query_results(
   LOG(INFO) << "Receive results for inline query " << query_hash;
   if (results == nullptr || results->query_id_ == 0) {
     get_inline_query_results_object(query_hash);
-    return promise.set_error(Status::Error(500, "Receive no response"));
+    return promise.set_error(500, "Receive no response");
   }
   LOG(INFO) << to_string(results);
 
@@ -2158,7 +2157,7 @@ void InlineQueriesManager::on_get_prepared_inline_message(
     Promise<td_api::object_ptr<td_api::preparedInlineMessage>> promise) {
   if (prepared_message == nullptr || prepared_message->query_id_ == 0) {
     get_prepared_inline_message_object(query_hash);
-    return promise.set_error(Status::Error(500, "Receive no response"));
+    return promise.set_error(500, "Receive no response");
   }
 
   td_->user_manager_->on_get_users(std::move(prepared_message->users_), "on_get_prepared_inline_message");
@@ -2169,7 +2168,7 @@ void InlineQueriesManager::on_get_prepared_inline_message(
       get_inline_query_result_object(prepared_message->query_id_, DialogId(), std::move(prepared_message->result_));
   if (output_result == nullptr) {
     get_prepared_inline_message_object(query_hash);
-    return promise.set_error(Status::Error(500, "Receive invalid response"));
+    return promise.set_error(500, "Receive invalid response");
   }
 
   auto it = inline_query_results_.find(query_hash);
diff --git a/td/telegram/LanguagePackManager.cpp b/td/telegram/LanguagePackManager.cpp
index eb4eae7c3..987e41e34 100644
--- a/td/telegram/LanguagePackManager.cpp
+++ b/td/telegram/LanguagePackManager.cpp
@@ -860,7 +860,7 @@ td_api::object_ptr<td_api::languagePackStrings> LanguagePackManager::get_languag
 void LanguagePackManager::get_languages(bool only_local,
                                         Promise<td_api::object_ptr<td_api::localizationTargetInfo>> promise) {
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
 
   if (only_local) {
@@ -881,7 +881,7 @@ void LanguagePackManager::get_languages(bool only_local,
 void LanguagePackManager::search_language_info(string language_code,
                                                Promise<td_api::object_ptr<td_api::languagePackInfo>> promise) {
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
 
   auto request_promise =
@@ -1094,14 +1094,14 @@ void LanguagePackManager::on_get_language(tl_object_ptr<telegram_api::langPackLa
 void LanguagePackManager::get_language_pack_strings(string language_code, vector<string> keys,
                                                     Promise<td_api::object_ptr<td_api::languagePackStrings>> promise) {
   if (!check_language_code_name(language_code) || language_code.empty()) {
-    return promise.set_error(Status::Error(400, "Language pack ID is invalid"));
+    return promise.set_error(400, "Language pack ID is invalid");
   }
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
   for (auto &key : keys) {
     if (!is_valid_key(key)) {
-      return promise.set_error(Status::Error(400, "Invalid key name"));
+      return promise.set_error(400, "Invalid key name");
     }
   }
 
@@ -1114,7 +1114,7 @@ void LanguagePackManager::get_language_pack_strings(string language_code, vector
   }
 
   if (is_custom_language_code(language_code)) {
-    return promise.set_error(Status::Error(400, "Custom language pack not found"));
+    return promise.set_error(400, "Custom language pack not found");
   }
 
   if (keys.empty()) {
@@ -1171,10 +1171,10 @@ void LanguagePackManager::load_empty_language_pack(const string &language_code)
 
 void LanguagePackManager::synchronize_language_pack(string language_code, Promise<Unit> promise) {
   if (!check_language_code_name(language_code) || language_code.empty()) {
-    return promise.set_error(Status::Error(400, "Language pack ID is invalid"));
+    return promise.set_error(400, "Language pack ID is invalid");
   }
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
   if (is_custom_language_code(language_code)) {
     return promise.set_value(Unit());
@@ -1533,18 +1533,17 @@ void LanguagePackManager::on_failed_get_difference(string language_pack, string
 
 void LanguagePackManager::add_custom_server_language(string language_code, Promise<Unit> &&promise) {
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
   if (!check_language_code_name(language_code)) {
-    return promise.set_error(Status::Error(400, "Language pack ID must contain only letters, digits and hyphen"));
+    return promise.set_error(400, "Language pack ID must contain only letters, digits and hyphen");
   }
   if (is_custom_language_code(language_code)) {
-    return promise.set_error(
-        Status::Error(400, "Custom local language pack can't be added through addCustomServerLanguagePack"));
+    return promise.set_error(400, "Custom local language pack can't be added through addCustomServerLanguagePack");
   }
 
   if (get_language(database_, language_pack_, language_code) == nullptr) {
-    return promise.set_error(Status::Error(400, "Language pack not found"));
+    return promise.set_error(400, "Language pack not found");
   }
 
   std::lock_guard<std::mutex> packs_lock(database_->mutex_);
@@ -1554,7 +1553,7 @@ void LanguagePackManager::add_custom_server_language(string language_code, Promi
   std::lock_guard<std::mutex> pack_lock(pack->mutex_);
   auto it = pack->all_server_language_pack_infos_.find(language_code);
   if (it == pack->all_server_language_pack_infos_.end()) {
-    return promise.set_error(Status::Error(400, "Language pack info not found"));
+    return promise.set_error(400, "Language pack info not found");
   }
   auto &info = pack->custom_language_pack_infos_[language_code];
   info = *it->second;
@@ -1709,13 +1708,13 @@ void LanguagePackManager::set_custom_language(td_api::object_ptr<td_api::languag
                                               vector<tl_object_ptr<td_api::languagePackString>> strings,
                                               Promise<Unit> &&promise) {
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
 
   TRY_RESULT_PROMISE(promise, language_info, get_language_info(language_pack_info.get()));
   auto language_code = std::move(language_pack_info->id_);
   if (!is_custom_language_code(language_code)) {
-    return promise.set_error(Status::Error(400, "Custom language pack ID must begin with 'X'"));
+    return promise.set_error(400, "Custom language pack ID must begin with 'X'");
   }
 
   vector<tl_object_ptr<telegram_api::LangPackString>> server_strings;
@@ -1745,13 +1744,13 @@ void LanguagePackManager::set_custom_language(td_api::object_ptr<td_api::languag
 void LanguagePackManager::edit_custom_language_info(td_api::object_ptr<td_api::languagePackInfo> &&language_pack_info,
                                                     Promise<Unit> &&promise) {
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
 
   TRY_RESULT_PROMISE(promise, language_info, get_language_info(language_pack_info.get()));
   auto language_code = std::move(language_pack_info->id_);
   if (!is_custom_language_code(language_code)) {
-    return promise.set_error(Status::Error(400, "Custom language pack ID must begin with 'X'"));
+    return promise.set_error(400, "Custom language pack ID must begin with 'X'");
   }
 
   std::lock_guard<std::mutex> packs_lock(database_->mutex_);
@@ -1761,7 +1760,7 @@ void LanguagePackManager::edit_custom_language_info(td_api::object_ptr<td_api::l
   std::lock_guard<std::mutex> pack_lock(pack->mutex_);
   auto language_info_it = pack->custom_language_pack_infos_.find(language_code);
   if (language_info_it == pack->custom_language_pack_infos_.end()) {
-    return promise.set_error(Status::Error(400, "Custom language pack is not found"));
+    return promise.set_error(400, "Custom language pack is not found");
   }
   auto &info = language_info_it->second;
   info = std::move(language_info);
@@ -1776,20 +1775,20 @@ void LanguagePackManager::set_custom_language_string(string language_code,
                                                      tl_object_ptr<td_api::languagePackString> str,
                                                      Promise<Unit> &&promise) {
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
   if (!check_language_code_name(language_code)) {
-    return promise.set_error(Status::Error(400, "Language pack ID must contain only letters, digits and hyphen"));
+    return promise.set_error(400, "Language pack ID must contain only letters, digits and hyphen");
   }
   if (!is_custom_language_code(language_code)) {
-    return promise.set_error(Status::Error(400, "Custom language pack ID must begin with 'X'"));
+    return promise.set_error(400, "Custom language pack ID must begin with 'X'");
   }
 
   if (get_language(database_, language_pack_, language_code) == nullptr) {
-    return promise.set_error(Status::Error(400, "Custom language pack not found"));
+    return promise.set_error(400, "Custom language pack not found");
   }
   if (str == nullptr) {
-    return promise.set_error(Status::Error(400, "Language pack strings must not be null"));
+    return promise.set_error(400, "Language pack strings must not be null");
   }
 
   vector<string> keys{str->key_};
@@ -1806,16 +1805,16 @@ void LanguagePackManager::set_custom_language_string(string language_code,
 
 void LanguagePackManager::delete_language(string language_code, Promise<Unit> &&promise) {
   if (language_pack_.empty()) {
-    return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
+    return promise.set_error(400, "Option \"localization_target\" needs to be set first");
   }
   if (!check_language_code_name(language_code)) {
-    return promise.set_error(Status::Error(400, "Language pack ID is invalid"));
+    return promise.set_error(400, "Language pack ID is invalid");
   }
   if (language_code.empty()) {
-    return promise.set_error(Status::Error(400, "Language pack ID is empty"));
+    return promise.set_error(400, "Language pack ID is empty");
   }
   if (language_code_ == language_code || base_language_code_ == language_code) {
-    return promise.set_error(Status::Error(400, "Currently used language pack can't be deleted"));
+    return promise.set_error(400, "Currently used language pack can't be deleted");
   }
 
   auto status = do_delete_language(language_code);
diff --git a/td/telegram/MessageContent.cpp b/td/telegram/MessageContent.cpp
index eee8fdc96..1a7cc7225 100644
--- a/td/telegram/MessageContent.cpp
+++ b/td/telegram/MessageContent.cpp
@@ -9786,12 +9786,12 @@ void set_message_content_video_start_timestamp(MessageContent *content, int32 st
 void get_message_content_animated_emoji_click_sticker(const MessageContent *content, MessageFullId message_full_id,
                                                       Td *td, Promise<td_api::object_ptr<td_api::sticker>> &&promise) {
   if (content->get_type() != MessageContentType::Text) {
-    return promise.set_error(Status::Error(400, "Message is not an animated emoji message"));
+    return promise.set_error(400, "Message is not an animated emoji message");
   }
 
   const auto &text = static_cast<const MessageText *>(content)->text;
   if (!can_be_animated_emoji(text)) {
-    return promise.set_error(Status::Error(400, "Message is not an animated emoji message"));
+    return promise.set_error(400, "Message is not an animated emoji message");
   }
   td->stickers_manager_->get_animated_emoji_click_sticker(text.text, message_full_id, std::move(promise));
 }
diff --git a/td/telegram/MessageImportManager.cpp b/td/telegram/MessageImportManager.cpp
index 247472404..abfb7618d 100644
--- a/td/telegram/MessageImportManager.cpp
+++ b/td/telegram/MessageImportManager.cpp
@@ -378,10 +378,10 @@ void MessageImportManager::on_upload_imported_messages(FileUploadId file_upload_
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (input_file == nullptr && main_remote_location != nullptr) {
     if (main_remote_location->is_web()) {
-      return promise.set_error(Status::Error(400, "Can't use web file"));
+      return promise.set_error(400, "Can't use web file");
     }
     if (is_reupload) {
-      return promise.set_error(Status::Error(400, "Failed to reupload the file"));
+      return promise.set_error(400, "Failed to reupload the file");
     }
 
     CHECK(file_view.get_type() == FileType::Document);
@@ -481,10 +481,10 @@ void MessageImportManager::on_upload_imported_message_attachment(
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (input_file == nullptr && main_remote_location != nullptr) {
     if (main_remote_location->is_web()) {
-      return promise.set_error(Status::Error(400, "Can't use web file"));
+      return promise.set_error(400, "Can't use web file");
     }
     if (is_reupload) {
-      return promise.set_error(Status::Error(400, "Failed to reupload the file"));
+      return promise.set_error(400, "Failed to reupload the file");
     }
 
     // delete file reference and forcely reupload the file
diff --git a/td/telegram/MessageQueryManager.cpp b/td/telegram/MessageQueryManager.cpp
index 46d488d1a..01ca44b8a 100644
--- a/td/telegram/MessageQueryManager.cpp
+++ b/td/telegram/MessageQueryManager.cpp
@@ -209,7 +209,7 @@ class GetFactCheckQuery final : public Td::ResultHandler {
     dialog_id_ = dialog_id;
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Can't access the chat"));
+      return promise_.set_error(400, "Can't access the chat");
     }
     send_query(G()->net_query_creator().create(
         telegram_api::messages_getFactCheck(std::move(input_peer), MessageId::get_server_message_ids(message_ids))));
@@ -584,7 +584,7 @@ class GetMessagePositionQuery final : public Td::ResultHandler {
         auto messages = telegram_api::move_object_as<telegram_api::messages_messages>(messages_ptr);
         if (messages->messages_.size() != 1 ||
             MessageId::get_message_id(messages->messages_[0], false) != message_id_) {
-          return promise_.set_error(Status::Error(400, "Message not found by the filter"));
+          return promise_.set_error(400, "Message not found by the filter");
         }
         return promise_.set_value(narrow_cast<int32>(messages->messages_.size()));
       }
@@ -592,12 +592,12 @@ class GetMessagePositionQuery final : public Td::ResultHandler {
         auto messages = telegram_api::move_object_as<telegram_api::messages_messagesSlice>(messages_ptr);
         if (messages->messages_.size() != 1 ||
             MessageId::get_message_id(messages->messages_[0], false) != message_id_) {
-          return promise_.set_error(Status::Error(400, "Message not found by the filter"));
+          return promise_.set_error(400, "Message not found by the filter");
         }
         if (messages->offset_id_offset_ <= 0) {
           LOG(ERROR) << "Failed to receive position for " << message_id_ << " in " << message_topic_ << " in "
                      << dialog_id_ << " by " << filter_;
-          return promise_.set_error(Status::Error(400, "Message position is unknown"));
+          return promise_.set_error(400, "Message position is unknown");
         }
         return promise_.set_value(std::move(messages->offset_id_offset_));
       }
@@ -605,17 +605,17 @@ class GetMessagePositionQuery final : public Td::ResultHandler {
         auto messages = telegram_api::move_object_as<telegram_api::messages_channelMessages>(messages_ptr);
         if (messages->messages_.size() != 1 ||
             MessageId::get_message_id(messages->messages_[0], false) != message_id_) {
-          return promise_.set_error(Status::Error(400, "Message not found by the filter"));
+          return promise_.set_error(400, "Message not found by the filter");
         }
         if (messages->offset_id_offset_ <= 0) {
           LOG(ERROR) << "Failed to receive position for " << message_id_ << " in " << dialog_id_ << " by " << filter_;
-          return promise_.set_error(Status::Error(500, "Message position is unknown"));
+          return promise_.set_error(500, "Message position is unknown");
         }
         return promise_.set_value(std::move(messages->offset_id_offset_));
       }
       case telegram_api::messages_messagesNotModified::ID:
         LOG(ERROR) << "Server returned messagesNotModified in response to GetMessagePositionQuery";
-        return promise_.set_error(Status::Error(500, "Receive invalid response"));
+        return promise_.set_error(500, "Receive invalid response");
       default:
         UNREACHABLE();
         break;
@@ -921,11 +921,11 @@ class DeleteParticipantHistoryQuery final : public Td::ResultHandler {
 
     auto input_channel = td_->chat_manager_->get_input_channel(channel_id);
     if (input_channel == nullptr) {
-      return promise_.set_error(Status::Error(400, "Chat is not accessible"));
+      return promise_.set_error(400, "Chat is not accessible");
     }
     auto input_peer = td_->dialog_manager_->get_input_peer(sender_dialog_id, AccessRights::Know);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Message sender is not accessible"));
+      return promise_.set_error(400, "Message sender is not accessible");
     }
 
     send_query(G()->net_query_creator().create(
@@ -962,7 +962,7 @@ class DeleteHistoryQuery final : public Td::ResultHandler {
 
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Chat is not accessible"));
+      return promise_.set_error(400, "Chat is not accessible");
     }
 
     send_query(G()->net_query_creator().create(
@@ -1040,7 +1040,7 @@ class DeleteMessagesByDateQuery final : public Td::ResultHandler {
 
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Chat is not accessible"));
+      return promise_.set_error(400, "Chat is not accessible");
     }
 
     int32 flags =
@@ -1247,7 +1247,7 @@ class ReadMentionsQuery final : public Td::ResultHandler {
 
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Chat is not accessible"));
+      return promise_.set_error(400, "Chat is not accessible");
     }
 
     int32 flags = 0;
@@ -1289,7 +1289,7 @@ class ReadReactionsQuery final : public Td::ResultHandler {
 
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Chat is not accessible"));
+      return promise_.set_error(400, "Chat is not accessible");
     }
 
     int32 flags = 0;
@@ -1606,15 +1606,15 @@ void MessageQueryManager::complete_upload_message_cover(
   send_closure_later(G()->file_manager(), &FileManager::cancel_upload, file_upload_id);
 
   if (media_ptr->get_id() != telegram_api::messageMediaPhoto::ID) {
-    return promise.set_error(Status::Error(500, "Receive invalid response"));
+    return promise.set_error(500, "Receive invalid response");
   }
   auto media = telegram_api::move_object_as<telegram_api::messageMediaPhoto>(media_ptr);
   if (media->photo_ == nullptr || media->ttl_seconds_ != 0) {
-    return promise.set_error(Status::Error(500, "Receive invalid response without photo"));
+    return promise.set_error(500, "Receive invalid response without photo");
   }
   auto new_photo = get_photo(td_, std::move(media->photo_), dialog_id, FileType::Photo);
   if (new_photo.is_empty()) {
-    return promise.set_error(Status::Error(500, "Receive invalid photo in response"));
+    return promise.set_error(500, "Receive invalid photo in response");
   }
   bool is_content_changed = false;
   bool need_update = false;
@@ -1622,7 +1622,7 @@ void MessageQueryManager::complete_upload_message_cover(
 
   auto input_media = photo_get_cover_input_media(td_->file_manager_.get(), photo, true, true);
   if (input_media == nullptr) {
-    return promise.set_error(Status::Error(500, "Failed to upload file"));
+    return promise.set_error(500, "Failed to upload file");
   }
   promise.set_value(Unit());
 }
@@ -1704,10 +1704,10 @@ void MessageQueryManager::search_messages(DialogListId dialog_list_id, bool igno
                                           int32 min_date, int32 max_date,
                                           Promise<td_api::object_ptr<td_api::foundMessages>> &&promise) {
   if (!dialog_list_id.is_folder()) {
-    return promise.set_error(Status::Error(400, "Wrong chat list specified"));
+    return promise.set_error(400, "Wrong chat list specified");
   }
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_SEARCH_MESSAGES) {
     limit = MAX_SEARCH_MESSAGES;
@@ -1719,7 +1719,7 @@ void MessageQueryManager::search_messages(DialogListId dialog_list_id, bool igno
   if (filter == MessageSearchFilter::Mention || filter == MessageSearchFilter::UnreadMention ||
       filter == MessageSearchFilter::UnreadReaction || filter == MessageSearchFilter::FailedToSend ||
       filter == MessageSearchFilter::Pinned) {
-    return promise.set_error(Status::Error(400, "The filter is not supported"));
+    return promise.set_error(400, "The filter is not supported");
   }
 
   if (query.empty() && filter == MessageSearchFilter::Empty) {
@@ -1773,7 +1773,7 @@ void MessageQueryManager::on_get_messages_search_result(
 void MessageQueryManager::search_outgoing_document_messages(
     const string &query, int32 limit, Promise<td_api::object_ptr<td_api::foundMessages>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_SEARCH_MESSAGES) {
     limit = MAX_SEARCH_MESSAGES;
@@ -1806,7 +1806,7 @@ void MessageQueryManager::on_get_outgoing_document_messages(
 void MessageQueryManager::search_hashtag_posts(string hashtag, string offset_str, int32 limit,
                                                Promise<td_api::object_ptr<td_api::foundMessages>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_SEARCH_MESSAGES) {
     limit = MAX_SEARCH_MESSAGES;
@@ -1869,7 +1869,7 @@ void MessageQueryManager::search_dialog_recent_location_messages(
   LOG(INFO) << "Search recent location messages in " << dialog_id << " with limit " << limit;
 
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_SEARCH_MESSAGES) {
     limit = MAX_SEARCH_MESSAGES;
@@ -1888,7 +1888,7 @@ void MessageQueryManager::search_dialog_recent_location_messages(
                                                                            "search_dialog_recent_location_messages"));
     default:
       UNREACHABLE();
-      promise.set_error(Status::Error(500, "Message search is not supported"));
+      promise.set_error(500, "Message search is not supported");
   }
 }
 
@@ -1932,7 +1932,7 @@ void MessageQueryManager::get_dialog_message_position_from_server(DialogId dialo
                                                                   Promise<int32> &&promise) {
   if (filter == MessageSearchFilter::UnreadMention || filter == MessageSearchFilter::UnreadReaction ||
       filter == MessageSearchFilter::FailedToSend) {
-    return promise.set_error(Status::Error(400, "The filter is not supported"));
+    return promise.set_error(400, "The filter is not supported");
   }
 
   td_->create_handler<GetMessagePositionQuery>(std::move(promise))->send(dialog_id, message_id, filter, message_topic);
@@ -2842,7 +2842,7 @@ void MessageQueryManager::read_message_contents_on_server(DialogId dialog_id, ve
         send_closure(G()->secret_chats_manager(), &SecretChatsManager::send_open_message,
                      dialog_id.get_secret_chat_id(), random_id, std::move(promise));
       } else {
-        promise.set_error(Status::Error(400, "Message not found"));
+        promise.set_error(400, "Message not found");
       }
       break;
     }
diff --git a/td/telegram/MessageReaction.cpp b/td/telegram/MessageReaction.cpp
index 327fb6b7c..28eb6cb0d 100644
--- a/td/telegram/MessageReaction.cpp
+++ b/td/telegram/MessageReaction.cpp
@@ -318,7 +318,7 @@ class ReportReactionQuery final : public Td::ResultHandler {
 
     auto chooser_input_peer = td_->dialog_manager_->get_input_peer(chooser_dialog_id, AccessRights::Know);
     if (chooser_input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Reaction sender is not accessible"));
+      return promise_.set_error(400, "Reaction sender is not accessible");
     }
 
     send_query(G()->net_query_creator().create(telegram_api::messages_reportReaction(
@@ -1115,7 +1115,7 @@ bool MessageReactions::set_paid_message_reaction_type(Td *td, MessageFullId mess
     promise.set_value(Unit());
     return true;
   }
-  promise.set_error(Status::Error(400, "Message has no paid reaction"));
+  promise.set_error(400, "Message has no paid reaction");
   return false;
 }
 
@@ -1148,11 +1148,11 @@ void send_message_reaction(Td *td, MessageFullId message_full_id, vector<Reactio
 void set_message_reactions(Td *td, MessageFullId message_full_id, vector<ReactionType> reaction_types, bool is_big,
                            Promise<Unit> &&promise) {
   if (!td->messages_manager_->have_message_force(message_full_id, "set_message_reactions")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   for (const auto &reaction_type : reaction_types) {
     if (reaction_type.is_empty() || reaction_type.is_paid_reaction()) {
-      return promise.set_error(Status::Error(400, "Invalid reaction type specified"));
+      return promise.set_error(400, "Invalid reaction type specified");
     }
   }
   send_message_reaction(td, message_full_id, std::move(reaction_types), is_big, false, std::move(promise));
@@ -1165,10 +1165,10 @@ void reload_paid_reaction_privacy(Td *td) {
 void get_message_added_reactions(Td *td, MessageFullId message_full_id, ReactionType reaction_type, string offset,
                                  int32 limit, Promise<td_api::object_ptr<td_api::addedReactions>> &&promise) {
   if (!td->messages_manager_->have_message_force(message_full_id, "get_message_added_reactions")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (reaction_type.is_paid_reaction()) {
-    return promise.set_error(Status::Error(400, "Can't use the method for paid reaction"));
+    return promise.set_error(400, "Can't use the method for paid reaction");
   }
 
   auto message_id = message_full_id.get_message_id();
@@ -1178,7 +1178,7 @@ void get_message_added_reactions(Td *td, MessageFullId message_full_id, Reaction
   }
 
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   static constexpr int32 MAX_GET_ADDED_REACTIONS = 100;  // server-side limit
   if (limit > MAX_GET_ADDED_REACTIONS) {
@@ -1196,18 +1196,18 @@ void report_message_reactions(Td *td, MessageFullId message_full_id, DialogId ch
                                                                        "report_message_reactions"));
 
   if (!td->messages_manager_->have_message_force(message_full_id, "report_message_reactions")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   auto message_id = message_full_id.get_message_id();
   if (message_id.is_valid_scheduled()) {
-    return promise.set_error(Status::Error(400, "Can't report reactions on scheduled messages"));
+    return promise.set_error(400, "Can't report reactions on scheduled messages");
   }
   if (!message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Message reactions can't be reported"));
+    return promise.set_error(400, "Message reactions can't be reported");
   }
 
   if (!td->dialog_manager_->have_input_peer(chooser_dialog_id, false, AccessRights::Know)) {
-    return promise.set_error(Status::Error(400, "Reaction sender not found"));
+    return promise.set_error(400, "Reaction sender not found");
   }
 
   td->create_handler<ReportReactionQuery>(std::move(promise))->send(dialog_id, message_id, chooser_dialog_id);
diff --git a/td/telegram/MessagesManager.cpp b/td/telegram/MessagesManager.cpp
index 7833176a0..7b52c4624 100644
--- a/td/telegram/MessagesManager.cpp
+++ b/td/telegram/MessagesManager.cpp
@@ -515,7 +515,7 @@ class GetDialogMessageByDateQuery final : public Td::ResultHandler {
   void send(DialogId dialog_id, int32 date) {
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Can't access the chat"));
+      return promise_.set_error(400, "Can't access the chat");
     }
 
     dialog_id_ = dialog_id;
@@ -572,7 +572,7 @@ class GetHistoryQuery final : public Td::ResultHandler {
             int32 limit) {
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Can't access the chat"));
+      return promise_.set_error(400, "Can't access the chat");
     }
     CHECK(offset < 0);
 
@@ -589,7 +589,7 @@ class GetHistoryQuery final : public Td::ResultHandler {
   void send_get_from_the_end(DialogId dialog_id, MessageId old_last_new_message_id, int32 limit) {
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Can't access the chat"));
+      return promise_.set_error(400, "Can't access the chat");
     }
 
     dialog_id_ = dialog_id;
@@ -1039,7 +1039,7 @@ class GetSearchResultPositionsQuery final : public Td::ResultHandler {
             MessageId from_message_id, int32 limit) {
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Can't access the chat"));
+      return promise_.set_error(400, "Can't access the chat");
     }
     dialog_id_ = dialog_id;
     saved_messages_topic_id_ = saved_messages_topic_id;
@@ -1086,7 +1086,7 @@ class GetSearchCountersQuery final : public Td::ResultHandler {
   void send(DialogId dialog_id, MessageTopic message_topic, MessageSearchFilter filter) {
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Can't access the chat"));
+      return promise_.set_error(400, "Can't access the chat");
     }
 
     dialog_id_ = dialog_id;
@@ -6118,7 +6118,7 @@ void MessagesManager::remove_dialog_action_bar(DialogId dialog_id, Promise<Unit>
   }
 
   if (!d->know_action_bar) {
-    return promise.set_error(Status::Error(400, "Can't update chat action bar"));
+    return promise.set_error(400, "Can't update chat action bar");
   }
   if (d->need_repair_action_bar) {
     d->need_repair_action_bar = false;
@@ -7906,7 +7906,7 @@ void MessagesManager::delete_messages(DialogId dialog_id, const vector<MessageId
   vector<MessageId> deleted_scheduled_server_message_ids;
   for (auto message_id : input_message_ids) {
     if (!message_id.is_valid() && !message_id.is_valid_scheduled()) {
-      return promise.set_error(Status::Error(400, "Invalid message identifier"));
+      return promise.set_error(400, "Invalid message identifier");
     }
 
     message_id = get_persistent_message_id(d, message_id);
@@ -7929,10 +7929,10 @@ void MessagesManager::delete_messages(DialogId dialog_id, const vector<MessageId
   for (auto message_id : message_ids) {
     auto m = get_message(d, message_id);
     if (!can_delete_message(dialog_id, m)) {
-      return promise.set_error(Status::Error(400, "Message can't be deleted"));
+      return promise.set_error(400, "Message can't be deleted");
     }
     if (is_bot && !message_id.is_scheduled() && message_id.is_server() && !can_revoke_message(dialog_id, m)) {
-      return promise.set_error(Status::Error(400, "Message can't be deleted for everyone"));
+      return promise.set_error(400, "Message can't be deleted for everyone");
     }
   }
 
@@ -8102,10 +8102,10 @@ void MessagesManager::delete_dialog_history(DialogId dialog_id, bool remove_from
   if (is_dialog_sponsored(d)) {
     auto chat_source = sponsored_dialog_source_.get_chat_source_object();
     if (chat_source == nullptr || chat_source->get_id() != td_api::chatSourcePublicServiceAnnouncement::ID) {
-      return promise.set_error(Status::Error(400, "Can't delete the chat"));
+      return promise.set_error(400, "Can't delete the chat");
     }
     if (!remove_from_dialog_list) {
-      return promise.set_error(Status::Error(400, "Can't delete chat history without removing the chat"));
+      return promise.set_error(400, "Can't delete chat history without removing the chat");
     }
 
     removed_sponsored_dialog_id_ = dialog_id;
@@ -8120,7 +8120,7 @@ void MessagesManager::delete_dialog_history(DialogId dialog_id, bool remove_from
   if (revoke) {
     if (!can_delete.for_all_users_) {
       if (!can_delete.for_self_) {
-        return promise.set_error(Status::Error(400, "Chat history can't be deleted"));
+        return promise.set_error(400, "Chat history can't be deleted");
       }
 
       LOG(INFO) << "Can't delete history of " << dialog_id << " for everyone; delete it only for self";
@@ -8128,8 +8128,7 @@ void MessagesManager::delete_dialog_history(DialogId dialog_id, bool remove_from
     }
   } else {
     if (!can_delete.for_self_) {
-      return promise.set_error(
-          Status::Error(400, PSLICE() << "Can't delete history of " << dialog_id << " only for self"));
+      return promise.set_error(400, PSLICE() << "Can't delete history of " << dialog_id << " only for self");
     }
   }
 
@@ -8216,7 +8215,7 @@ void MessagesManager::delete_dialog_messages_by_sender(DialogId dialog_id, Dialo
                      check_dialog_access(dialog_id, true, AccessRights::Write, "delete_dialog_messages_by_sender"));
 
   if (!td_->dialog_manager_->have_input_peer(sender_dialog_id, false, AccessRights::Know)) {
-    return promise.set_error(Status::Error(400, "Message sender not found"));
+    return promise.set_error(400, "Message sender not found");
   }
 
   ChannelId channel_id;
@@ -8225,17 +8224,16 @@ void MessagesManager::delete_dialog_messages_by_sender(DialogId dialog_id, Dialo
     case DialogType::User:
     case DialogType::Chat:
     case DialogType::SecretChat:
-      return promise.set_error(
-          Status::Error(400, "All messages from a sender can be deleted only in supergroup chats"));
+      return promise.set_error(400, "All messages from a sender can be deleted only in supergroup chats");
     case DialogType::Channel: {
       channel_id = dialog_id.get_channel_id();
       if (!td_->chat_manager_->is_megagroup_channel(channel_id) ||
           td_->chat_manager_->is_monoforum_channel(channel_id)) {
-        return promise.set_error(Status::Error(400, "The method is available only in regular supergroup chats"));
+        return promise.set_error(400, "The method is available only in regular supergroup chats");
       }
       channel_status = td_->chat_manager_->get_channel_permissions(channel_id);
       if (!channel_status.can_delete_messages()) {
-        return promise.set_error(Status::Error(400, "Need delete messages administrator right in the supergroup chat"));
+        return promise.set_error(400, "Need delete messages administrator right in the supergroup chat");
       }
       channel_id = dialog_id.get_channel_id();
       break;
@@ -8311,11 +8309,11 @@ void MessagesManager::delete_dialog_messages_by_date(DialogId dialog_id, int32 m
       break;
     case DialogType::Chat:
       if (revoke) {
-        return promise.set_error(Status::Error(400, "Bulk message revocation is unsupported in basic group chats"));
+        return promise.set_error(400, "Bulk message revocation is unsupported in basic group chats");
       }
       break;
     case DialogType::Channel:
-      return promise.set_error(Status::Error(400, "Bulk message deletion is unsupported in supergroup chats"));
+      return promise.set_error(400, "Bulk message deletion is unsupported in supergroup chats");
     case DialogType::SecretChat:
     case DialogType::None:
     default:
@@ -10432,7 +10430,7 @@ void MessagesManager::on_get_secret_message(SecretChatId secret_chat_id, UserId
 
   if (message->random_id_ == 0) {
     LOG(ERROR) << "Ignore secret message with random_id == 0";
-    promise.set_error(Status::Error(400, "Invalid random_id"));
+    promise.set_error(400, "Invalid random_id");
     return;
   }
 
@@ -10456,7 +10454,7 @@ void MessagesManager::on_get_secret_message(SecretChatId secret_chat_id, UserId
   }
   if (d == nullptr) {
     LOG(ERROR) << "Ignore secret message in unknown " << message_info.dialog_id;
-    pending_secret_message->success_promise.set_error(Status::Error(500, "Chat not found"));
+    pending_secret_message->success_promise.set_error(500, "Chat not found");
     return;
   }
 
@@ -10543,7 +10541,7 @@ void MessagesManager::on_secret_chat_screenshot_taken(SecretChatId secret_chat_i
   }
   if (d == nullptr) {
     LOG(ERROR) << "Ignore secret message in unknown " << message_info.dialog_id;
-    pending_secret_message->success_promise.set_error(Status::Error(500, "Chat not found"));
+    pending_secret_message->success_promise.set_error(500, "Chat not found");
     return;
   }
 
@@ -10581,7 +10579,7 @@ void MessagesManager::on_secret_chat_ttl_changed(SecretChatId secret_chat_id, Us
   }
   if (d == nullptr) {
     LOG(ERROR) << "Ignore secret message in unknown " << message_info.dialog_id;
-    pending_secret_message->success_promise.set_error(Status::Error(500, "Chat not found"));
+    pending_secret_message->success_promise.set_error(500, "Chat not found");
     return;
   }
 
@@ -12051,29 +12049,27 @@ void MessagesManager::on_get_dialogs(FolderId folder_id, vector<tl_object_ptr<te
 
     if (!dialog_id.is_valid()) {
       LOG(ERROR) << "Receive wrong " << dialog_id;
-      return promise.set_error(Status::Error(500, "Wrong query result returned: receive wrong chat identifier"));
+      return promise.set_error(500, "Wrong query result returned: receive wrong chat identifier");
     }
     switch (dialog_id.get_type()) {
       case DialogType::User:
       case DialogType::Chat:
         if (has_pts) {
           LOG(ERROR) << "Receive user or group " << dialog_id << " with PTS";
-          return promise.set_error(
-              Status::Error(500, "Wrong query result returned: receive user or basic group chat with PTS"));
+          return promise.set_error(500, "Wrong query result returned: receive user or basic group chat with PTS");
         }
         break;
       case DialogType::Channel:
         if (!has_pts) {
           LOG(ERROR) << "Receive channel " << dialog_id << " without PTS";
-          return promise.set_error(
-              Status::Error(500, "Wrong query result returned: receive supergroup chat without PTS"));
+          return promise.set_error(500, "Wrong query result returned: receive supergroup chat without PTS");
         }
         break;
       case DialogType::SecretChat:
       case DialogType::None:
       default:
         UNREACHABLE();
-        return promise.set_error(Status::Error(500, "UNREACHABLE"));
+        return promise.set_error(500, "UNREACHABLE");
     }
 
     if (from_dialog_list) {
@@ -12086,7 +12082,7 @@ void MessagesManager::on_get_dialogs(FolderId folder_id, vector<tl_object_ptr<te
         }
         if (it == message_full_id_to_dialog_date.end()) {
           LOG(ERROR) << "Last " << last_message_id << " in " << dialog_id << " not found";
-          return promise.set_error(Status::Error(500, "Wrong query result returned: last message not found"));
+          return promise.set_error(500, "Wrong query result returned: last message not found");
         }
         FolderId dialog_folder_id(dialog->folder_id_);
         if (dialog_folder_id != folder_id) {
@@ -13074,7 +13070,7 @@ void MessagesManager::load_dialogs(vector<DialogId> dialog_ids, Promise<vector<D
 
 bool MessagesManager::load_dialog(DialogId dialog_id, int left_tries, Promise<Unit> &&promise) {
   if (!dialog_id.is_valid()) {
-    promise.set_error(Status::Error(400, "Invalid chat identifier specified"));
+    promise.set_error(400, "Invalid chat identifier specified");
     return false;
   }
 
@@ -13116,7 +13112,7 @@ bool MessagesManager::load_dialog(DialogId dialog_id, int left_tries, Promise<Un
           break;
         }
         case DialogType::SecretChat:
-          promise.set_error(Status::Error(400, "Chat not found"));
+          promise.set_error(400, "Chat not found");
           return false;
         case DialogType::None:
         default:
@@ -13130,7 +13126,7 @@ bool MessagesManager::load_dialog(DialogId dialog_id, int left_tries, Promise<Un
       return true;
     }
 
-    promise.set_error(Status::Error(400, "Chat not found"));
+    promise.set_error(400, "Chat not found");
     return false;
   }
 
@@ -13154,7 +13150,7 @@ vector<DialogId> MessagesManager::get_dialogs(DialogListId dialog_list_id, Dialo
 
   auto *list_ptr = get_dialog_list(dialog_list_id);
   if (list_ptr == nullptr) {
-    promise.set_error(Status::Error(400, "Chat list not found"));
+    promise.set_error(400, "Chat list not found");
     return {};
   }
   auto &list = *list_ptr;
@@ -13165,7 +13161,7 @@ vector<DialogId> MessagesManager::get_dialogs(DialogListId dialog_list_id, Dialo
             << ", are_pinned_dialogs_inited_ = " << list.are_pinned_dialogs_inited_;
 
   if (limit <= 0) {
-    promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    promise.set_error(400, "Parameter limit must be positive");
     return {};
   }
 
@@ -13340,7 +13336,7 @@ void MessagesManager::load_dialog_list(DialogList &list, int32 limit, Promise<Un
   } else {
     LOG(ERROR) << "There is nothing to load for " << list.dialog_list_id << " with folders "
                << get_dialog_list_folder_ids(list);
-    promise.set_error(Status::Error(404, "Not Found"));
+    promise.set_error(404, "Not Found");
   }
 }
 
@@ -13564,11 +13560,11 @@ void MessagesManager::get_dialogs_from_list(DialogListId dialog_list_id, int32 l
 
   auto *list = get_dialog_list(dialog_list_id);
   if (list == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat list not found"));
+    return promise.set_error(400, "Chat list not found");
   }
 
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
 
   auto task_id = ++current_get_dialogs_task_id_;
@@ -13662,7 +13658,7 @@ void MessagesManager::read_all_dialogs_from_list(DialogListId dialog_list_id, Pr
   TRY_STATUS_PROMISE(promise, G()->close_status());
 
   if (get_dialog_list(dialog_list_id) == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat list not found"));
+    return promise.set_error(400, "Chat list not found");
   }
 
   dialogs_.foreach([&](const DialogId &dialog_id, unique_ptr<Dialog> &dialog) {
@@ -13714,7 +13710,7 @@ std::pair<int32, vector<DialogId>> MessagesManager::search_dialogs(const string
   CHECK(!td_->auth_manager_->is_bot());
 
   if (limit < 0) {
-    promise.set_error(Status::Error(400, "Limit must be non-negative"));
+    promise.set_error(400, "Limit must be non-negative");
     return {};
   }
   if (query.empty()) {
@@ -13766,10 +13762,10 @@ void MessagesManager::block_message_sender_from_replies(MessageId message_id, bo
 
   auto *m = get_message_force(d, message_id, "block_message_sender_from_replies");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (m->is_outgoing || m->message_id.is_scheduled() || !m->message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Wrong message specified"));
+    return promise.set_error(400, "Wrong message specified");
   }
 
   DialogId sender_dialog_id;
@@ -13958,7 +13954,7 @@ MessageFullId MessagesManager::get_replied_message(DialogId dialog_id, MessageId
                                                    Promise<Unit> &&promise) {
   Dialog *d = get_dialog_force(dialog_id, "get_replied_message");
   if (d == nullptr) {
-    promise.set_error(Status::Error(400, "Chat not found"));
+    promise.set_error(400, "Chat not found");
     return MessageFullId();
   }
 
@@ -13989,7 +13985,7 @@ MessageFullId MessagesManager::get_replied_message(DialogId dialog_id, MessageId
     force_create_dialog(dialog_id, "get_replied_message");
     d = get_dialog_force(dialog_id, "get_replied_message");
     if (d == nullptr) {
-      promise.set_error(Status::Error(500, "Chat with replied message not found"));
+      promise.set_error(500, "Chat with replied message not found");
       return {};
     }
   } else if (m->message_id.is_valid() && m->message_id.is_server()) {
@@ -14034,10 +14030,10 @@ void MessagesManager::get_message_thread(DialogId dialog_id, MessageId message_i
   LOG(INFO) << "Get message thread from " << message_id << " in " << dialog_id;
   TRY_RESULT_PROMISE(promise, d, check_dialog_access(dialog_id, false, AccessRights::Read, "get_message_thread"));
   if (dialog_id.get_type() != DialogType::Channel) {
-    return promise.set_error(Status::Error(400, "Chat is not a supergroup or a channel"));
+    return promise.set_error(400, "Chat is not a supergroup or a channel");
   }
   if (message_id.is_scheduled()) {
-    return promise.set_error(Status::Error(400, "Scheduled messages can't have message threads"));
+    return promise.set_error(400, "Scheduled messages can't have message threads");
   }
 
   MessageFullId top_thread_message_full_id;
@@ -14047,7 +14043,7 @@ void MessagesManager::get_message_thread(DialogId dialog_id, MessageId message_i
     message_id = get_persistent_message_id(d, message_id);
     auto m = get_message_force(d, message_id, "get_message_thread");
     if (m == nullptr) {
-      return promise.set_error(Status::Error(400, "Message not found"));
+      return promise.set_error(400, "Message not found");
     }
 
     TRY_RESULT_PROMISE_ASSIGN(promise, top_thread_message_full_id, get_top_thread_message_full_id(dialog_id, m, true));
@@ -14085,20 +14081,20 @@ void MessagesManager::on_get_discussion_message(DialogId dialog_id, MessageId me
   CHECK(message_id.is_valid());
   auto m = get_message_force(d, message_id, "on_get_discussion_message");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (message_thread_info.message_ids.empty()) {
     if (message_thread_info.dialog_id != dialog_id &&
         !td_->dialog_manager_->have_input_peer(message_thread_info.dialog_id, false, AccessRights::Read)) {
-      return promise.set_error(Status::Error(400, "Can't access message comments"));
+      return promise.set_error(400, "Can't access message comments");
     }
-    return promise.set_error(Status::Error(400, "Message has no thread"));
+    return promise.set_error(400, "Message has no thread");
   }
 
   DialogId expected_dialog_id;
   if (m->reply_info.is_comment_) {
     if (!is_active_message_reply_info(dialog_id, m->reply_info)) {
-      return promise.set_error(Status::Error(400, "Message has no comments"));
+      return promise.set_error(400, "Message has no comments");
     }
     expected_dialog_id = DialogId(m->reply_info.channel_id_);
   } else if (message_id == MessageId(ServerMessageId(1)) && d->is_forum) {
@@ -14106,7 +14102,7 @@ void MessagesManager::on_get_discussion_message(DialogId dialog_id, MessageId me
     expected_dialog_id = dialog_id;
   } else {
     if (!m->top_thread_message_id.is_valid()) {
-      return promise.set_error(Status::Error(400, "Message has no thread"));
+      return promise.set_error(400, "Message has no thread");
     }
     expected_dialog_id = dialog_id;
   }
@@ -14119,7 +14115,7 @@ void MessagesManager::on_get_discussion_message(DialogId dialog_id, MessageId me
       return !have_message_force(linked_d, linked_message_id, "on_get_discussion_message 4");
     });
     if (message_thread_info.message_ids.empty()) {
-      return promise.set_error(Status::Error(400, "Message has no thread"));
+      return promise.set_error(400, "Message has no thread");
     }
     auto linked_message_id = message_thread_info.message_ids.back();
     Message *linked_m = get_message_force(linked_d, linked_message_id, "on_get_discussion_message 3");
@@ -14239,7 +14235,7 @@ void MessagesManager::get_message_read_date(MessageFullId message_full_id,
 
   auto m = get_message_force(d, message_full_id.get_message_id(), "get_message_read_date");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   TRY_STATUS_PROMISE(promise, can_get_message_read_date(dialog_id, m));
@@ -14342,7 +14338,7 @@ void MessagesManager::translate_message_text(MessageFullId message_full_id, cons
                                              Promise<td_api::object_ptr<td_api::formattedText>> &&promise) {
   auto m = get_message_force(message_full_id, "translate_message_text");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   auto text = get_message_content_text(m->content.get());
@@ -14377,7 +14373,7 @@ void MessagesManager::reload_dialog_notification_settings(DialogId dialog_id, Pr
 MessageId MessagesManager::get_dialog_pinned_message(DialogId dialog_id, Promise<Unit> &&promise) {
   Dialog *d = get_dialog_force(dialog_id, "get_dialog_pinned_message");
   if (d == nullptr) {
-    promise.set_error(Status::Error(400, "Chat not found"));
+    promise.set_error(400, "Chat not found");
     return MessageId();
   }
 
@@ -14410,7 +14406,7 @@ void MessagesManager::get_callback_query_message(DialogId dialog_id, MessageId m
   TRY_RESULT_PROMISE(promise, d,
                      check_dialog_access(dialog_id, true, AccessRights::Read, "get_callback_query_message"));
   if (!message_id.is_valid() || !message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Invalid message identifier specified"));
+    return promise.set_error(400, "Invalid message identifier specified");
   }
 
   LOG(INFO) << "Get callback query " << message_id << " in " << dialog_id << " for query " << callback_query_id;
@@ -14427,7 +14423,7 @@ void MessagesManager::get_messages(DialogId dialog_id, const vector<MessageId> &
   vector<MessageFullId> missed_message_ids;
   for (auto message_id : message_ids) {
     if (!message_id.is_valid() && !message_id.is_valid_scheduled()) {
-      return promise.set_error(Status::Error(400, "Invalid message identifier"));
+      return promise.set_error(400, "Invalid message identifier");
     }
 
     auto *m = get_message_force(d, message_id, "get_messages");
@@ -14457,7 +14453,7 @@ void MessagesManager::get_messages_from_server(vector<MessageFullId> &&message_i
 
   if (message_ids.empty()) {
     LOG(ERROR) << "Empty message_ids from " << source;
-    return promise.set_error(Status::Error(500, "There are no messages specified to fetch"));
+    return promise.set_error(500, "There are no messages specified to fetch");
   }
 
   if (input_message != nullptr) {
@@ -14515,7 +14511,7 @@ void MessagesManager::get_messages_from_server(vector<MessageFullId> &&message_i
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     if (input_peer == nullptr) {
       LOG(ERROR) << "Can't find info about " << dialog_id << " to get a message from it from " << source;
-      mpas.get_promise().set_error(Status::Error(400, "Can't access the chat"));
+      mpas.get_promise().set_error(400, "Can't access the chat");
       continue;
     }
     td_->create_handler<GetScheduledMessagesQuery>(mpas.get_promise())
@@ -14527,7 +14523,7 @@ void MessagesManager::get_messages_from_server(vector<MessageFullId> &&message_i
     auto input_channel = td_->chat_manager_->get_input_channel(it.first);
     if (input_channel == nullptr) {
       LOG(ERROR) << "Can't find info about " << it.first << " to get a message from it from " << source;
-      mpas.get_promise().set_error(Status::Error(400, "Can't access the chat"));
+      mpas.get_promise().set_error(400, "Can't access the chat");
       continue;
     }
     const auto *d = get_dialog_force(DialogId(it.first));
@@ -14552,7 +14548,7 @@ void MessagesManager::get_message_properties(DialogId dialog_id, MessageId messa
     if (message_id.is_valid_sponsored()) {
       return promise.set_value(td_api::make_object<td_api::messageProperties>());
     }
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   message_id = m->message_id;
 
@@ -14648,7 +14644,7 @@ MessagesManager::ReportDialogFromActionBar MessagesManager::report_dialog_from_a
     auto user_dialog_id = DialogId(td_->user_manager_->get_secret_chat_user_id(dialog_id.get_secret_chat_id()));
     d = get_dialog_force(user_dialog_id, "report_dialog_from_action_bar");
     if (d == nullptr) {
-      promise.set_error(Status::Error(400, "Chat with the user not found"));
+      promise.set_error(400, "Chat with the user not found");
       result.is_reported_ = true;
       return result;
     }
@@ -14967,7 +14963,7 @@ void MessagesManager::on_get_public_message_link(MessageFullId message_full_id,
 void MessagesManager::get_message_link_info(Slice url, Promise<MessageLinkInfo> &&promise) {
   auto r_message_link_info = LinkManager::get_message_link_info(url);
   if (r_message_link_info.is_error()) {
-    return promise.set_error(Status::Error(400, r_message_link_info.error().message()));
+    return promise.set_error(400, r_message_link_info.error().message());
   }
 
   auto info = r_message_link_info.move_as_ok();
@@ -15040,7 +15036,7 @@ void MessagesManager::on_get_message_link_discussion_message(MessageLinkInfo &&i
 
   Dialog *d = get_dialog_force(comment_dialog_id, "on_get_message_link_discussion_message");
   if (d == nullptr) {
-    return promise.set_error(Status::Error(500, "Chat not found"));
+    return promise.set_error(500, "Chat not found");
   }
 
   auto comment_message_id = info.comment_message_id;
@@ -15668,10 +15664,10 @@ bool MessagesManager::is_dialog_mention_notifications_disabled(const Dialog *d)
 void MessagesManager::create_dialog(DialogId dialog_id, bool force, Promise<Unit> &&promise) {
   if (!td_->dialog_manager_->have_input_peer(dialog_id, true, AccessRights::Read)) {
     if (!td_->dialog_manager_->have_dialog_info_force(dialog_id, "create dialog")) {
-      return promise.set_error(Status::Error(400, "Chat info not found"));
+      return promise.set_error(400, "Chat info not found");
     }
     if (!td_->dialog_manager_->have_input_peer(dialog_id, true, AccessRights::Read)) {
-      return promise.set_error(Status::Error(400, "Can't access the chat"));
+      return promise.set_error(400, "Can't access the chat");
     }
   }
 
@@ -16162,7 +16158,7 @@ void MessagesManager::click_animated_emoji_message(MessageFullId message_full_id
   auto message_id = get_persistent_message_id(d, message_full_id.get_message_id());
   auto *m = get_message_force(d, message_id, "click_animated_emoji_message");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   if (m->message_id.is_scheduled() || dialog_id.get_type() != DialogType::User || !m->message_id.is_server()) {
@@ -16683,32 +16679,32 @@ tl_object_ptr<td_api::messages> MessagesManager::get_dialog_history(DialogId dia
                                                                     int32 offset, int32 limit, int left_tries,
                                                                     bool only_local, Promise<Unit> &&promise) {
   if (limit <= 0) {
-    promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    promise.set_error(400, "Parameter limit must be positive");
     return nullptr;
   }
   if (limit > MAX_GET_HISTORY) {
     limit = MAX_GET_HISTORY;
   }
   if (offset > 0) {
-    promise.set_error(Status::Error(400, "Parameter offset must be non-positive"));
+    promise.set_error(400, "Parameter offset must be non-positive");
     return nullptr;
   }
   if (offset <= -MAX_GET_HISTORY) {
-    promise.set_error(Status::Error(400, "Parameter offset must be greater than -100"));
+    promise.set_error(400, "Parameter offset must be greater than -100");
     return nullptr;
   }
   if (offset < -limit) {
-    promise.set_error(Status::Error(400, "Parameter offset must be greater than or equal to -limit"));
+    promise.set_error(400, "Parameter offset must be greater than or equal to -limit");
     return nullptr;
   }
 
   const Dialog *d = get_dialog_force(dialog_id, "get_dialog_history");
   if (d == nullptr) {
-    promise.set_error(Status::Error(400, "Chat not found"));
+    promise.set_error(400, "Chat not found");
     return nullptr;
   }
   if (!td_->dialog_manager_->have_input_peer(dialog_id, true, AccessRights::Read)) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return nullptr;
   }
 
@@ -16716,7 +16712,7 @@ tl_object_ptr<td_api::messages> MessagesManager::get_dialog_history(DialogId dia
     from_message_id = MessageId::max();
   }
   if (!from_message_id.is_valid()) {
-    promise.set_error(Status::Error(400, "Invalid value of parameter from_message_id specified"));
+    promise.set_error(400, "Invalid value of parameter from_message_id specified");
     return nullptr;
   }
 
@@ -17043,22 +17039,22 @@ std::pair<DialogId, vector<MessageId>> MessagesManager::get_message_thread_histo
     DialogId dialog_id, MessageId message_id, MessageId from_message_id, int32 offset, int32 limit, int64 &random_id,
     Promise<Unit> &&promise) {
   if (limit <= 0) {
-    promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    promise.set_error(400, "Parameter limit must be positive");
     return {};
   }
   if (limit > MAX_GET_HISTORY) {
     limit = MAX_GET_HISTORY;
   }
   if (offset > 0) {
-    promise.set_error(Status::Error(400, "Parameter offset must be non-positive"));
+    promise.set_error(400, "Parameter offset must be non-positive");
     return {};
   }
   if (offset <= -MAX_GET_HISTORY) {
-    promise.set_error(Status::Error(400, "Parameter offset must be greater than -100"));
+    promise.set_error(400, "Parameter offset must be greater than -100");
     return {};
   }
   if (offset < -limit) {
-    promise.set_error(Status::Error(400, "Parameter offset must be greater than or equal to -limit"));
+    promise.set_error(400, "Parameter offset must be greater than or equal to -limit");
     return {};
   }
   bool is_limit_increased = false;
@@ -17071,15 +17067,15 @@ std::pair<DialogId, vector<MessageId>> MessagesManager::get_message_thread_histo
 
   Dialog *d = get_dialog_force(dialog_id, "get_message_thread_history");
   if (d == nullptr) {
-    promise.set_error(Status::Error(400, "Chat not found"));
+    promise.set_error(400, "Chat not found");
     return {};
   }
   if (!td_->dialog_manager_->have_input_peer(dialog_id, true, AccessRights::Read)) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return {};
   }
   if (dialog_id.get_type() != DialogType::Channel) {
-    promise.set_error(Status::Error(400, "Can't get message thread history in the chat"));
+    promise.set_error(400, "Can't get message thread history in the chat");
     return {};
   }
 
@@ -17087,7 +17083,7 @@ std::pair<DialogId, vector<MessageId>> MessagesManager::get_message_thread_histo
     from_message_id = MessageId::max();
   }
   if (!from_message_id.is_valid()) {
-    promise.set_error(Status::Error(400, "Parameter from_message_id must be identifier of a chat message or 0"));
+    promise.set_error(400, "Parameter from_message_id must be identifier of a chat message or 0");
     return {};
   }
 
@@ -17098,7 +17094,7 @@ std::pair<DialogId, vector<MessageId>> MessagesManager::get_message_thread_histo
     message_id = get_persistent_message_id(d, message_id);
     Message *m = get_message_force(d, message_id, "get_message_thread_history 1");
     if (m == nullptr) {
-      promise.set_error(Status::Error(400, "Message not found"));
+      promise.set_error(400, "Message not found");
       return {};
     }
 
@@ -17147,7 +17143,7 @@ std::pair<DialogId, vector<MessageId>> MessagesManager::get_message_thread_histo
       CHECK(d != nullptr);
     }
     if (dialog_id != top_thread_message_full_id.get_dialog_id()) {
-      promise.set_error(Status::Error(500, "Receive messages in an unexpected chat"));
+      promise.set_error(500, "Receive messages in an unexpected chat");
       return {};
     }
 
@@ -17226,7 +17222,7 @@ void MessagesManager::get_dialog_message_calendar(DialogId dialog_id,
   }
 
   if (!from_message_id.is_valid() && from_message_id != MessageId()) {
-    return promise.set_error(Status::Error(400, "Parameter from_message_id must be identifier of a chat message or 0"));
+    return promise.set_error(400, "Parameter from_message_id must be identifier of a chat message or 0");
   }
   from_message_id = from_message_id.get_next_server_message_id();
 
@@ -17243,10 +17239,10 @@ void MessagesManager::get_dialog_message_calendar(DialogId dialog_id,
     if (filter != MessageSearchFilter::Empty && message_topic.get_saved_messages_topic_id().is_valid()) {
       return promise.set_value(td_api::make_object<td_api::messageCalendar>());
     }
-    return promise.set_error(Status::Error(400, "The filter is not supported"));
+    return promise.set_error(400, "The filter is not supported");
   }
   if (message_topic.get_forum_topic_id().is_valid()) {
-    return promise.set_error(Status::Error(400, "Not supported in forum topics"));
+    return promise.set_error(400, "Not supported in forum topics");
   }
 
   // Trying to use database
@@ -17290,7 +17286,7 @@ void MessagesManager::get_dialog_message_calendar(DialogId dialog_id,
     case DialogType::None:
     default:
       UNREACHABLE();
-      return promise.set_error(Status::Error(500, "Message search is not supported"));
+      return promise.set_error(500, "Message search is not supported");
   }
 }
 
@@ -17367,18 +17363,18 @@ MessagesManager::FoundDialogMessages MessagesManager::search_dialog_messages(
 
   FoundDialogMessages result;
   if (limit <= 0) {
-    promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    promise.set_error(400, "Parameter limit must be positive");
     return result;
   }
   if (limit > MAX_SEARCH_MESSAGES) {
     limit = MAX_SEARCH_MESSAGES;
   }
   if (limit <= -offset) {
-    promise.set_error(Status::Error(400, "Parameter limit must be greater than -offset"));
+    promise.set_error(400, "Parameter limit must be greater than -offset");
     return result;
   }
   if (offset > 0) {
-    promise.set_error(Status::Error(400, "Parameter offset must be non-positive"));
+    promise.set_error(400, "Parameter offset must be non-positive");
     return result;
   }
 
@@ -17387,18 +17383,18 @@ MessagesManager::FoundDialogMessages MessagesManager::search_dialog_messages(
   }
 
   if (!from_message_id.is_valid() && from_message_id != MessageId()) {
-    promise.set_error(Status::Error(400, "Parameter from_message_id must be identifier of a chat message or 0"));
+    promise.set_error(400, "Parameter from_message_id must be identifier of a chat message or 0");
     return result;
   }
   from_message_id = from_message_id.get_next_server_message_id();
 
   const Dialog *d = get_dialog_force(dialog_id, "search_dialog_messages");
   if (d == nullptr) {
-    promise.set_error(Status::Error(400, "Chat not found"));
+    promise.set_error(400, "Chat not found");
     return result;
   }
   if (!td_->dialog_manager_->have_input_peer(dialog_id, true, AccessRights::Read)) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return result;
   }
 
@@ -17417,7 +17413,7 @@ MessagesManager::FoundDialogMessages MessagesManager::search_dialog_messages(
   auto sender_dialog_id = r_sender_dialog_id.move_as_ok();
   if (sender_dialog_id != DialogId() &&
       !td_->dialog_manager_->have_input_peer(sender_dialog_id, false, AccessRights::Know)) {
-    promise.set_error(Status::Error(400, "Invalid message sender specified"));
+    promise.set_error(400, "Invalid message sender specified");
     return result;
   }
   if (sender_dialog_id == dialog_id && td_->dialog_manager_->is_broadcast_channel(dialog_id)) {
@@ -17439,11 +17435,11 @@ MessagesManager::FoundDialogMessages MessagesManager::search_dialog_messages(
 
   if (filter == MessageSearchFilter::UnreadMention || filter == MessageSearchFilter::UnreadReaction) {
     if (!query.empty()) {
-      promise.set_error(Status::Error(400, "Non-empty query is unsupported with the specified filter"));
+      promise.set_error(400, "Non-empty query is unsupported with the specified filter");
       return result;
     }
     if (sender_dialog_id.is_valid()) {
-      promise.set_error(Status::Error(400, "Filtering by sender is unsupported with the specified filter"));
+      promise.set_error(400, "Filtering by sender is unsupported with the specified filter");
       return result;
     }
     if (message_topic.get_saved_messages_topic_id().is_valid() ||
@@ -17518,13 +17514,13 @@ MessagesManager::FoundDialogMessages MessagesManager::search_dialog_messages(
           filter == MessageSearchFilter::UnreadReaction) {
         promise.set_value(Unit());
       } else {
-        promise.set_error(Status::Error(500, "Message search is not supported in secret chats"));
+        promise.set_error(500, "Message search is not supported in secret chats");
       }
       break;
     case DialogType::None:
     default:
       UNREACHABLE();
-      promise.set_error(Status::Error(500, "Message search is not supported"));
+      promise.set_error(500, "Message search is not supported");
   }
   return result;
 }
@@ -17532,7 +17528,7 @@ MessagesManager::FoundDialogMessages MessagesManager::search_dialog_messages(
 void MessagesManager::search_call_messages(const string &offset, int32 limit, bool only_missed,
                                            Promise<td_api::object_ptr<td_api::foundMessages>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_SEARCH_MESSAGES) {
     limit = MAX_SEARCH_MESSAGES;
@@ -17542,7 +17538,7 @@ void MessagesManager::search_call_messages(const string &offset, int32 limit, bo
   if (!offset.empty()) {
     auto r_offset_server_message_id = to_integer_safe<int32>(offset);
     if (r_offset_server_message_id.is_error()) {
-      return promise.set_error(Status::Error(400, "Invalid offset specified"));
+      return promise.set_error(400, "Invalid offset specified");
     }
 
     offset_message_id = MessageId(ServerMessageId(r_offset_server_message_id.ok()));
@@ -18071,16 +18067,16 @@ void MessagesManager::offline_search_messages(DialogId dialog_id, const string &
                                               MessageSearchFilter filter,
                                               Promise<td_api::object_ptr<td_api::foundMessages>> &&promise) {
   if (!G()->use_message_database()) {
-    return promise.set_error(Status::Error(400, "Message database is required to search messages in secret chats"));
+    return promise.set_error(400, "Message database is required to search messages in secret chats");
   }
   if (query.empty()) {
     return promise.set_value(get_found_messages_object({}, "offline_search_messages"));
   }
   if (dialog_id != DialogId() && !have_dialog_force(dialog_id, "offline_search_messages")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Limit must be positive"));
+    return promise.set_error(400, "Limit must be positive");
   }
   if (limit > MAX_SEARCH_MESSAGES) {
     limit = MAX_SEARCH_MESSAGES;
@@ -18093,7 +18089,7 @@ void MessagesManager::offline_search_messages(DialogId dialog_id, const string &
   if (!offset.empty()) {
     auto r_from_search_id = to_integer_safe<int64>(offset);
     if (r_from_search_id.is_error()) {
-      return promise.set_error(Status::Error(400, "Invalid offset specified"));
+      return promise.set_error(400, "Invalid offset specified");
     }
     fts_query.from_search_id = r_from_search_id.ok();
   }
@@ -18297,18 +18293,18 @@ void MessagesManager::get_dialog_sparse_message_positions(
   TRY_RESULT_PROMISE(promise, d,
                      check_dialog_access(dialog_id, true, AccessRights::Read, "get_dialog_sparse_message_positions"));
   if (limit < 50 || limit > 2000) {  // server-side limits
-    return promise.set_error(Status::Error(400, "Invalid limit specified"));
+    return promise.set_error(400, "Invalid limit specified");
   }
 
   CHECK(filter != MessageSearchFilter::Call && filter != MessageSearchFilter::MissedCall);
   if (filter == MessageSearchFilter::Empty || filter == MessageSearchFilter::Mention ||
       filter == MessageSearchFilter::UnreadMention || filter == MessageSearchFilter::UnreadReaction ||
       filter == MessageSearchFilter::Pinned) {
-    return promise.set_error(Status::Error(400, "The filter is not supported"));
+    return promise.set_error(400, "The filter is not supported");
   }
 
   if (from_message_id.is_scheduled()) {
-    return promise.set_error(Status::Error(400, "Invalid from_message_id specified"));
+    return promise.set_error(400, "Invalid from_message_id specified");
   }
   if (!from_message_id.is_valid() || from_message_id > d->last_new_message_id) {
     if (d->last_new_message_id.is_valid()) {
@@ -18328,7 +18324,7 @@ void MessagesManager::get_dialog_sparse_message_positions(
       return promise.set_value(td_api::make_object<td_api::messagePositions>());
     }
     if (!G()->use_message_database()) {
-      return promise.set_error(Status::Error(400, "Unsupported without message database"));
+      return promise.set_error(400, "Unsupported without message database");
     }
 
     LOG(INFO) << "Get sparse message positions from database";
@@ -18388,7 +18384,7 @@ void MessagesManager::get_dialog_message_count(DialogId dialog_id,
   TRY_RESULT_PROMISE(promise, d, check_dialog_access(dialog_id, true, AccessRights::Read, "get_dialog_message_count"));
 
   if (filter == MessageSearchFilter::Empty) {
-    return promise.set_error(Status::Error(400, "Can't use searchMessagesFilterEmpty"));
+    return promise.set_error(400, "Can't use searchMessagesFilterEmpty");
   }
   TRY_RESULT_PROMISE(promise, message_topic, MessageTopic::get_message_topic(td_, dialog_id, topic_id));
 
@@ -18458,17 +18454,17 @@ void MessagesManager::get_dialog_message_position(MessageFullId message_full_id,
   auto message_id = message_full_id.get_message_id();
   const Message *m = get_message_force(d, message_id, "get_dialog_message_position");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!m->message_id.is_valid() || !m->message_id.is_server() ||
       (filter != MessageSearchFilter::Empty &&
        (get_message_index_mask(d->dialog_id, m) & message_search_filter_index_mask(filter)) == 0)) {
-    return promise.set_error(Status::Error(400, "Message can't be found in the filter"));
+    return promise.set_error(400, "Message can't be found in the filter");
   }
   TRY_RESULT_PROMISE(promise, message_topic, MessageTopic::get_message_topic(td_, dialog_id, topic_id));
 
   if (!message_topic.is_empty() && get_message_topic(dialog_id, m) != message_topic) {
-    return promise.set_error(Status::Error(400, "Message doesn't belong to the topic"));
+    return promise.set_error(400, "Message doesn't belong to the topic");
   }
 
   td_->message_query_manager_->get_dialog_message_position_from_server(dialog_id, message_topic, filter, message_id,
@@ -19023,16 +19019,16 @@ vector<MessageId> MessagesManager::get_dialog_scheduled_messages(DialogId dialog
   LOG(INFO) << "Get scheduled messages in " << dialog_id;
   Dialog *d = get_dialog_force(dialog_id, "get_dialog_scheduled_messages");
   if (d == nullptr) {
-    promise.set_error(Status::Error(400, "Chat not found"));
+    promise.set_error(400, "Chat not found");
     return {};
   }
   if (!td_->dialog_manager_->have_input_peer(dialog_id, true, AccessRights::Read)) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return {};
   }
   if (td_->dialog_manager_->is_broadcast_channel(dialog_id) &&
       !td_->chat_manager_->get_channel_status(dialog_id.get_channel_id()).can_post_messages()) {
-    promise.set_error(Status::Error(400, "Not enough rights to get scheduled messages"));
+    promise.set_error(400, "Not enough rights to get scheduled messages");
     return {};
   }
   if (d->dialog_id.get_type() == DialogType::SecretChat) {
@@ -19297,14 +19293,14 @@ void MessagesManager::add_message_reaction(MessageFullId message_full_id, Reacti
 
   Message *m = get_message_force(d, message_full_id.get_message_id(), "add_message_reaction");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   if (!get_message_available_reactions(d, m, true, nullptr).is_allowed_reaction_type(reaction_type)) {
-    return promise.set_error(Status::Error(400, "The reaction isn't available for the message"));
+    return promise.set_error(400, "The reaction isn't available for the message");
   }
   if (reaction_type.is_paid_reaction()) {
-    return promise.set_error(Status::Error(400, "Use addPendingPaidMessageReaction instead to add the paid reaction"));
+    return promise.set_error(400, "Use addPendingPaidMessageReaction instead to add the paid reaction");
   }
 
   bool have_recent_choosers =
@@ -19340,11 +19336,11 @@ void MessagesManager::remove_message_reaction(MessageFullId message_full_id, Rea
 
   Message *m = get_message_force(d, message_full_id.get_message_id(), "remove_message_reaction");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   if (reaction_type.is_empty() || reaction_type.is_paid_reaction()) {
-    return promise.set_error(Status::Error(400, "Invalid reaction specified"));
+    return promise.set_error(400, "Invalid reaction specified");
   }
 
   if (m->reactions == nullptr) {
@@ -19373,17 +19369,17 @@ void MessagesManager::add_paid_message_reaction(MessageFullId message_full_id, i
 
   Message *m = get_message_force(d, message_full_id.get_message_id(), "add_paid_message_reaction");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!get_message_available_reactions(d, m, true, nullptr).is_allowed_reaction_type(ReactionType::paid()) ||
       !td_->dialog_manager_->is_broadcast_channel(dialog_id)) {
-    return promise.set_error(Status::Error(400, "The reaction isn't available for the message"));
+    return promise.set_error(400, "The reaction isn't available for the message");
   }
   if (star_count <= 0 || star_count > td_->option_manager_->get_option_integer("paid_reaction_star_count_max")) {
-    return promise.set_error(Status::Error(400, "Invalid number of Telegram Stars specified"));
+    return promise.set_error(400, "Invalid number of Telegram Stars specified");
   }
   if (!td_->star_manager_->has_owned_star_count(star_count)) {
-    return promise.set_error(Status::Error(400, "Have not enough Telegram Stars"));
+    return promise.set_error(400, "Have not enough Telegram Stars");
   }
 
   if (m->reactions == nullptr) {
@@ -19453,10 +19449,10 @@ void MessagesManager::set_paid_message_reaction_type(MessageFullId message_full_
 
   Message *m = get_message_force(d, message_full_id.get_message_id(), "toggle_paid_message_reaction_is_anonymous");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (m->reactions == nullptr) {
-    return promise.set_error(Status::Error(400, "Message has no paid reactions"));
+    return promise.set_error(400, "Message has no paid reactions");
   }
   if (m->reactions->set_paid_message_reaction_type(td_, message_full_id, type, std::move(promise))) {
     send_update_message_interaction_info(d->dialog_id, m);
@@ -20555,7 +20551,7 @@ void MessagesManager::set_dialog_default_send_message_as_dialog_id(DialogId dial
       check_dialog_access(dialog_id, false, AccessRights::Read, "set_dialog_default_send_message_as_dialog_id"));
   if (!d->default_send_message_as_dialog_id.is_valid() || can_send_message(dialog_id).is_error() ||
       td_->dialog_manager_->is_monoforum_channel(dialog_id)) {
-    return promise.set_error(Status::Error(400, "Can't change message sender in the chat"));
+    return promise.set_error(400, "Can't change message sender in the chat");
   }
   // checked in on_update_dialog_default_send_message_as_dialog_id
   CHECK(dialog_id.get_type() == DialogType::Channel);
@@ -20565,11 +20561,11 @@ void MessagesManager::set_dialog_default_send_message_as_dialog_id(DialogId dial
   switch (message_sender_dialog_id.get_type()) {
     case DialogType::User:
       if (message_sender_dialog_id != td_->dialog_manager_->get_my_dialog_id()) {
-        return promise.set_error(Status::Error(400, "Can't send messages as another user"));
+        return promise.set_error(400, "Can't send messages as another user");
       }
       if (is_anonymous &&
           (!is_broadcast || !td_->chat_manager_->get_channel_sign_messages(dialog_id.get_channel_id()))) {
-        return promise.set_error(Status::Error(400, "Can't send messages as self"));
+        return promise.set_error(400, "Can't send messages as self");
       }
       break;
     case DialogType::Chat:
@@ -20580,14 +20576,14 @@ void MessagesManager::set_dialog_default_send_message_as_dialog_id(DialogId dial
       }
       if (!td_->dialog_manager_->is_broadcast_channel(message_sender_dialog_id) ||
           td_->chat_manager_->get_channel_first_username(message_sender_dialog_id.get_channel_id()).empty()) {
-        return promise.set_error(Status::Error(400, "Message sender chat must be a public channel"));
+        return promise.set_error(400, "Message sender chat must be a public channel");
       }
       break;
     default:
-      return promise.set_error(Status::Error(400, "Invalid message sender specified"));
+      return promise.set_error(400, "Invalid message sender specified");
   }
   if (!td_->dialog_manager_->have_input_peer(message_sender_dialog_id, true, AccessRights::Read)) {
-    return promise.set_error(Status::Error(400, "Can't access specified message sender chat"));
+    return promise.set_error(400, "Can't access specified message sender chat");
   }
 
   td_->dialog_action_manager_->cancel_send_dialog_action_queries(dialog_id);
@@ -21912,7 +21908,7 @@ void MessagesManager::on_media_message_ready_to_send(DialogId dialog_id, Message
     return;
   }
   if (it->second) {
-    return promise.set_error(Status::Error(500, "Duplicate promise"));
+    return promise.set_error(500, "Duplicate promise");
   }
   it->second = std::move(promise);
 
@@ -21947,7 +21943,7 @@ void MessagesManager::on_yet_unsent_media_queue_updated(DialogId dialog_id) {
       LOG(INFO) << "Can send " << MessageFullId{dialog_id, m->message_id};
       promise.set_value(std::move(m));
     } else {
-      promise.set_error(Status::Error(400, "Message not found"));
+      promise.set_error(400, "Message not found");
     }
   }
 }
@@ -22534,11 +22530,11 @@ void MessagesManager::edit_message_text(MessageFullId message_full_id,
                                         tl_object_ptr<td_api::InputMessageContent> &&input_message_content,
                                         Promise<Unit> &&promise) {
   if (input_message_content == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't edit message without new content"));
+    return promise.set_error(400, "Can't edit message without new content");
   }
   int32 new_message_content_type = input_message_content->get_id();
   if (new_message_content_type != td_api::inputMessageText::ID) {
-    return promise.set_error(Status::Error(400, "Input message content type must be InputMessageText"));
+    return promise.set_error(400, "Input message content type must be InputMessageText");
   }
 
   auto dialog_id = message_full_id.get_dialog_id();
@@ -22546,15 +22542,15 @@ void MessagesManager::edit_message_text(MessageFullId message_full_id,
 
   const Message *m = get_message_force(d, message_full_id.get_message_id(), "edit_message_text");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!can_edit_message(dialog_id, m, true)) {
-    return promise.set_error(Status::Error(400, "Message can't be edited"));
+    return promise.set_error(400, "Message can't be edited");
   }
 
   MessageContentType old_message_content_type = m->content->get_type();
   if (old_message_content_type != MessageContentType::Text && old_message_content_type != MessageContentType::Game) {
-    return promise.set_error(Status::Error(400, "There is no text in the message to edit"));
+    return promise.set_error(400, "There is no text in the message to edit");
   }
 
   TRY_RESULT_PROMISE(
@@ -22582,24 +22578,24 @@ void MessagesManager::edit_message_live_location(MessageFullId message_full_id,
 
   const Message *m = get_message_force(d, message_full_id.get_message_id(), "edit_message_live_location");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!can_edit_message(dialog_id, m, true)) {
-    return promise.set_error(Status::Error(400, "Message can't be edited"));
+    return promise.set_error(400, "Message can't be edited");
   }
 
   MessageContentType old_message_content_type = m->content->get_type();
   if (old_message_content_type != MessageContentType::LiveLocation) {
-    return promise.set_error(Status::Error(400, "There is no live location in the message to edit"));
+    return promise.set_error(400, "There is no live location in the message to edit");
   }
   if (m->message_id.is_scheduled()) {
     LOG(ERROR) << "Have " << message_full_id << " with live location";
-    return promise.set_error(Status::Error(400, "Can't edit live location in scheduled message"));
+    return promise.set_error(400, "Can't edit live location in scheduled message");
   }
 
   Location location(input_location);
   if (location.empty() && input_location != nullptr) {
-    return promise.set_error(Status::Error(400, "Invalid location specified"));
+    return promise.set_error(400, "Invalid location specified");
   }
 
   TRY_RESULT_PROMISE(promise, new_reply_markup,
@@ -22632,7 +22628,7 @@ void MessagesManager::cancel_edit_message_media(DialogId dialog_id, Message *m,
   auto promise = std::move(edited_message->promise_);
   delete_edited_message(dialog_id, m->message_id);
   m->edit_generation = 0;
-  promise.set_error(Status::Error(400, error_message));
+  promise.set_error(400, error_message);
 }
 
 void MessagesManager::on_message_media_edited(DialogId dialog_id, MessageId message_id, FileUploadId file_upload_id,
@@ -22751,7 +22747,7 @@ void MessagesManager::edit_message_media(MessageFullId message_full_id,
                                          tl_object_ptr<td_api::InputMessageContent> &&input_message_content,
                                          Promise<Unit> &&promise) {
   if (input_message_content == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't edit message without new content"));
+    return promise.set_error(400, "Can't edit message without new content");
   }
   int32 new_message_content_type = input_message_content->get_id();
   if (new_message_content_type != td_api::inputMessageAnimation::ID &&
@@ -22759,7 +22755,7 @@ void MessagesManager::edit_message_media(MessageFullId message_full_id,
       new_message_content_type != td_api::inputMessageDocument::ID &&
       new_message_content_type != td_api::inputMessagePhoto::ID &&
       new_message_content_type != td_api::inputMessageVideo::ID) {
-    return promise.set_error(Status::Error(400, "Unsupported input message content type"));
+    return promise.set_error(400, "Unsupported input message content type");
   }
 
   auto dialog_id = message_full_id.get_dialog_id();
@@ -22767,16 +22763,16 @@ void MessagesManager::edit_message_media(MessageFullId message_full_id,
 
   Message *m = get_message_force(d, message_full_id.get_message_id(), "edit_message_media");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!can_edit_message_media(dialog_id, m, true)) {
-    return promise.set_error(Status::Error(400, "Message media can't be edited"));
+    return promise.set_error(400, "Message media can't be edited");
   }
   CHECK(m->message_id.is_any_server());
 
   TRY_RESULT_PROMISE(promise, content, process_input_message_content(dialog_id, std::move(input_message_content)));
   if (!content.ttl.is_empty()) {
-    return promise.set_error(Status::Error(400, "Can't enable self-destruction for media"));
+    return promise.set_error(400, "Can't enable self-destruction for media");
   }
 
   if (m->media_album_id != 0) {
@@ -22784,11 +22780,11 @@ void MessagesManager::edit_message_media(MessageFullId message_full_id,
     auto new_content_type = content.content->get_type();
     if (old_message_content_type != new_content_type) {
       if (!is_allowed_media_group_content(new_content_type)) {
-        return promise.set_error(Status::Error(400, "Message content type can't be used in an album"));
+        return promise.set_error(400, "Message content type can't be used in an album");
       }
       if (is_homogenous_media_group_content(old_message_content_type) ||
           is_homogenous_media_group_content(new_content_type)) {
-        return promise.set_error(Status::Error(400, "Can't change media type in the album"));
+        return promise.set_error(400, "Can't change media type in the album");
       }
     }
   }
@@ -22821,14 +22817,14 @@ void MessagesManager::edit_message_caption(MessageFullId message_full_id,
 
   const Message *m = get_message_force(d, message_full_id.get_message_id(), "edit_message_caption");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!can_edit_message(dialog_id, m, true)) {
-    return promise.set_error(Status::Error(400, "Message can't be edited"));
+    return promise.set_error(400, "Message can't be edited");
   }
 
   if (!can_have_message_content_caption(m->content->get_type())) {
-    return promise.set_error(Status::Error(400, "There is no caption in the message to edit"));
+    return promise.set_error(400, "There is no caption in the message to edit");
   }
   if (invert_media && !is_allowed_invert_caption_message_content(m->content->get_type())) {
     invert_media = false;
@@ -22858,10 +22854,10 @@ void MessagesManager::edit_message_reply_markup(MessageFullId message_full_id,
 
   const Message *m = get_message_force(d, message_full_id.get_message_id(), "edit_message_reply_markup");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!can_edit_message(dialog_id, m, true, true)) {
-    return promise.set_error(Status::Error(400, "Message can't be edited"));
+    return promise.set_error(400, "Message can't be edited");
   }
 
   TRY_RESULT_PROMISE(promise, new_reply_markup,
@@ -22885,10 +22881,10 @@ void MessagesManager::edit_message_scheduling_state(
 
   Message *m = get_message_force(d, message_full_id.get_message_id(), "edit_message_scheduling_state");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!can_edit_message_scheduling_state(m) || (m->video_processing_pending && schedule_date > 0)) {
-    return promise.set_error(Status::Error(400, "Can't reschedule the message"));
+    return promise.set_error(400, "Can't reschedule the message");
   }
 
   if (get_message_schedule_date(m) == schedule_date) {
@@ -22913,10 +22909,10 @@ void MessagesManager::set_message_fact_check(MessageFullId message_full_id,
 
   const Message *m = get_message_force(d, message_full_id.get_message_id(), "set_message_fact_check");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!can_set_message_fact_check(dialog_id, m)) {
-    return promise.set_error(Status::Error(400, "Message fact-check can't be changed for the message"));
+    return promise.set_error(400, "Message fact-check can't be changed for the message");
   }
 
   TRY_RESULT_PROMISE(promise, fact_check_text,
@@ -24322,24 +24318,24 @@ void MessagesManager::share_dialogs_with_bot(MessageFullId message_full_id, int3
                                              Promise<Unit> &&promise) {
   const Message *m = get_message_force(message_full_id, "share_dialog_with_bot");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (m->reply_markup == nullptr) {
-    return promise.set_error(Status::Error(400, "Message has no buttons"));
+    return promise.set_error(400, "Message has no buttons");
   }
   CHECK(m->message_id.is_valid() && m->message_id.is_server());
   TRY_STATUS_PROMISE(promise, m->reply_markup->check_shared_dialog_count(button_id, shared_dialog_ids.size()));
   for (auto shared_dialog_id : shared_dialog_ids) {
     if (shared_dialog_id.get_type() != DialogType::User) {
       if (!have_dialog_force(shared_dialog_id, "share_dialogs_with_bot")) {
-        return promise.set_error(Status::Error(400, "Shared chat not found"));
+        return promise.set_error(400, "Shared chat not found");
       }
     } else {
       if (!expect_user) {
-        return promise.set_error(Status::Error(400, "Wrong chat type"));
+        return promise.set_error(400, "Wrong chat type");
       }
       if (!td_->user_manager_->have_user(shared_dialog_id.get_user_id())) {
-        return promise.set_error(Status::Error(400, "Shared user not found"));
+        return promise.set_error(400, "Shared user not found");
       }
     }
     TRY_STATUS_PROMISE(promise, m->reply_markup->check_shared_dialog(td_, button_id, shared_dialog_id));
@@ -24498,7 +24494,7 @@ void MessagesManager::wait_message_add(MessageFullId message_full_id, Promise<Un
       return promise.set_value(Unit());
     }
     if (is_deleted_message(d, message_id)) {
-      return promise.set_error(Status::Error(400, "The message was deleted"));
+      return promise.set_error(400, "The message was deleted");
     }
   }
   awaited_message_full_ids_[message_full_id].push_back(std::move(promise));
@@ -25105,10 +25101,10 @@ void MessagesManager::get_message_notifications_from_database(DialogId dialog_id
                                                               MessageId from_message_id, int32 limit,
                                                               Promise<vector<Notification>> promise) {
   if (!G()->use_message_database()) {
-    return promise.set_error(Status::Error(500, "There is no message database"));
+    return promise.set_error(500, "There is no message database");
   }
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(500, "Bots have no notifications"));
+    return promise.set_error(500, "Bots have no notifications");
   }
 
   CHECK(dialog_id.is_valid());
@@ -25201,7 +25197,7 @@ void MessagesManager::on_get_message_notifications_from_database(DialogId dialog
 
   auto &group_info = get_notification_group_info(d, from_mentions);
   if (!group_info.is_valid()) {
-    return promise.set_error(Status::Error("Notification group was deleted"));
+    return promise.set_error("Notification group was deleted");
   }
 
   auto messages = result.move_as_ok();
@@ -28130,8 +28126,8 @@ void MessagesManager::on_create_new_dialog(telegram_api::object_ptr<telegram_api
   LOG(INFO) << "Receive result for creating of a chat: " << to_string(updates);
 
   auto fail = [&](Slice message) {
-    chat_promise.set_error(Status::Error(500, message));
-    channel_promise.set_error(Status::Error(500, message));
+    chat_promise.set_error(500, message);
+    channel_promise.set_error(500, message);
   };
   auto sent_messages = UpdatesManager::get_new_messages(updates.get());
   auto sent_messages_random_ids = UpdatesManager::get_sent_messages_random_ids(updates.get());
@@ -28442,13 +28438,13 @@ void MessagesManager::send_get_dialog_query(DialogId dialog_id, Promise<Unit> &&
     if (log_event_id != 0) {
       binlog_erase(G()->td_db()->get_binlog(), log_event_id);
     }
-    return promise.set_error(Status::Error(500, "Wrong getDialog query"));
+    return promise.set_error(500, "Wrong getDialog query");
   }
   if (!td_->dialog_manager_->have_input_peer(dialog_id, false, AccessRights::Read)) {
     if (log_event_id != 0) {
       binlog_erase(G()->td_db()->get_binlog(), log_event_id);
     }
-    return promise.set_error(Status::Error(400, "Can't access the chat"));
+    return promise.set_error(400, "Can't access the chat");
   }
 
   auto &promises = get_dialog_queries_[dialog_id];
@@ -28956,11 +28952,11 @@ void MessagesManager::add_dialog_to_list(DialogId dialog_id, DialogListId dialog
   TRY_RESULT_PROMISE(promise, d, check_dialog_access(dialog_id, true, AccessRights::Read, "add_dialog_to_list"));
 
   if (d->order == DEFAULT_ORDER) {
-    return promise.set_error(Status::Error(400, "Chat is not in a chat list"));
+    return promise.set_error(400, "Chat is not in a chat list");
   }
 
   if (get_dialog_list(dialog_list_id) == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat list not found"));
+    return promise.set_error(400, "Chat list not found");
   }
 
   if (dialog_list_id.is_filter()) {
@@ -28976,7 +28972,7 @@ void MessagesManager::add_dialog_to_list(DialogId dialog_id, DialogListId dialog
 
   if (folder_id == FolderId::archive() && (dialog_id == td_->dialog_manager_->get_my_dialog_id() ||
                                            dialog_id == DialogId(UserManager::get_service_notifications_user_id()))) {
-    return promise.set_error(Status::Error(400, "Chat can't be archived"));
+    return promise.set_error(400, "Chat can't be archived");
   }
 
   set_dialog_folder_id(d, folder_id);
@@ -29047,26 +29043,26 @@ void MessagesManager::set_dialog_available_reactions(
                                     !td_->dialog_manager_->is_broadcast_channel(dialog_id));
   auto active_reactions = get_active_reactions(available_reactions);
   if (active_reactions.reaction_types_.size() != available_reactions.reaction_types_.size()) {
-    return promise.set_error(Status::Error(400, "Invalid reactions specified"));
+    return promise.set_error(400, "Invalid reactions specified");
   }
   available_reactions = std::move(active_reactions);
 
   switch (dialog_id.get_type()) {
     case DialogType::User:
-      return promise.set_error(Status::Error(400, "Can't change private chat available reactions"));
+      return promise.set_error(400, "Can't change private chat available reactions");
     case DialogType::Chat: {
       auto chat_id = dialog_id.get_chat_id();
       auto status = td_->chat_manager_->get_chat_permissions(chat_id);
       if (!status.can_change_info_and_settings() ||
           (td_->auth_manager_->is_bot() && !td_->chat_manager_->is_appointed_chat_administrator(chat_id))) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change chat available reactions"));
+        return promise.set_error(400, "Not enough rights to change chat available reactions");
       }
       break;
     }
     case DialogType::Channel: {
       auto status = td_->chat_manager_->get_channel_permissions(dialog_id.get_channel_id());
       if (!status.can_change_info_and_settings()) {
-        return promise.set_error(Status::Error(400, "Not enough rights to change chat available reactions"));
+        return promise.set_error(400, "Not enough rights to change chat available reactions");
       }
       break;
     }
@@ -29089,7 +29085,7 @@ void MessagesManager::set_dialog_available_reactions(
 
 void MessagesManager::set_dialog_message_ttl(DialogId dialog_id, int32 ttl, Promise<Unit> &&promise) {
   if (ttl < 0) {
-    return promise.set_error(Status::Error(400, "Message auto-delete time can't be negative"));
+    return promise.set_error(400, "Message auto-delete time can't be negative");
   }
 
   TRY_RESULT_PROMISE(promise, d, check_dialog_access(dialog_id, true, AccessRights::Write, "set_dialog_message_ttl"));
@@ -29098,23 +29094,21 @@ void MessagesManager::set_dialog_message_ttl(DialogId dialog_id, int32 ttl, Prom
     case DialogType::User:
       if (dialog_id == td_->dialog_manager_->get_my_dialog_id() ||
           dialog_id == DialogId(UserManager::get_service_notifications_user_id())) {
-        return promise.set_error(Status::Error(400, "Message auto-delete time in the chat can't be changed"));
+        return promise.set_error(400, "Message auto-delete time in the chat can't be changed");
       }
       break;
     case DialogType::Chat: {
       auto chat_id = dialog_id.get_chat_id();
       auto status = td_->chat_manager_->get_chat_permissions(chat_id);
       if (!status.can_change_info_and_settings()) {
-        return promise.set_error(
-            Status::Error(400, "Not enough rights to change message auto-delete time in the chat"));
+        return promise.set_error(400, "Not enough rights to change message auto-delete time in the chat");
       }
       break;
     }
     case DialogType::Channel: {
       auto status = td_->chat_manager_->get_channel_permissions(dialog_id.get_channel_id());
       if (!status.can_change_info_and_settings()) {
-        return promise.set_error(
-            Status::Error(400, "Not enough rights to change message auto-delete time in the chat"));
+        return promise.set_error(400, "Not enough rights to change message auto-delete time in the chat");
       }
       break;
     }
@@ -29153,11 +29147,11 @@ void MessagesManager::set_dialog_theme(DialogId dialog_id, const string &theme_n
       break;
     case DialogType::Chat:
     case DialogType::Channel:
-      return promise.set_error(Status::Error(400, "Can't change theme in the chat"));
+      return promise.set_error(400, "Can't change theme in the chat");
     case DialogType::SecretChat: {
       auto user_id = td_->user_manager_->get_secret_chat_user_id(dialog_id.get_secret_chat_id());
       if (!user_id.is_valid()) {
-        return promise.set_error(Status::Error(400, "Can't access the user"));
+        return promise.set_error(400, "Can't access the user");
       }
       dialog_id = DialogId(user_id);
       break;
@@ -29185,14 +29179,14 @@ void MessagesManager::pin_dialog_message(BusinessConnectionId business_connectio
   } else {
     auto d = get_dialog_force(dialog_id, "pin_dialog_message");
     if (d == nullptr) {
-      return promise.set_error(Status::Error(400, "Chat not found"));
+      return promise.set_error(400, "Chat not found");
     }
     const Message *m = get_message_force(d, message_id, "pin_dialog_message");
     TRY_STATUS_PROMISE(promise, can_pin_message(dialog_id, m));
   }
 
   if (only_for_self && dialog_id.get_type() != DialogType::User) {
-    return promise.set_error(Status::Error(400, "Messages can't be pinned only for self in the chat"));
+    return promise.set_error(400, "Messages can't be pinned only for self in the chat");
   }
 
   // TODO log event
@@ -35134,19 +35128,19 @@ void MessagesManager::set_poll_answer(MessageFullId message_full_id, vector<int3
                                       Promise<Unit> &&promise) {
   auto m = get_message_force(message_full_id, "set_poll_answer");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!td_->dialog_manager_->have_input_peer(message_full_id.get_dialog_id(), true, AccessRights::Read)) {
-    return promise.set_error(Status::Error(400, "Can't access the chat"));
+    return promise.set_error(400, "Can't access the chat");
   }
   if (m->content->get_type() != MessageContentType::Poll) {
-    return promise.set_error(Status::Error(400, "Message is not a poll"));
+    return promise.set_error(400, "Message is not a poll");
   }
   if (m->message_id.is_scheduled()) {
-    return promise.set_error(Status::Error(400, "Can't answer polls from scheduled messages"));
+    return promise.set_error(400, "Can't answer polls from scheduled messages");
   }
   if (!m->message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Poll can't be answered"));
+    return promise.set_error(400, "Poll can't be answered");
   }
 
   set_message_content_poll_answer(td_, m->content.get(), message_full_id, std::move(option_ids), std::move(promise));
@@ -35156,19 +35150,19 @@ void MessagesManager::get_poll_voters(MessageFullId message_full_id, int32 optio
                                       Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
   auto m = get_message_force(message_full_id, "get_poll_voters");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!td_->dialog_manager_->have_input_peer(message_full_id.get_dialog_id(), true, AccessRights::Read)) {
-    return promise.set_error(Status::Error(400, "Can't access the chat"));
+    return promise.set_error(400, "Can't access the chat");
   }
   if (m->content->get_type() != MessageContentType::Poll) {
-    return promise.set_error(Status::Error(400, "Message is not a poll"));
+    return promise.set_error(400, "Message is not a poll");
   }
   if (m->message_id.is_scheduled()) {
-    return promise.set_error(Status::Error(400, "Can't get poll results from scheduled messages"));
+    return promise.set_error(400, "Can't get poll results from scheduled messages");
   }
   if (!m->message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Poll results can't be received"));
+    return promise.set_error(400, "Poll results can't be received");
   }
 
   get_message_content_poll_voters(td_, m->content.get(), message_full_id, option_id, offset, limit, std::move(promise));
@@ -35178,25 +35172,25 @@ void MessagesManager::stop_poll(MessageFullId message_full_id, td_api::object_pt
                                 Promise<Unit> &&promise) {
   auto m = get_message_force(message_full_id, "stop_poll");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!td_->dialog_manager_->have_input_peer(message_full_id.get_dialog_id(), true, AccessRights::Read)) {
-    return promise.set_error(Status::Error(400, "Can't access the chat"));
+    return promise.set_error(400, "Can't access the chat");
   }
   if (m->content->get_type() != MessageContentType::Poll) {
-    return promise.set_error(Status::Error(400, "Message is not a poll"));
+    return promise.set_error(400, "Message is not a poll");
   }
   if (get_message_content_poll_is_closed(td_, m->content.get())) {
-    return promise.set_error(Status::Error(400, "Poll has already been closed"));
+    return promise.set_error(400, "Poll has already been closed");
   }
   if (!can_edit_message(message_full_id.get_dialog_id(), m, true)) {
-    return promise.set_error(Status::Error(400, "Poll can't be stopped"));
+    return promise.set_error(400, "Poll can't be stopped");
   }
   if (m->message_id.is_scheduled()) {
-    return promise.set_error(Status::Error(400, "Can't stop polls from scheduled messages"));
+    return promise.set_error(400, "Can't stop polls from scheduled messages");
   }
   if (!m->message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Poll can't be stopped"));
+    return promise.set_error(400, "Poll can't be stopped");
   }
 
   TRY_RESULT_PROMISE(promise, new_reply_markup,
@@ -35216,7 +35210,7 @@ void MessagesManager::finish_gift_upgrade(MessageFullId message_full_id,
                                           Promise<td_api::object_ptr<td_api::upgradeGiftResult>> &&promise) {
   auto m = get_message_force(message_full_id, "finish_gift_upgrade");
   if (m == nullptr || m->content->get_type() != MessageContentType::StarGiftUnique) {
-    return promise.set_error(Status::Error(500, "Gift not found"));
+    return promise.set_error(500, "Gift not found");
   }
   promise.set_value(get_message_content_upgrade_gift_result_object(m->content.get(), td_,
                                                                    message_full_id.get_dialog_id(), m->message_id));
@@ -35480,11 +35474,11 @@ void MessagesManager::add_message_file_to_downloads(MessageFullId message_full_i
   TRY_STATUS_PROMISE(promise, FileManager::check_priority(priority));
   auto m = get_message_force(message_full_id, "add_message_file_to_downloads");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   auto file_view = td_->file_manager_->get_file_view(file_id);
   if (file_view.empty()) {
-    return promise.set_error(Status::Error(400, "File not found"));
+    return promise.set_error(400, "File not found");
   }
   file_id = file_view.get_main_file_id();
   bool is_found = false;
@@ -35496,10 +35490,10 @@ void MessagesManager::add_message_file_to_downloads(MessageFullId message_full_i
     }
   }
   if (!is_found) {
-    return promise.set_error(Status::Error(400, "Message has no specified file"));
+    return promise.set_error(400, "Message has no specified file");
   }
   if (m->message_id.is_yet_unsent()) {
-    return promise.set_error(Status::Error(400, "Yet unsent messages can't be added to Downloads"));
+    return promise.set_error(400, "Yet unsent messages can't be added to Downloads");
   }
   auto search_text = get_message_search_text(m);
   auto file_source_id = get_message_file_source_id(message_full_id, true);
@@ -35512,7 +35506,7 @@ void MessagesManager::get_message_file_search_text(MessageFullId message_full_id
                                                    Promise<string> promise) {
   auto m = get_message_force(message_full_id, "get_message_file_search_text");
   if (m == nullptr) {
-    return promise.set_error(Status::Error(200, "Message not found"));
+    return promise.set_error(200, "Message not found");
   }
   for (auto file_id : get_message_file_ids(m)) {
     auto file_view = td_->file_manager_->get_file_view(file_id);
@@ -35521,7 +35515,7 @@ void MessagesManager::get_message_file_search_text(MessageFullId message_full_id
       return promise.set_value(get_message_search_text(m));
     }
   }
-  return promise.set_error(Status::Error(200, "File not found"));
+  return promise.set_error(200, "File not found");
 }
 
 }  // namespace td
diff --git a/td/telegram/NotificationManager.cpp b/td/telegram/NotificationManager.cpp
index 4218f7d28..ea54c0720 100644
--- a/td/telegram/NotificationManager.cpp
+++ b/td/telegram/NotificationManager.cpp
@@ -1866,10 +1866,10 @@ void NotificationManager::remove_notification(NotificationGroupId group_id, Noti
                                               bool is_permanent, bool force_update, Promise<Unit> &&promise,
                                               const char *source) {
   if (!group_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Notification group identifier is invalid"));
+    return promise.set_error(400, "Notification group identifier is invalid");
   }
   if (!notification_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Notification identifier is invalid"));
+    return promise.set_error(400, "Notification identifier is invalid");
   }
 
   if (is_disabled() || max_notification_group_count_ == 0) {
@@ -2010,10 +2010,10 @@ void NotificationManager::remove_notification_group(NotificationGroupId group_id
                                                     NotificationObjectId max_object_id, int32 new_total_count,
                                                     bool force_update, Promise<Unit> &&promise) {
   if (!group_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Group identifier is invalid"));
+    return promise.set_error(400, "Group identifier is invalid");
   }
   if (!max_notification_id.is_valid() && !max_object_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Notification identifier is invalid"));
+    return promise.set_error(400, "Notification identifier is invalid");
   }
 
   if (is_disabled() || max_notification_group_count_ == 0) {
@@ -2757,7 +2757,7 @@ void NotificationManager::process_push_notification(string payload, Promise<Unit
   });
 
   if (is_disabled() || payload == "{}") {
-    return promise.set_error(Status::Error(200, "Immediate success"));
+    return promise.set_error(200, "Immediate success");
   }
 
   auto r_receiver_id = get_push_receiver_id(payload);
@@ -2781,7 +2781,7 @@ void NotificationManager::process_push_notification(string payload, Promise<Unit
         auto r_payload = decrypt_push(key.first, key.second.str(), std::move(payload));
         if (r_payload.is_error()) {
           LOG(ERROR) << "Failed to decrypt push: " << r_payload.error();
-          return promise.set_error(Status::Error(400, "Failed to decrypt push payload"));
+          return promise.set_error(400, "Failed to decrypt push payload");
         }
         payload = r_payload.move_as_ok();
         was_encrypted = true;
@@ -2804,14 +2804,14 @@ void NotificationManager::process_push_notification(string payload, Promise<Unit
       }
 
       LOG(ERROR) << "Receive error " << status << ", while parsing push payload " << payload;
-      return promise.set_error(Status::Error(400, status.message()));
+      return promise.set_error(400, status.message());
     }
     // promise will be set after updateNotificationGroup is sent to the client
     return;
   }
 
   VLOG(notifications) << "Failed to process push notification";
-  promise.set_error(Status::Error(200, "Immediate success"));
+  promise.set_error(200, "Immediate success");
 }
 
 string NotificationManager::convert_loc_key(const string &loc_key) {
@@ -3688,7 +3688,7 @@ void NotificationManager::add_message_push_notification(DialogId dialog_id, Mess
     if (r_info.error().code() == 406) {
       promise.set_error(r_info.move_as_error());
     } else {
-      promise.set_error(Status::Error(200, "Immediate success"));
+      promise.set_error(200, "Immediate success");
     }
     return;
   }
@@ -3702,13 +3702,13 @@ void NotificationManager::add_message_push_notification(DialogId dialog_id, Mess
     // main problem: there is no message_id yet
     // also don't forget to delete newSecretChat notification
     CHECK(log_event_id == 0);
-    return promise.set_error(Status::Error(406, "Secret chat push notifications are unsupported"));
+    return promise.set_error(406, "Secret chat push notifications are unsupported");
   }
   CHECK(random_id == 0);
 
   if (is_disabled() || max_notification_group_count_ == 0) {
     CHECK(log_event_id == 0);
-    return promise.set_error(Status::Error(200, "Immediate success"));
+    return promise.set_error(200, "Immediate success");
   }
 
   if (!notification_id.is_valid()) {
@@ -3850,14 +3850,14 @@ void NotificationManager::edit_message_push_notification(DialogId dialog_id, Mes
                                                          uint64 log_event_id, Promise<Unit> promise) {
   if (is_disabled() || max_notification_group_count_ == 0) {
     CHECK(log_event_id == 0);
-    return promise.set_error(Status::Error(200, "Immediate success"));
+    return promise.set_error(200, "Immediate success");
   }
 
   auto it = temporary_notifications_.find({dialog_id, message_id});
   if (it == temporary_notifications_.end()) {
     VLOG(notifications) << "Ignore edit of message push notification for " << message_id << " in " << dialog_id
                         << " edited at " << edit_date;
-    return promise.set_error(Status::Error(200, "Immediate success"));
+    return promise.set_error(200, "Immediate success");
   }
 
   auto group_id = it->second.group_id;
diff --git a/td/telegram/NotificationSettingsManager.cpp b/td/telegram/NotificationSettingsManager.cpp
index 90672bbf9..5a16a61d9 100644
--- a/td/telegram/NotificationSettingsManager.cpp
+++ b/td/telegram/NotificationSettingsManager.cpp
@@ -139,7 +139,7 @@ class SaveRingtoneQuery final : public Td::ResultHandler {
           file_id_, PromiseCreator::lambda([ringtone_id = file_id_, unsave = unsave_,
                                             promise = std::move(promise_)](Result<Unit> result) mutable {
             if (result.is_error()) {
-              return promise.set_error(Status::Error(400, "Failed to find the ringtone"));
+              return promise.set_error(400, "Failed to find the ringtone");
             }
 
             send_closure(G()->notification_settings_manager(), &NotificationSettingsManager::send_save_ringtone_query,
@@ -891,7 +891,7 @@ bool NotificationSettingsManager::update_scope_notification_settings(Notificatio
 void NotificationSettingsManager::send_get_reaction_notification_settings_query(Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
     LOG(ERROR) << "Can't get reaction notification settings";
-    return promise.set_error(Status::Error(500, "Wrong getReactionNotificationSettings query"));
+    return promise.set_error(500, "Wrong getReactionNotificationSettings query");
   }
 
   td_->create_handler<GetReactionsNotifySettingsQuery>(std::move(promise))->send();
@@ -1047,7 +1047,7 @@ void NotificationSettingsManager::add_saved_ringtone(td_api::object_ptr<td_api::
   auto file_view = td_->file_manager_->get_file_view(file_id);
   CHECK(!file_view.empty());
   if (file_view.size() > td_->option_manager_->get_option_integer("notification_sound_size_max")) {
-    return promise.set_error(Status::Error(400, "Notification sound file is too big"));
+    return promise.set_error(400, "Notification sound file is too big");
   }
   auto file_type = file_view.get_type();
   int32 duration = 0;
@@ -1062,19 +1062,19 @@ void NotificationSettingsManager::add_saved_ringtone(td_api::object_ptr<td_api::
       break;
   }
   if (duration > td_->option_manager_->get_option_integer("notification_sound_duration_max")) {
-    return promise.set_error(Status::Error(400, "Notification sound is too long"));
+    return promise.set_error(400, "Notification sound is too long");
   }
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (main_remote_location != nullptr && !file_view.is_encrypted()) {
     CHECK(main_remote_location->is_document());
     if (main_remote_location->is_web()) {
-      return promise.set_error(Status::Error(400, "Can't use web document as notification sound"));
+      return promise.set_error(400, "Can't use web document as notification sound");
     }
 
     FileId ringtone_file_id = file_view.get_main_file_id();
     if (file_type != FileType::Ringtone) {
       if (file_type != FileType::Audio && file_type != FileType::VoiceNote) {
-        return promise.set_error(Status::Error(400, "Unsupported file specified"));
+        return promise.set_error(400, "Unsupported file specified");
       }
       auto &remote = *main_remote_location;
       ringtone_file_id = td_->file_manager_->register_remote(
@@ -1140,10 +1140,10 @@ void NotificationSettingsManager::on_upload_ringtone(FileUploadId file_upload_id
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (input_file == nullptr && main_remote_location != nullptr) {
     if (main_remote_location->is_web()) {
-      return promise.set_error(Status::Error(400, "Can't use web document as notification sound"));
+      return promise.set_error(400, "Can't use web document as notification sound");
     }
     if (is_reupload) {
-      return promise.set_error(Status::Error(400, "Failed to reupload the file"));
+      return promise.set_error(400, "Failed to reupload the file");
     }
 
     auto main_file_id = file_view.get_main_file_id();
@@ -1225,7 +1225,7 @@ void NotificationSettingsManager::on_add_saved_ringtone(
       }
     }
     if (saved_ringtone == nullptr) {
-      return promise.set_error(Status::Error(500, "Failed to find saved notification sound"));
+      return promise.set_error(500, "Failed to find saved notification sound");
     }
   }
 
@@ -1359,7 +1359,7 @@ void NotificationSettingsManager::on_load_saved_ringtones(Promise<Unit> &&promis
 
 void NotificationSettingsManager::reload_saved_ringtones(Promise<Unit> &&promise) {
   if (!is_active()) {
-    return promise.set_error(Status::Error(400, "Don't need to reload saved notification sounds"));
+    return promise.set_error(400, "Don't need to reload saved notification sounds");
   }
   reload_saved_ringtones_queries_.push_back(std::move(promise));
   if (reload_saved_ringtones_queries_.size() == 1) {
@@ -1374,7 +1374,7 @@ void NotificationSettingsManager::reload_saved_ringtones(Promise<Unit> &&promise
 
 void NotificationSettingsManager::repair_saved_ringtones(Promise<Unit> &&promise) {
   if (!is_active()) {
-    return promise.set_error(Status::Error(400, "Don't need to repair saved notification sounds"));
+    return promise.set_error(400, "Don't need to repair saved notification sounds");
   }
 
   repair_saved_ringtones_queries_.push_back(std::move(promise));
@@ -1507,7 +1507,7 @@ void NotificationSettingsManager::send_get_dialog_notification_settings_query(Di
                                                                               Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
     LOG(ERROR) << "Can't get notification settings for " << dialog_id;
-    return promise.set_error(Status::Error(500, "Wrong getDialogNotificationSettings query"));
+    return promise.set_error(500, "Wrong getDialogNotificationSettings query");
   }
   TRY_STATUS_PROMISE(promise,
                      td_->dialog_manager_->check_dialog_access_in_memory(dialog_id, false, AccessRights::Read));
@@ -1539,7 +1539,7 @@ void NotificationSettingsManager::send_get_scope_notification_settings_query(Not
                                                                              Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
     LOG(ERROR) << "Can't get notification settings for " << scope;
-    return promise.set_error(Status::Error(500, "Wrong getScopeNotificationSettings query"));
+    return promise.set_error(500, "Wrong getScopeNotificationSettings query");
   }
 
   td_->create_handler<GetScopeNotifySettingsQuery>(std::move(promise))->send(scope);
diff --git a/td/telegram/OptionManager.cpp b/td/telegram/OptionManager.cpp
index b72947777..32cf87fb0 100644
--- a/td/telegram/OptionManager.cpp
+++ b/td/telegram/OptionManager.cpp
@@ -752,15 +752,14 @@ void OptionManager::set_option(const string &name, td_api::object_ptr<td_api::Op
       set_option_empty(option_name);
     } else {
       if (value_constructor_id != td_api::optionValueInteger::ID) {
-        promise.set_error(Status::Error(400, PSLICE() << "Option \"" << name << "\" must have integer value"));
+        promise.set_error(400, PSLICE() << "Option \"" << name << "\" must have integer value");
         return false;
       }
 
       int64 int_value = static_cast<td_api::optionValueInteger *>(value.get())->value_;
       if (int_value < min_value || int_value > max_value) {
-        promise.set_error(Status::Error(400, PSLICE() << "Option's \"" << name << "\" value " << int_value
-                                                      << " is outside of the valid range [" << min_value << ", "
-                                                      << max_value << "]"));
+        promise.set_error(400, PSLICE() << "Option's \"" << name << "\" value " << int_value
+                                        << " is outside of the valid range [" << min_value << ", " << max_value << "]");
         return false;
       }
       set_option_integer(name, int_value);
@@ -777,7 +776,7 @@ void OptionManager::set_option(const string &name, td_api::object_ptr<td_api::Op
       set_option_empty(name);
     } else {
       if (value_constructor_id != td_api::optionValueBoolean::ID) {
-        promise.set_error(Status::Error(400, PSLICE() << "Option \"" << name << "\" must have boolean value"));
+        promise.set_error(400, PSLICE() << "Option \"" << name << "\" must have boolean value");
         return false;
       }
 
@@ -796,7 +795,7 @@ void OptionManager::set_option(const string &name, td_api::object_ptr<td_api::Op
       set_option_empty(name);
     } else {
       if (value_constructor_id != td_api::optionValueString::ID) {
-        promise.set_error(Status::Error(400, PSLICE() << "Option \"" << name << "\" must have string value"));
+        promise.set_error(400, PSLICE() << "Option \"" << name << "\" must have string value");
         return false;
       }
 
@@ -807,7 +806,7 @@ void OptionManager::set_option(const string &name, td_api::object_ptr<td_api::Op
         if (check_value(str_value)) {
           set_option_string(name, str_value);
         } else {
-          promise.set_error(Status::Error(400, PSLICE() << "Option \"" << name << "\" can't have specified value"));
+          promise.set_error(400, PSLICE() << "Option \"" << name << "\" can't have specified value");
           return false;
         }
       }
@@ -890,14 +889,13 @@ void OptionManager::set_option(const string &name, td_api::object_ptr<td_api::Op
       }
       if (!is_bot && name == "ignore_sensitive_content_restrictions") {
         if (!get_option_boolean("can_ignore_sensitive_content_restrictions")) {
-          return promise.set_error(
-              Status::Error(400, "Option \"ignore_sensitive_content_restrictions\" can't be changed by the user"));
+          return promise.set_error(400,
+                                   "Option \"ignore_sensitive_content_restrictions\" can't be changed by the user");
         }
 
         if (value_constructor_id != td_api::optionValueBoolean::ID &&
             value_constructor_id != td_api::optionValueEmpty::ID) {
-          return promise.set_error(
-              Status::Error(400, "Option \"ignore_sensitive_content_restrictions\" must have boolean value"));
+          return promise.set_error(400, "Option \"ignore_sensitive_content_restrictions\" must have boolean value");
         }
 
         auto ignore_sensitive_content_restrictions = value_constructor_id == td_api::optionValueBoolean::ID &&
@@ -939,7 +937,7 @@ void OptionManager::set_option(const string &name, td_api::object_ptr<td_api::Op
       if (name == "online") {
         if (value_constructor_id != td_api::optionValueBoolean::ID &&
             value_constructor_id != td_api::optionValueEmpty::ID) {
-          return promise.set_error(Status::Error(400, "Option \"online\" must have boolean value"));
+          return promise.set_error(400, "Option \"online\" must have boolean value");
         }
         bool is_online = value_constructor_id == td_api::optionValueEmpty::ID ||
                          static_cast<const td_api::optionValueBoolean *>(value.get())->value_;
@@ -1004,7 +1002,7 @@ void OptionManager::set_option(const string &name, td_api::object_ptr<td_api::Op
     case 'X':
     case 'x': {
       if (name.size() > 255) {
-        return promise.set_error(Status::Error(400, "Option name is too long"));
+        return promise.set_error(400, "Option name is too long");
       }
       switch (value_constructor_id) {
         case td_api::optionValueBoolean::ID:
@@ -1027,7 +1025,7 @@ void OptionManager::set_option(const string &name, td_api::object_ptr<td_api::Op
   }
 
   if (promise) {
-    promise.set_error(Status::Error(400, "Option can't be set"));
+    promise.set_error(400, "Option can't be set");
   }
 }
 
diff --git a/td/telegram/PasswordManager.cpp b/td/telegram/PasswordManager.cpp
index bdf0d78a0..cf5bee117 100644
--- a/td/telegram/PasswordManager.cpp
+++ b/td/telegram/PasswordManager.cpp
@@ -196,17 +196,17 @@ void PasswordManager::set_login_email_address(string new_login_email_address, Pr
 
 void PasswordManager::resend_login_email_address_code(Promise<SentEmailCode> promise) {
   if (last_set_login_email_address_.empty()) {
-    return promise.set_error(Status::Error(400, "No login email address code was sent"));
+    return promise.set_error(400, "No login email address code was sent");
   }
   set_login_email_address(last_set_login_email_address_, std::move(promise));
 }
 
 void PasswordManager::check_login_email_address_code(EmailVerification &&code, Promise<Unit> promise) {
   if (last_set_login_email_address_.empty()) {
-    return promise.set_error(Status::Error(400, "No login email address code was sent"));
+    return promise.set_error(400, "No login email address code was sent");
   }
   if (code.is_empty()) {
-    return promise.set_error(Status::Error(400, "Verification code must be non-empty"));
+    return promise.set_error(400, "Verification code must be non-empty");
   }
   auto query = G()->net_query_creator().create(telegram_api::account_verifyEmail(
       make_tl_object<telegram_api::emailVerifyPurposeLoginChange>(), code.get_input_email_verification()));
@@ -237,7 +237,7 @@ void PasswordManager::do_get_secure_secret(bool allow_recursive, string password
     return promise.set_value(secret_.value().clone());
   }
   if (password.empty()) {
-    return promise.set_error(Status::Error(400, "PASSWORD_HASH_INVALID"));
+    return promise.set_error(400, "PASSWORD_HASH_INVALID");
   }
   get_full_state(
       password, PromiseCreator::lambda([actor_id = actor_id(this), password, allow_recursive,
@@ -247,14 +247,14 @@ void PasswordManager::do_get_secure_secret(bool allow_recursive, string password
         }
         auto state = r_state.move_as_ok();
         if (!state.state.has_password) {
-          return promise.set_error(Status::Error(400, "2-step verification is disabled"));
+          return promise.set_error(400, "2-step verification is disabled");
         }
         if (state.private_state.secret) {
           send_closure(actor_id, &PasswordManager::cache_secret, state.private_state.secret.value().clone());
           return promise.set_value(std::move(state.private_state.secret.value()));
         }
         if (!allow_recursive) {
-          return promise.set_error(Status::Error(400, "Failed to get Telegram Passport secret"));
+          return promise.set_error(400, "Failed to get Telegram Passport secret");
         }
 
         auto new_promise =
@@ -290,7 +290,7 @@ TempPasswordState PasswordManager::get_temp_password_state_sync() {
 
 void PasswordManager::create_temp_password(string password, int32 timeout, Promise<TempState> promise) {
   if (create_temp_password_promise_) {
-    return promise.set_error(Status::Error(400, "Another create_temp_password query is active"));
+    return promise.set_error(400, "Another create_temp_password query is active");
   }
   create_temp_password_promise_ = std::move(promise);
 
@@ -480,14 +480,14 @@ void PasswordManager::send_email_address_verification_code(string email, Promise
 
 void PasswordManager::resend_email_address_verification_code(Promise<SentEmailCode> promise) {
   if (last_verified_email_address_.empty()) {
-    return promise.set_error(Status::Error(400, "No email address verification was sent"));
+    return promise.set_error(400, "No email address verification was sent");
   }
   send_email_address_verification_code(last_verified_email_address_, std::move(promise));
 }
 
 void PasswordManager::check_email_address_verification_code(string code, Promise<Unit> promise) {
   if (last_verified_email_address_.empty()) {
-    return promise.set_error(Status::Error(400, "No email address verification was sent"));
+    return promise.set_error(400, "No email address verification was sent");
   }
   auto verification_code = make_tl_object<telegram_api::emailVerificationCode>(std::move(code));
   auto query = G()->net_query_creator().create(telegram_api::account_verifyEmail(
@@ -516,7 +516,7 @@ void PasswordManager::check_password_recovery_code(string code, Promise<Unit> pr
                       TRY_RESULT_PROMISE(promise, result,
                                          fetch_result<telegram_api::auth_checkRecoveryPassword>(std::move(r_query)));
                       if (!result) {
-                        return promise.set_error(Status::Error(400, "Invalid recovery code"));
+                        return promise.set_error(400, "Invalid recovery code");
                       }
                       promise.set_value(Unit());
                     }));
@@ -604,7 +604,7 @@ void PasswordManager::update_password_settings(UpdateSettings update_settings, P
           return promise.set_error(r_update_settings.move_as_error());
         }
         if (!r_update_settings.ok()) {
-          return promise.set_error(Status::Error(400, "account_updatePasswordSettings returned false"));
+          return promise.set_error(400, "account_updatePasswordSettings returned false");
         }
         send_closure(actor_id, &PasswordManager::get_state, std::move(promise));
       });
@@ -780,7 +780,7 @@ void PasswordManager::do_get_state(Promise<PasswordState> promise) {
 
           switch (password->current_algo_->get_id()) {
             case telegram_api::passwordKdfAlgoUnknown::ID:
-              return promise.set_error(Status::Error(400, "Please update client to continue"));
+              return promise.set_error(400, "Please update client to continue");
             case telegram_api::passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow::ID: {
               auto algo =
                   move_tl_object_as<telegram_api::passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow>(
diff --git a/td/telegram/Payments.cpp b/td/telegram/Payments.cpp
index ca582d8f4..dfa58e0f5 100644
--- a/td/telegram/Payments.cpp
+++ b/td/telegram/Payments.cpp
@@ -582,7 +582,7 @@ class GetPaymentFormQuery final : public Td::ResultHandler {
       }
       case telegram_api::payments_paymentFormStarGift::ID:
         LOG(ERROR) << "Receive " << to_string(payment_form_ptr);
-        promise_.set_error(Status::Error(500, "Unsupported"));
+        promise_.set_error(500, "Unsupported");
         break;
       default:
         UNREACHABLE();
@@ -1008,25 +1008,25 @@ void answer_shipping_query(Td *td, int64 shipping_query_id,
   vector<tl_object_ptr<telegram_api::shippingOption>> options;
   for (auto &option : shipping_options) {
     if (option == nullptr) {
-      return promise.set_error(Status::Error(400, "Shipping option must be non-empty"));
+      return promise.set_error(400, "Shipping option must be non-empty");
     }
     if (!clean_input_string(option->id_)) {
-      return promise.set_error(Status::Error(400, "Shipping option identifier must be encoded in UTF-8"));
+      return promise.set_error(400, "Shipping option identifier must be encoded in UTF-8");
     }
     if (!clean_input_string(option->title_)) {
-      return promise.set_error(Status::Error(400, "Shipping option title must be encoded in UTF-8"));
+      return promise.set_error(400, "Shipping option title must be encoded in UTF-8");
     }
 
     vector<tl_object_ptr<telegram_api::labeledPrice>> prices;
     for (auto &price_part : option->price_parts_) {
       if (price_part == nullptr) {
-        return promise.set_error(Status::Error(400, "Shipping option price part must be non-empty"));
+        return promise.set_error(400, "Shipping option price part must be non-empty");
       }
       if (!clean_input_string(price_part->label_)) {
-        return promise.set_error(Status::Error(400, "Shipping option price part label must be encoded in UTF-8"));
+        return promise.set_error(400, "Shipping option price part label must be encoded in UTF-8");
       }
       if (!check_currency_amount(price_part->amount_)) {
-        return promise.set_error(Status::Error(400, "Too big amount of the currency specified"));
+        return promise.set_error(400, "Too big amount of the currency specified");
       }
 
       prices.push_back(make_tl_object<telegram_api::labeledPrice>(std::move(price_part->label_), price_part->amount_));
@@ -1066,32 +1066,32 @@ void validate_order_info(Td *td, td_api::object_ptr<td_api::InputInvoice> &&inpu
 
   if (order_info != nullptr) {
     if (!clean_input_string(order_info->name_)) {
-      return promise.set_error(Status::Error(400, "Name must be encoded in UTF-8"));
+      return promise.set_error(400, "Name must be encoded in UTF-8");
     }
     if (!clean_input_string(order_info->phone_number_)) {
-      return promise.set_error(Status::Error(400, "Phone number must be encoded in UTF-8"));
+      return promise.set_error(400, "Phone number must be encoded in UTF-8");
     }
     if (!clean_input_string(order_info->email_address_)) {
-      return promise.set_error(Status::Error(400, "Email address must be encoded in UTF-8"));
+      return promise.set_error(400, "Email address must be encoded in UTF-8");
     }
     if (order_info->shipping_address_ != nullptr) {
       if (!clean_input_string(order_info->shipping_address_->country_code_)) {
-        return promise.set_error(Status::Error(400, "Country code must be encoded in UTF-8"));
+        return promise.set_error(400, "Country code must be encoded in UTF-8");
       }
       if (!clean_input_string(order_info->shipping_address_->state_)) {
-        return promise.set_error(Status::Error(400, "State must be encoded in UTF-8"));
+        return promise.set_error(400, "State must be encoded in UTF-8");
       }
       if (!clean_input_string(order_info->shipping_address_->city_)) {
-        return promise.set_error(Status::Error(400, "City must be encoded in UTF-8"));
+        return promise.set_error(400, "City must be encoded in UTF-8");
       }
       if (!clean_input_string(order_info->shipping_address_->street_line1_)) {
-        return promise.set_error(Status::Error(400, "Street address must be encoded in UTF-8"));
+        return promise.set_error(400, "Street address must be encoded in UTF-8");
       }
       if (!clean_input_string(order_info->shipping_address_->street_line2_)) {
-        return promise.set_error(Status::Error(400, "Street address must be encoded in UTF-8"));
+        return promise.set_error(400, "Street address must be encoded in UTF-8");
       }
       if (!clean_input_string(order_info->shipping_address_->postal_code_)) {
-        return promise.set_error(Status::Error(400, "Postal code must be encoded in UTF-8"));
+        return promise.set_error(400, "Postal code must be encoded in UTF-8");
       }
     }
   }
@@ -1108,10 +1108,10 @@ void send_payment_form(Td *td, td_api::object_ptr<td_api::InputInvoice> &&input_
 
   if (credentials == nullptr) {
     if (tip_amount != 0 || !order_info_id.empty() || !shipping_option_id.empty()) {
-      return promise.set_error(Status::Error(400, "Invalid payment form parameters specified"));
+      return promise.set_error(400, "Invalid payment form parameters specified");
     }
     if (!td->star_manager_->has_owned_star_count(input_invoice_info.star_count_)) {
-      return promise.set_error(Status::Error(400, "Have not enough Telegram Stars to complete payment"));
+      return promise.set_error(400, "Have not enough Telegram Stars to complete payment");
     }
     td->create_handler<SendStarPaymentFormQuery>(std::move(promise))
         ->send(std::move(input_invoice_info), payment_form_id);
@@ -1124,11 +1124,11 @@ void send_payment_form(Td *td, td_api::object_ptr<td_api::InputInvoice> &&input_
       auto credentials_saved = static_cast<const td_api::inputCredentialsSaved *>(credentials.get());
       auto credentials_id = credentials_saved->saved_credentials_id_;
       if (!clean_input_string(credentials_id)) {
-        return promise.set_error(Status::Error(400, "Credentials identifier must be encoded in UTF-8"));
+        return promise.set_error(400, "Credentials identifier must be encoded in UTF-8");
       }
       auto temp_password_state = PasswordManager::get_temp_password_state_sync();
       if (!temp_password_state.has_temp_password) {
-        return promise.set_error(Status::Error(400, "Temporary password required to use saved credentials"));
+        return promise.set_error(400, "Temporary password required to use saved credentials");
       }
 
       input_credentials = make_tl_object<telegram_api::inputPaymentCredentialsSaved>(
@@ -1185,7 +1185,7 @@ void delete_saved_credentials(Td *td, Promise<Unit> &&promise) {
 void export_invoice(Td *td, BusinessConnectionId business_connection_id,
                     td_api::object_ptr<td_api::InputMessageContent> &&invoice, Promise<string> &&promise) {
   if (invoice == nullptr) {
-    return promise.set_error(Status::Error(400, "Invoice must be non-empty"));
+    return promise.set_error(400, "Invoice must be non-empty");
   }
   TRY_RESULT_PROMISE(promise, input_invoice,
                      InputInvoice::process_input_message_invoice(std::move(invoice), td, DialogId()));
@@ -1208,13 +1208,13 @@ void get_bank_card_info(Td *td, const string &bank_card_number,
 void get_collectible_info(Td *td, td_api::object_ptr<td_api::CollectibleItemType> type,
                           Promise<td_api::object_ptr<td_api::collectibleItemInfo>> &&promise) {
   if (type == nullptr) {
-    return promise.set_error(Status::Error(400, "Item type must be non-empty"));
+    return promise.set_error(400, "Item type must be non-empty");
   }
   switch (type->get_id()) {
     case td_api::collectibleItemTypeUsername::ID: {
       auto username = td_api::move_object_as<td_api::collectibleItemTypeUsername>(type);
       if (!clean_input_string(username->username_)) {
-        return promise.set_error(Status::Error(400, "Username must be encoded in UTF-8"));
+        return promise.set_error(400, "Username must be encoded in UTF-8");
       }
       td->create_handler<GetCollectibleInfoQuery>(std::move(promise))
           ->send(telegram_api::make_object<telegram_api::inputCollectibleUsername>(username->username_));
@@ -1223,7 +1223,7 @@ void get_collectible_info(Td *td, td_api::object_ptr<td_api::CollectibleItemType
     case td_api::collectibleItemTypePhoneNumber::ID: {
       auto phone_number = td_api::move_object_as<td_api::collectibleItemTypePhoneNumber>(type);
       if (!clean_input_string(phone_number->phone_number_)) {
-        return promise.set_error(Status::Error(400, "Phone number must be encoded in UTF-8"));
+        return promise.set_error(400, "Phone number must be encoded in UTF-8");
       }
       td->create_handler<GetCollectibleInfoQuery>(std::move(promise))
           ->send(telegram_api::make_object<telegram_api::inputCollectiblePhone>(phone_number->phone_number_));
diff --git a/td/telegram/PhoneNumberManager.cpp b/td/telegram/PhoneNumberManager.cpp
index 9ed390898..efd329f19 100644
--- a/td/telegram/PhoneNumberManager.cpp
+++ b/td/telegram/PhoneNumberManager.cpp
@@ -212,7 +212,7 @@ void PhoneNumberManager::on_send_code_result(Result<telegram_api::object_ptr<tel
     return promise.set_error(r_sent_code.move_as_error());
   }
   if (generation != generation_) {
-    return promise.set_error(Status::Error(500, "Request was canceled"));
+    return promise.set_error(500, "Request was canceled");
   }
   auto sent_code = r_sent_code.move_as_ok();
 
@@ -221,7 +221,7 @@ void PhoneNumberManager::on_send_code_result(Result<telegram_api::object_ptr<tel
   switch (sent_code->type_->get_id()) {
     case telegram_api::auth_sentCodeTypeSetUpEmailRequired::ID:
     case telegram_api::auth_sentCodeTypeEmailCode::ID:
-      return promise.set_error(Status::Error(500, "Receive incorrect response"));
+      return promise.set_error(500, "Receive incorrect response");
     default:
       break;
   }
@@ -238,10 +238,10 @@ void PhoneNumberManager::set_phone_number(string phone_number,
                                           Promise<td_api::object_ptr<td_api::authenticationCodeInfo>> &&promise) {
   inc_generation();
   if (phone_number.empty()) {
-    return promise.set_error(Status::Error(400, "Phone number must be non-empty"));
+    return promise.set_error(400, "Phone number must be non-empty");
   }
   if (type == nullptr) {
-    return promise.set_error(Status::Error(400, "Type must be non-empty"));
+    return promise.set_error(400, "Type must be non-empty");
   }
 
   switch (type->get_id()) {
@@ -258,10 +258,10 @@ void PhoneNumberManager::set_phone_number(string phone_number,
     case td_api::phoneNumberCodeTypeConfirmOwnership::ID: {
       auto hash = std::move(static_cast<td_api::phoneNumberCodeTypeConfirmOwnership *>(type.get())->hash_);
       if (!clean_input_string(hash)) {
-        return promise.set_error(Status::Error(400, "Hash must be encoded in UTF-8"));
+        return promise.set_error(400, "Hash must be encoded in UTF-8");
       }
       if (hash.empty()) {
-        return promise.set_error(Status::Error(400, "Hash must be non-empty"));
+        return promise.set_error(400, "Hash must be non-empty");
       }
 
       type_ = Type::ConfirmPhone;
@@ -275,7 +275,7 @@ void PhoneNumberManager::set_phone_number(string phone_number,
 
 void PhoneNumberManager::send_firebase_sms(const string &token, Promise<Unit> &&promise) {
   if (state_ != State::WaitCode) {
-    return promise.set_error(Status::Error(400, "Can't send Firebase SMS"));
+    return promise.set_error(400, "Can't send Firebase SMS");
   }
 
   td_->create_handler<RequestFirebaseSmsQuery>(std::move(promise))->send(send_code_helper_.request_firebase_sms(token));
@@ -283,7 +283,7 @@ void PhoneNumberManager::send_firebase_sms(const string &token, Promise<Unit> &&
 
 void PhoneNumberManager::report_missing_code(const string &mobile_network_code, Promise<Unit> &&promise) {
   if (state_ != State::WaitCode) {
-    return promise.set_error(Status::Error(400, "Can't report missing code"));
+    return promise.set_error(400, "Can't report missing code");
   }
 
   td_->create_handler<ReportMissingCodeQuery>(std::move(promise))
@@ -294,7 +294,7 @@ void PhoneNumberManager::resend_authentication_code(
     td_api::object_ptr<td_api::ResendCodeReason> &&reason,
     Promise<td_api::object_ptr<td_api::authenticationCodeInfo>> &&promise) {
   if (state_ != State::WaitCode) {
-    return promise.set_error(Status::Error(400, "Can't resend code"));
+    return promise.set_error(400, "Can't resend code");
   }
 
   TRY_RESULT_PROMISE(promise, resend_code, send_code_helper_.resend_code(std::move(reason)));
@@ -303,7 +303,7 @@ void PhoneNumberManager::resend_authentication_code(
 
 void PhoneNumberManager::check_code(string code, Promise<Unit> &&promise) {
   if (state_ != State::WaitCode) {
-    return promise.set_error(Status::Error(400, "Can't check code"));
+    return promise.set_error(400, "Can't check code");
   }
 
   auto query_promise = PromiseCreator::lambda(
@@ -335,7 +335,7 @@ void PhoneNumberManager::on_check_code_result(Result<Unit> result, int64 generat
     return promise.set_error(result.move_as_error());
   }
   if (generation != generation_) {
-    return promise.set_error(Status::Error(500, "Request was canceled"));
+    return promise.set_error(500, "Request was canceled");
   }
 
   inc_generation();
diff --git a/td/telegram/PollManager.cpp b/td/telegram/PollManager.cpp
index 473326fb2..7664631d4 100644
--- a/td/telegram/PollManager.cpp
+++ b/td/telegram/PollManager.cpp
@@ -108,7 +108,7 @@ class GetPollVotersQuery final : public Td::ResultHandler {
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
     if (input_peer == nullptr) {
       LOG(INFO) << "Can't get poll, because have no read access to " << dialog_id_;
-      return promise_.set_error(Status::Error(400, "Chat is not accessible"));
+      return promise_.set_error(400, "Chat is not accessible");
     }
 
     CHECK(!option.empty());
@@ -819,22 +819,22 @@ void PollManager::set_poll_answer(PollId poll_id, MessageFullId message_full_id,
   td::unique(option_ids);
 
   if (is_local_poll_id(poll_id)) {
-    return promise.set_error(Status::Error(400, "Poll can't be answered"));
+    return promise.set_error(400, "Poll can't be answered");
   }
 
   auto poll = get_poll(poll_id);
   CHECK(poll != nullptr);
   if (poll->is_closed_) {
-    return promise.set_error(Status::Error(400, "Can't answer closed poll"));
+    return promise.set_error(400, "Can't answer closed poll");
   }
   if (!poll->allow_multiple_answers_ && option_ids.size() > 1) {
-    return promise.set_error(Status::Error(400, "Can't choose more than 1 option in the poll"));
+    return promise.set_error(400, "Can't choose more than 1 option in the poll");
   }
   if (poll->is_quiz_ && option_ids.empty()) {
-    return promise.set_error(Status::Error(400, "Can't retract vote in a quiz"));
+    return promise.set_error(400, "Can't retract vote in a quiz");
   }
   if (poll->is_quiz_ && pending_answers_.count(poll_id) != 0) {
-    return promise.set_error(Status::Error(400, "Can't revote in a quiz"));
+    return promise.set_error(400, "Can't revote in a quiz");
   }
 
   FlatHashMap<uint64, int> affected_option_ids;
@@ -842,7 +842,7 @@ void PollManager::set_poll_answer(PollId poll_id, MessageFullId message_full_id,
   for (auto &option_id : option_ids) {
     auto index = static_cast<size_t>(option_id);
     if (index >= poll->options_.size()) {
-      return promise.set_error(Status::Error(400, "Invalid option ID specified"));
+      return promise.set_error(400, "Invalid option ID specified");
     }
     options.push_back(poll->options_[index].data_);
 
@@ -851,7 +851,7 @@ void PollManager::set_poll_answer(PollId poll_id, MessageFullId message_full_id,
   for (size_t option_index = 0; option_index < poll->options_.size(); option_index++) {
     if (poll->options_[option_index].is_chosen_) {
       if (poll->is_quiz_) {
-        return promise.set_error(Status::Error(400, "Can't revote in a quiz"));
+        return promise.set_error(400, "Can't revote in a quiz");
       }
       affected_option_ids[option_index + 1]++;
     }
@@ -1104,13 +1104,13 @@ td_api::object_ptr<td_api::messageSenders> PollManager::get_poll_voters_object(
 void PollManager::get_poll_voters(PollId poll_id, MessageFullId message_full_id, int32 option_id, int32 offset,
                                   int32 limit, Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
   if (is_local_poll_id(poll_id)) {
-    return promise.set_error(Status::Error(400, "Poll results can't be received"));
+    return promise.set_error(400, "Poll results can't be received");
   }
   if (offset < 0) {
-    return promise.set_error(Status::Error(400, "Invalid offset specified"));
+    return promise.set_error(400, "Invalid offset specified");
   }
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_GET_POLL_VOTERS) {
     limit = MAX_GET_POLL_VOTERS;
@@ -1119,10 +1119,10 @@ void PollManager::get_poll_voters(PollId poll_id, MessageFullId message_full_id,
   auto poll = get_poll(poll_id);
   CHECK(poll != nullptr);
   if (option_id < 0 || static_cast<size_t>(option_id) >= poll->options_.size()) {
-    return promise.set_error(Status::Error(400, "Invalid option ID specified"));
+    return promise.set_error(400, "Invalid option ID specified");
   }
   if (poll->is_anonymous_) {
-    return promise.set_error(Status::Error(400, "Poll is anonymous"));
+    return promise.set_error(400, "Poll is anonymous");
   }
 
   auto &voters = get_poll_option_voters(poll, poll_id, option_id);
@@ -1135,7 +1135,7 @@ void PollManager::get_poll_voters(PollId poll_id, MessageFullId message_full_id,
   auto cur_offset = narrow_cast<int32>(voters.voter_dialog_ids_.size());
 
   if (offset > cur_offset) {
-    return promise.set_error(Status::Error(400, "Too big offset specified; voters can be received only consequently"));
+    return promise.set_error(400, "Too big offset specified; voters can be received only consequently");
   }
   if (offset < cur_offset) {
     vector<DialogId> result;
diff --git a/td/telegram/Premium.cpp b/td/telegram/Premium.cpp
index 935f6acfc..42ab4cf86 100644
--- a/td/telegram/Premium.cpp
+++ b/td/telegram/Premium.cpp
@@ -648,13 +648,13 @@ class GetPremiumGiftPaymentFormQuery final : public Td::ResultHandler {
       case telegram_api::payments_paymentForm::ID:
       case telegram_api::payments_paymentFormStarGift::ID:
         LOG(ERROR) << "Receive " << to_string(payment_form_ptr);
-        promise_.set_error(Status::Error(500, "Unsupported"));
+        promise_.set_error(500, "Unsupported");
         break;
       case telegram_api::payments_paymentFormStars::ID: {
         auto payment_form = static_cast<const telegram_api::payments_paymentFormStars *>(payment_form_ptr.get());
         if (payment_form->invoice_->prices_.size() != 1u ||
             payment_form->invoice_->prices_[0]->amount_ != star_count_) {
-          return promise_.set_error(Status::Error(400, "Wrong purchase price specified"));
+          return promise_.set_error(400, "Wrong purchase price specified");
         }
         td_->create_handler<SendPremiumGiftQuery>(std::move(promise_))
             ->send(std::move(send_input_invoice_), payment_form->form_id_);
@@ -1209,7 +1209,7 @@ static td_api::object_ptr<td_api::premiumLimit> get_premium_limit_object(Slice k
 void get_premium_limit(const td_api::object_ptr<td_api::PremiumLimitType> &limit_type,
                        Promise<td_api::object_ptr<td_api::premiumLimit>> &&promise) {
   if (limit_type == nullptr) {
-    return promise.set_error(Status::Error(400, "Limit type must be non-empty"));
+    return promise.set_error(400, "Limit type must be non-empty");
   }
 
   promise.set_value(get_premium_limit_object(get_limit_type_key(limit_type.get())));
@@ -1301,7 +1301,7 @@ void get_business_features(Td *td, const td_api::object_ptr<td_api::BusinessFeat
 void view_premium_feature(Td *td, const td_api::object_ptr<td_api::PremiumFeature> &feature, Promise<Unit> &&promise) {
   auto source = get_premium_source(feature.get());
   if (source.empty()) {
-    return promise.set_error(Status::Error(400, "Feature must be non-empty"));
+    return promise.set_error(400, "Feature must be non-empty");
   }
 
   vector<tl_object_ptr<telegram_api::jsonObjectValue>> data;
@@ -1390,7 +1390,7 @@ void can_purchase_premium(Td *td, td_api::object_ptr<td_api::StorePaymentPurpose
 void assign_store_transaction(Td *td, td_api::object_ptr<td_api::StoreTransaction> &&transaction,
                               td_api::object_ptr<td_api::StorePaymentPurpose> &&purpose, Promise<Unit> &&promise) {
   if (transaction == nullptr) {
-    return promise.set_error(Status::Error(400, "Transaction must be non-empty"));
+    return promise.set_error(400, "Transaction must be non-empty");
   }
   if (purpose != nullptr && purpose->get_id() == td_api::storePaymentPurposePremiumSubscription::ID) {
     dismiss_suggested_action(SuggestedAction{SuggestedAction::Type::UpgradePremium}, Promise<Unit>());
@@ -1407,7 +1407,7 @@ void assign_store_transaction(Td *td, td_api::object_ptr<td_api::StoreTransactio
       auto type = td_api::move_object_as<td_api::storeTransactionGooglePlay>(transaction);
       if (!clean_input_string(type->package_name_) || !clean_input_string(type->store_product_id_) ||
           !clean_input_string(type->purchase_token_)) {
-        return promise.set_error(Status::Error(400, "Strings must be encoded in UTF-8"));
+        return promise.set_error(400, "Strings must be encoded in UTF-8");
       }
 
       td->create_handler<AssignPlayMarketTransactionQuery>(std::move(promise))
diff --git a/td/telegram/QuickReplyManager.cpp b/td/telegram/QuickReplyManager.cpp
index a0c6908f1..57e81f45c 100644
--- a/td/telegram/QuickReplyManager.cpp
+++ b/td/telegram/QuickReplyManager.cpp
@@ -1494,13 +1494,13 @@ void QuickReplyManager::set_quick_reply_shortcut_name(QuickReplyShortcutId short
   load_quick_reply_shortcuts();
   const auto *shortcut = get_shortcut(shortcut_id);
   if (shortcut == nullptr) {
-    return promise.set_error(Status::Error(400, "Shortcut not found"));
+    return promise.set_error(400, "Shortcut not found");
   }
   if (check_shortcut_name(name).is_error()) {
-    return promise.set_error(Status::Error(400, "Shortcut name is invalid"));
+    return promise.set_error(400, "Shortcut name is invalid");
   }
   if (!shortcut_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Shortcut isn't created yet"));
+    return promise.set_error(400, "Shortcut isn't created yet");
   }
   auto query_promise = PromiseCreator::lambda(
       [actor_id = actor_id(this), shortcut_id, name, promise = std::move(promise)](Result<Unit> &&result) mutable {
@@ -1536,7 +1536,7 @@ void QuickReplyManager::delete_quick_reply_shortcut(QuickReplyShortcutId shortcu
   load_quick_reply_shortcuts();
   auto it = get_shortcut_it(shortcut_id);
   if (it == shortcuts_.shortcuts_.end()) {
-    return promise.set_error(Status::Error(400, "Shortcut not found"));
+    return promise.set_error(400, "Shortcut not found");
   }
   send_update_quick_reply_shortcut_deleted(it->get());
   shortcuts_.shortcuts_.erase(it);
@@ -1564,13 +1564,13 @@ void QuickReplyManager::reorder_quick_reply_shortcuts(const vector<QuickReplySho
   FlatHashSet<QuickReplyShortcutId, QuickReplyShortcutIdHash> unique_shortcut_ids;
   for (const auto &shortcut_id : shortcut_ids) {
     if (get_shortcut(shortcut_id) == nullptr) {
-      return promise.set_error(Status::Error(400, "Shortcut not found"));
+      return promise.set_error(400, "Shortcut not found");
     }
     CHECK(shortcut_id.is_valid());
     unique_shortcut_ids.insert(shortcut_id);
   }
   if (unique_shortcut_ids.size() != shortcut_ids.size()) {
-    return promise.set_error(Status::Error(400, "Duplicate shortcut identifiers specified"));
+    return promise.set_error(400, "Duplicate shortcut identifiers specified");
   }
   if (!shortcuts_.are_inited_) {
     return promise.set_value(Unit());
@@ -1766,7 +1766,7 @@ void QuickReplyManager::delete_quick_reply_shortcut_messages(QuickReplyShortcutI
   load_quick_reply_shortcuts();
   auto *s = get_shortcut(shortcut_id);
   if (s == nullptr) {
-    return promise.set_error(Status::Error(400, "Shortcut not found"));
+    return promise.set_error(400, "Shortcut not found");
   }
   if (message_ids.empty()) {
     return promise.set_value(Unit());
@@ -1775,7 +1775,7 @@ void QuickReplyManager::delete_quick_reply_shortcut_messages(QuickReplyShortcutI
   vector<MessageId> deleted_server_message_ids;
   for (auto &message_id : message_ids) {
     if (!message_id.is_valid()) {
-      return promise.set_error(Status::Error(400, "Invalid message identifier"));
+      return promise.set_error(400, "Invalid message identifier");
     }
 
     // message_id = get_persistent_message_id(s, message_id);
@@ -2777,14 +2777,14 @@ void QuickReplyManager::edit_quick_reply_message(
   load_quick_reply_shortcuts();
   auto *s = get_shortcut(shortcut_id);
   if (s == nullptr) {
-    return promise.set_error(Status::Error(400, "Shortcut not found"));
+    return promise.set_error(400, "Shortcut not found");
   }
   auto *m = get_message_editable(s, message_id);
   if (m == nullptr) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!can_edit_quick_reply_message(m)) {
-    return promise.set_error(Status::Error(400, "Message can't be edited"));
+    return promise.set_error(400, "Message can't be edited");
   }
 
   TRY_RESULT_PROMISE(promise, message_content, process_input_message_content(std::move(input_message_content)));
@@ -2804,16 +2804,16 @@ void QuickReplyManager::edit_quick_reply_message(
           new_message_content_type != MessageContentType::Video &&
           (new_message_content_type != MessageContentType::Text ||
            old_message_content_type != MessageContentType::Text)) {
-        return promise.set_error(Status::Error(400, "Message can't be edited to the specified message type"));
+        return promise.set_error(400, "Message can't be edited to the specified message type");
       }
       if (m->media_album_id != 0) {
         if (old_message_content_type != new_message_content_type) {
           if (!is_allowed_media_group_content(new_message_content_type)) {
-            return promise.set_error(Status::Error(400, "Message content type can't be used in an album"));
+            return promise.set_error(400, "Message content type can't be used in an album");
           }
           if (is_homogenous_media_group_content(old_message_content_type) ||
               is_homogenous_media_group_content(new_message_content_type)) {
-            return promise.set_error(Status::Error(400, "Can't change media type in the album"));
+            return promise.set_error(400, "Can't change media type in the album");
           }
         }
       }
@@ -2822,7 +2822,7 @@ void QuickReplyManager::edit_quick_reply_message(
       if (new_message_content_type != MessageContentType::VoiceNote ||
           get_message_content_any_file_id(m->content.get()) !=
               get_message_content_any_file_id(message_content.content.get())) {
-        return promise.set_error(Status::Error(400, "Only caption can be edited in voice note messages"));
+        return promise.set_error(400, "Only caption can be edited in voice note messages");
       }
       break;
     default:
@@ -3012,7 +3012,7 @@ void QuickReplyManager::get_quick_reply_shortcut_messages(QuickReplyShortcutId s
   load_quick_reply_shortcuts();
   auto *s = get_shortcut(shortcut_id);
   if (s == nullptr) {
-    return promise.set_error(Status::Error(400, "Shortcut not found"));
+    return promise.set_error(400, "Shortcut not found");
   }
   if (have_all_shortcut_messages(s)) {
     return promise.set_value(Unit());
@@ -3024,7 +3024,7 @@ void QuickReplyManager::get_quick_reply_shortcut_messages(QuickReplyShortcutId s
 
 void QuickReplyManager::reload_quick_reply_messages(QuickReplyShortcutId shortcut_id, Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Not supported by bots"));
+    return promise.set_error(400, "Not supported by bots");
   }
 
   load_quick_reply_shortcuts();
@@ -3153,16 +3153,16 @@ int64 QuickReplyManager::get_quick_reply_messages_hash(const Shortcut *s) {
 void QuickReplyManager::reload_quick_reply_message(QuickReplyShortcutId shortcut_id, MessageId message_id,
                                                    Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Not supported by bots"));
+    return promise.set_error(400, "Not supported by bots");
   }
 
   load_quick_reply_shortcuts();
   auto *s = get_shortcut(shortcut_id);
   if (s == nullptr) {
-    return promise.set_error(Status::Error(400, "Shortcut not found"));
+    return promise.set_error(400, "Shortcut not found");
   }
   if (!message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Message can't be reloaded"));
+    return promise.set_error(400, "Message can't be reloaded");
   }
   auto query_promise =
       PromiseCreator::lambda([actor_id = actor_id(this), shortcut_id, message_id, promise = std::move(promise)](
@@ -3183,7 +3183,7 @@ void QuickReplyManager::on_reload_quick_reply_message(
   }
   auto *s = get_shortcut(shortcut_id);
   if (s == nullptr) {
-    return promise.set_error(Status::Error(400, "Shortcut not found"));
+    return promise.set_error(400, "Shortcut not found");
   }
   auto messages_ptr = r_messages.move_as_ok();
   switch (messages_ptr->get_id()) {
@@ -3191,7 +3191,7 @@ void QuickReplyManager::on_reload_quick_reply_message(
     case telegram_api::messages_channelMessages::ID:
     case telegram_api::messages_messagesNotModified::ID:
       LOG(ERROR) << "Receive " << to_string(messages_ptr);
-      return promise.set_error(Status::Error(400, "Receive wrong response"));
+      return promise.set_error(400, "Receive wrong response");
     case telegram_api::messages_messages::ID: {
       auto messages = telegram_api::move_object_as<telegram_api::messages_messages>(messages_ptr);
       td_->user_manager_->on_get_users(std::move(messages->users_), "on_reload_quick_reply_message");
@@ -3207,11 +3207,11 @@ void QuickReplyManager::on_reload_quick_reply_message(
       }
       if (message == nullptr) {
         delete_quick_reply_messages(s, {message_id}, "on_reload_quick_reply_message");
-        return promise.set_error(Status::Error(400, "Message not found"));
+        return promise.set_error(400, "Message not found");
       }
       if (message->shortcut_id != shortcut_id) {
         LOG(ERROR) << "Receive message from " << message->shortcut_id << " instead of " << shortcut_id;
-        return promise.set_error(Status::Error(400, "Message not found"));
+        return promise.set_error(400, "Message not found");
       }
       on_get_quick_reply_message(s, std::move(message));
       break;
diff --git a/td/telegram/ReactionManager.cpp b/td/telegram/ReactionManager.cpp
index 84bccf492..4b2ae20df 100644
--- a/td/telegram/ReactionManager.cpp
+++ b/td/telegram/ReactionManager.cpp
@@ -973,13 +973,13 @@ bool ReactionManager::is_active_reaction(const ReactionType &reaction_type) cons
 
 void ReactionManager::set_default_reaction(ReactionType reaction_type, Promise<Unit> &&promise) {
   if (reaction_type.is_empty()) {
-    return promise.set_error(Status::Error(400, "Default reaction must be non-empty"));
+    return promise.set_error(400, "Default reaction must be non-empty");
   }
   if (reaction_type.is_paid_reaction()) {
-    return promise.set_error(Status::Error(400, "Can't set paid reaction as default"));
+    return promise.set_error(400, "Can't set paid reaction as default");
   }
   if (!reaction_type.is_custom_reaction() && !is_active_reaction(reaction_type)) {
-    return promise.set_error(Status::Error(400, "Can't set inactive reaction as default"));
+    return promise.set_error(400, "Can't set inactive reaction as default");
   }
 
   if (td_->option_manager_->get_option_string("default_reaction", "-") != reaction_type.get_string()) {
@@ -1052,7 +1052,7 @@ ReactionManager::SavedReactionTags *ReactionManager::get_saved_reaction_tags(
 void ReactionManager::get_saved_messages_tags(SavedMessagesTopicId saved_messages_topic_id,
                                               Promise<td_api::object_ptr<td_api::savedMessagesTags>> &&promise) {
   if (!saved_messages_topic_id.is_valid() && saved_messages_topic_id != SavedMessagesTopicId()) {
-    return promise.set_error(Status::Error(400, "Invalid Saved Messages topic specified"));
+    return promise.set_error(400, "Invalid Saved Messages topic specified");
   }
   const auto *tags = get_saved_reaction_tags(saved_messages_topic_id);
   if (tags->is_inited_) {
@@ -1198,10 +1198,10 @@ void ReactionManager::update_saved_messages_tags(SavedMessagesTopicId saved_mess
 
 void ReactionManager::set_saved_messages_tag_title(ReactionType reaction_type, string title, Promise<Unit> &&promise) {
   if (reaction_type.is_empty()) {
-    return promise.set_error(Status::Error(400, "Reaction type must be non-empty"));
+    return promise.set_error(400, "Reaction type must be non-empty");
   }
   if (reaction_type.is_paid_reaction()) {
-    return promise.set_error(Status::Error(400, "Invalid reaction specified"));
+    return promise.set_error(400, "Invalid reaction specified");
   }
   title = clean_name(title, MAX_TAG_TITLE_LENGTH);
 
diff --git a/td/telegram/ReferralProgramManager.cpp b/td/telegram/ReferralProgramManager.cpp
index 5584a2a12..347c445d7 100644
--- a/td/telegram/ReferralProgramManager.cpp
+++ b/td/telegram/ReferralProgramManager.cpp
@@ -415,7 +415,7 @@ void ReferralProgramManager::tear_down() {
 void ReferralProgramManager::set_dialog_referral_program(DialogId dialog_id, ReferralProgramParameters parameters,
                                                          Promise<Unit> &&promise) {
   if (!parameters.is_valid() && parameters != ReferralProgramParameters()) {
-    return promise.set_error(Status::Error(400, "Invalid affiliate parameters specified"));
+    return promise.set_error(400, "Invalid affiliate parameters specified");
   }
   switch (dialog_id.get_type()) {
     case DialogType::User: {
@@ -423,13 +423,13 @@ void ReferralProgramManager::set_dialog_referral_program(DialogId dialog_id, Ref
       if (bot_data.can_be_edited) {
         break;
       }
-      return promise.set_error(Status::Error(400, "The bot isn't owned"));
+      return promise.set_error(400, "The bot isn't owned");
     }
     case DialogType::Chat:
     case DialogType::Channel:
     case DialogType::SecretChat:
     case DialogType::None:
-      return promise.set_error(Status::Error(400, "The chat can't have affiliate program"));
+      return promise.set_error(400, "The chat can't have affiliate program");
     default:
       UNREACHABLE();
   }
@@ -450,7 +450,7 @@ void ReferralProgramManager::search_referral_programs(
     const string &offset, int32 limit, Promise<td_api::object_ptr<td_api::foundAffiliatePrograms>> &&promise) {
   TRY_RESULT_PROMISE(promise, affiliate_type, AffiliateType::get_affiliate_type(td_, affiliate));
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Limit must be positive"));
+    return promise.set_error(400, "Limit must be positive");
   }
 
   td_->create_handler<GetSuggestedStarRefBotsQuery>(std::move(promise))
@@ -488,7 +488,7 @@ void ReferralProgramManager::get_connected_referral_programs(
     Promise<td_api::object_ptr<td_api::connectedAffiliatePrograms>> &&promise) {
   TRY_RESULT_PROMISE(promise, affiliate_type, AffiliateType::get_affiliate_type(td_, affiliate));
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Limit must be positive"));
+    return promise.set_error(400, "Limit must be positive");
   }
 
   td_->create_handler<GetConnectedStarRefBotsQuery>(std::move(promise))->send(affiliate_type, offset, limit);
diff --git a/td/telegram/SavedMessagesManager.cpp b/td/telegram/SavedMessagesManager.cpp
index 8dfe20e29..a2d29213c 100644
--- a/td/telegram/SavedMessagesManager.cpp
+++ b/td/telegram/SavedMessagesManager.cpp
@@ -1331,13 +1331,13 @@ void SavedMessagesManager::load_saved_messages_topics(int32 limit, Promise<Unit>
 
 void SavedMessagesManager::load_topics(TopicList *topic_list, int32 limit, Promise<Unit> &&promise) {
   if (limit < 0) {
-    return promise.set_error(Status::Error(400, "Limit must be non-negative"));
+    return promise.set_error(400, "Limit must be non-negative");
   }
   if (limit == 0) {
     return promise.set_value(Unit());
   }
   if (topic_list->last_topic_date_ == MAX_TOPIC_DATE) {
-    return promise.set_error(Status::Error(404, "Not Found"));
+    return promise.set_error(404, "Not Found");
   }
   if (!topic_list->are_pinned_saved_messages_topics_inited_) {
     CHECK(topic_list == &topic_list_);
@@ -1422,10 +1422,10 @@ void SavedMessagesManager::on_get_saved_messages_topics(
     Promise<Unit> &&promise) {
   auto *topic_list = get_topic_list(dialog_id);
   if (topic_list == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat has no topics"));
+    return promise.set_error(400, "Chat has no topics");
   }
   if (topic_list->generation_ != generation) {
-    return promise.set_error(Status::Error(400, "Topic was deleted"));
+    return promise.set_error(400, "Topic was deleted");
   }
 
   CHECK(saved_dialogs_ptr != nullptr);
@@ -1438,7 +1438,7 @@ void SavedMessagesManager::on_get_saved_messages_topics(
   switch (saved_dialogs_ptr->get_id()) {
     case telegram_api::messages_savedDialogsNotModified::ID:
       LOG(ERROR) << "Receive messages.savedDialogsNotModified";
-      return promise.set_error(Status::Error(500, "Receive messages.savedDialogsNotModified"));
+      return promise.set_error(500, "Receive messages.savedDialogsNotModified");
     case telegram_api::messages_savedDialogs::ID: {
       auto saved_dialogs = telegram_api::move_object_as<telegram_api::messages_savedDialogs>(saved_dialogs_ptr);
       total_count = static_cast<int32>(saved_dialogs->dialogs_.size());
@@ -1495,10 +1495,10 @@ void SavedMessagesManager::process_saved_messages_topics(
   TRY_STATUS_PROMISE(promise, G()->close_status());
   auto *topic_list = get_topic_list(dialog_id);
   if (topic_list == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat has no topics"));
+    return promise.set_error(400, "Chat has no topics");
   }
   if (topic_list->generation_ != generation) {
-    return promise.set_error(Status::Error(400, "Topic was deleted"));
+    return promise.set_error(400, "Topic was deleted");
   }
 
   FlatHashMap<MessageId, telegram_api::object_ptr<telegram_api::Message>, MessageIdHash> message_id_to_message;
@@ -1633,7 +1633,7 @@ void SavedMessagesManager::process_saved_messages_topics(
 
   if (is_get_topic) {
     if (added_saved_messages_topic_ids.size() != 1u) {
-      return promise.set_error(Status::Error(404, "Not Found"));
+      return promise.set_error(404, "Not Found");
     }
   } else if (is_pinned) {
     if (!topic_list->are_pinned_saved_messages_topics_inited_ && total_count < limit) {
@@ -1647,7 +1647,7 @@ void SavedMessagesManager::process_saved_messages_topics(
     set_last_topic_date(topic_list, MAX_TOPIC_DATE);
 
     if (dialogs.empty()) {
-      return promise.set_error(Status::Error(404, "Not Found"));
+      return promise.set_error(404, "Not Found");
     }
   } else if (last_message_date > 0) {
     set_last_topic_date(topic_list,
@@ -1655,7 +1655,7 @@ void SavedMessagesManager::process_saved_messages_topics(
   } else {
     LOG(ERROR) << "Receive no suitable topics";
     set_last_topic_date(topic_list, MAX_TOPIC_DATE);
-    return promise.set_error(Status::Error(404, "Not Found"));
+    return promise.set_error(404, "Not Found");
   }
 
   promise.set_value(Unit());
@@ -1878,12 +1878,12 @@ void SavedMessagesManager::reload_monoforum_topic(
   CHECK(dialog_id != DialogId());
   auto topic_list = get_topic_list(dialog_id);
   if (topic_list == nullptr) {
-    return promise.set_error(Status::Error(400, "Topic list not found"));
+    return promise.set_error(400, "Topic list not found");
   }
   if (saved_messages_topic_id.is_valid_in(td_, dialog_id).is_error()) {
     LOG(ERROR) << "Can't load " << saved_messages_topic_id << " of " << dialog_id << ": "
                << saved_messages_topic_id.is_valid_in(td_, dialog_id);
-    return promise.set_error(Status::Error(500, "Can't load topic info"));
+    return promise.set_error(500, "Can't load topic info");
   }
   auto &queries = topic_list->get_topic_queries_[saved_messages_topic_id];
   queries.push_back(std::move(promise));
@@ -1947,23 +1947,23 @@ void SavedMessagesManager::get_topic_history(DialogId dialog_id, SavedMessagesTo
                                              Promise<td_api::object_ptr<td_api::messages>> &&promise) {
   auto *topic_list = get_topic_list(dialog_id);
   if (topic_list == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat has no topics"));
+    return promise.set_error(400, "Chat has no topics");
   }
 
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_GET_HISTORY) {
     limit = MAX_GET_HISTORY;
   }
   if (offset > 0) {
-    return promise.set_error(Status::Error(400, "Parameter offset must be non-positive"));
+    return promise.set_error(400, "Parameter offset must be non-positive");
   }
   if (offset <= -MAX_GET_HISTORY) {
-    return promise.set_error(Status::Error(400, "Parameter offset must be greater than -100"));
+    return promise.set_error(400, "Parameter offset must be greater than -100");
   }
   if (offset < -limit) {
-    return promise.set_error(Status::Error(400, "Parameter offset must be greater than or equal to -limit"));
+    return promise.set_error(400, "Parameter offset must be greater than or equal to -limit");
   }
 
   TRY_STATUS_PROMISE(promise, saved_messages_topic_id.is_valid_in(td_, dialog_id));
@@ -1974,7 +1974,7 @@ void SavedMessagesManager::get_topic_history(DialogId dialog_id, SavedMessagesTo
     offset = 0;
   }
   if (!from_message_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid value of parameter from_message_id specified"));
+    return promise.set_error(400, "Invalid value of parameter from_message_id specified");
   }
 
   auto *topic = get_topic(topic_list, saved_messages_topic_id);
@@ -2041,10 +2041,10 @@ void SavedMessagesManager::on_get_topic_history(DialogId dialog_id, uint32 gener
 
   auto *topic_list = get_topic_list(dialog_id);
   if (topic_list == nullptr) {
-    return promise.set_error(Status::Error(400, "Chat has no topics"));
+    return promise.set_error(400, "Chat has no topics");
   }
   if (topic_list->generation_ != generation) {
-    return promise.set_error(Status::Error(400, "Topic was deleted"));
+    return promise.set_error(400, "Topic was deleted");
   }
   auto *topic = add_topic(topic_list, saved_messages_topic_id, false);
 
@@ -2054,7 +2054,7 @@ void SavedMessagesManager::on_get_topic_history(DialogId dialog_id, uint32 gener
   auto info = r_info.move_as_ok();
 
   if (!MessageId::is_message_id_order_descending(info.messages)) {
-    return promise.set_error(Status::Error(500, "Receive invalid response"));
+    return promise.set_error(500, "Receive invalid response");
   }
 
   MessageId first_message_id;
@@ -2212,16 +2212,16 @@ void SavedMessagesManager::toggle_saved_messages_topic_is_pinned(SavedMessagesTo
   TRY_STATUS_PROMISE(promise, saved_messages_topic_id.is_valid_in(td_, dialog_id));
   auto *topic_list = &topic_list_;
   if (!topic_list->are_pinned_saved_messages_topics_inited_) {
-    return promise.set_error(Status::Error(400, "Pinned Saved Messages topics must be loaded first"));
+    return promise.set_error(400, "Pinned Saved Messages topics must be loaded first");
   }
   auto *topic = get_topic(topic_list, saved_messages_topic_id);
   if (topic == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't find Saved Messages topic"));
+    return promise.set_error(400, "Can't find Saved Messages topic");
   }
   if (is_pinned && !td::contains(topic_list->pinned_saved_messages_topic_ids_, saved_messages_topic_id) &&
       static_cast<size_t>(get_pinned_saved_messages_topic_limit()) <=
           topic_list->pinned_saved_messages_topic_ids_.size()) {
-    return promise.set_error(Status::Error(400, "The maximum number of pinned chats exceeded"));
+    return promise.set_error(400, "The maximum number of pinned chats exceeded");
   }
   if (!set_saved_messages_topic_is_pinned(topic, is_pinned, "toggle_saved_messages_topic_is_pinned")) {
     return promise.set_value(Unit());
@@ -2236,14 +2236,14 @@ void SavedMessagesManager::set_pinned_saved_messages_topics(vector<SavedMessages
   for (const auto &saved_messages_topic_id : saved_messages_topic_ids) {
     TRY_STATUS_PROMISE(promise, saved_messages_topic_id.is_valid_in(td_, dialog_id));
     if (get_topic(topic_list, saved_messages_topic_id) == nullptr) {
-      return promise.set_error(Status::Error(400, "Can't find Saved Messages topic"));
+      return promise.set_error(400, "Can't find Saved Messages topic");
     }
   }
   if (!topic_list->are_pinned_saved_messages_topics_inited_) {
-    return promise.set_error(Status::Error(400, "Pinned Saved Messages topics must be loaded first"));
+    return promise.set_error(400, "Pinned Saved Messages topics must be loaded first");
   }
   if (static_cast<size_t>(get_pinned_saved_messages_topic_limit()) < saved_messages_topic_ids.size()) {
-    return promise.set_error(Status::Error(400, "The maximum number of pinned chats exceeded"));
+    return promise.set_error(400, "The maximum number of pinned chats exceeded");
   }
   if (!set_pinned_saved_messages_topics(saved_messages_topic_ids)) {
     return promise.set_value(Unit());
@@ -2268,14 +2268,14 @@ void SavedMessagesManager::set_monoforum_topic_is_marked_as_unread(DialogId dial
                                                                    bool is_marked_as_unread, Promise<Unit> &&promise) {
   auto *topic_list = get_topic_list(dialog_id);
   if (topic_list == nullptr) {
-    return promise.set_error(Status::Error(400, "Topic not found"));
+    return promise.set_error(400, "Topic not found");
   }
   auto *topic = get_topic(topic_list, saved_messages_topic_id);
   if (topic == nullptr) {
-    return promise.set_error(Status::Error(400, "Topic not found"));
+    return promise.set_error(400, "Topic not found");
   }
   if (topic->dialog_id_ != dialog_id) {
-    return promise.set_error(Status::Error(400, "Topic can't be marked as unread"));
+    return promise.set_error(400, "Topic can't be marked as unread");
   }
 
   do_set_topic_is_marked_as_unread(topic, is_marked_as_unread);
@@ -2321,14 +2321,14 @@ void SavedMessagesManager::unpin_all_monoforum_topic_messages(DialogId dialog_id
                                                               Promise<Unit> &&promise) {
   auto *topic_list = get_topic_list(dialog_id);
   if (topic_list == nullptr) {
-    return promise.set_error(Status::Error(400, "Topic not found"));
+    return promise.set_error(400, "Topic not found");
   }
   auto *topic = get_topic(topic_list, saved_messages_topic_id);
   if (topic == nullptr) {
-    return promise.set_error(Status::Error(400, "Topic not found"));
+    return promise.set_error(400, "Topic not found");
   }
   if (topic->dialog_id_ != dialog_id) {
-    return promise.set_error(Status::Error(400, "Topic messages can't be unpinned"));
+    return promise.set_error(400, "Topic messages can't be unpinned");
   }
 
   td_->messages_manager_->unpin_all_local_dialog_messages(dialog_id, MessageId(), saved_messages_topic_id);
@@ -2342,14 +2342,14 @@ void SavedMessagesManager::read_all_monoforum_topic_reactions(DialogId dialog_id
                                                               Promise<Unit> &&promise) {
   auto *topic_list = get_topic_list(dialog_id);
   if (topic_list == nullptr) {
-    return promise.set_error(Status::Error(400, "Topic not found"));
+    return promise.set_error(400, "Topic not found");
   }
   auto *topic = get_topic(topic_list, saved_messages_topic_id);
   if (topic == nullptr) {
-    return promise.set_error(Status::Error(400, "Topic not found"));
+    return promise.set_error(400, "Topic not found");
   }
   if (topic->dialog_id_ != dialog_id) {
-    return promise.set_error(Status::Error(400, "Topic messages can't have reactions"));
+    return promise.set_error(400, "Topic messages can't have reactions");
   }
 
   td_->messages_manager_->read_all_local_dialog_reactions(dialog_id, MessageId(), saved_messages_topic_id);
@@ -2370,11 +2370,11 @@ void SavedMessagesManager::get_monoforum_message_author(MessageFullId message_fu
   auto dialog_id = message_full_id.get_dialog_id();
   TRY_STATUS_PROMISE(promise, check_monoforum_dialog_id(dialog_id));
   if (!td_->messages_manager_->have_message_force(message_full_id, "get_monoforum_message_author")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   auto message_id = message_full_id.get_message_id();
   if (!message_id.is_valid() || !message_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Can't get message author"));
+    return promise.set_error(400, "Can't get message author");
   }
 
   td_->create_handler<GetMessageAuthorQuery>(std::move(promise))->send(dialog_id.get_channel_id(), message_id);
diff --git a/td/telegram/SecretChatActor.cpp b/td/telegram/SecretChatActor.cpp
index 26535f9ad..14d2fcfa3 100644
--- a/td/telegram/SecretChatActor.cpp
+++ b/td/telegram/SecretChatActor.cpp
@@ -82,11 +82,11 @@ void SecretChatActor::update_chat(telegram_api::object_ptr<telegram_api::Encrypt
 void SecretChatActor::create_chat(UserId user_id, int64 user_access_hash, int32 random_id,
                                   Promise<SecretChatId> promise) {
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Empty) {
-    promise.set_error(Status::Error(500, "Bad random_id"));
+    promise.set_error(500, "Bad random_id");
     check_status(Status::Error("Unexpected request_chat"));
     loop();
     return;
@@ -231,7 +231,7 @@ Result<BufferSlice> SecretChatActor::create_encrypted_message(int32 my_in_seq_no
 void SecretChatActor::send_message(tl_object_ptr<secret_api::DecryptedMessage> message,
                                    telegram_api::object_ptr<telegram_api::InputEncryptedFile> file, Promise<> promise) {
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   send_message_impl(std::move(message), std::move(file), SendFlag::External | SendFlag::Push, std::move(promise));
@@ -241,12 +241,12 @@ void SecretChatActor::send_message_impl(tl_object_ptr<secret_api::DecryptedMessa
                                         telegram_api::object_ptr<telegram_api::InputEncryptedFile> file, int32 flags,
                                         Promise<> promise) {
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Ready) {
     LOG(ERROR) << "Ignore send_message: " << tag("message", to_string(message)) << tag("file", to_string(file));
-    return promise.set_error(Status::Error(400, "Chat is not accessible"));
+    return promise.set_error(400, "Chat is not accessible");
   }
   LOG_CHECK(binlog_replay_finish_flag_) << "Trying to send message before binlog replay is finished: "
                                         << to_string(*message) << to_string(file);
@@ -305,12 +305,12 @@ void SecretChatActor::send_message_action(tl_object_ptr<secret_api::SendMessageA
 
 void SecretChatActor::send_read_history(int32 date, Promise<> promise) {
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Ready) {
     LOG(ERROR) << "Ignore send_read_history: " << tag("date", date);
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return;
   }
 
@@ -335,11 +335,11 @@ void SecretChatActor::send_read_history(int32 date, Promise<> promise) {
 
 void SecretChatActor::send_open_message(int64 random_id, Promise<> promise) {
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Ready) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return;
   }
   std::vector<int64> random_ids{random_id};
@@ -353,11 +353,11 @@ void SecretChatActor::delete_message(int64 random_id, Promise<> promise) {
     return;
   }
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Ready) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return;
   }
   return delete_messages(std::vector<int64>{random_id}, std::move(promise));
@@ -369,11 +369,11 @@ void SecretChatActor::delete_messages(std::vector<int64> random_ids, Promise<> p
     return;
   }
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Ready) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return;
   }
   send_action(make_tl_object<secret_api::decryptedMessageActionDeleteMessages>(std::move(random_ids)), SendFlag::Push,
@@ -385,11 +385,11 @@ void SecretChatActor::delete_all_messages(Promise<> promise) {
     return;
   }
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Ready) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return;
   }
   send_action(make_tl_object<secret_api::decryptedMessageActionFlushHistory>(), SendFlag::Push, std::move(promise));
@@ -397,11 +397,11 @@ void SecretChatActor::delete_all_messages(Promise<> promise) {
 
 void SecretChatActor::notify_screenshot_taken(Promise<> promise) {
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Ready) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return;
   }
   send_action(make_tl_object<secret_api::decryptedMessageActionScreenshotMessages>(vector<int64>()), SendFlag::Push,
@@ -410,11 +410,11 @@ void SecretChatActor::notify_screenshot_taken(Promise<> promise) {
 
 void SecretChatActor::send_set_ttl_message(int32 ttl, int64 random_id, Promise<> promise) {
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   if (auth_state_.state != State::Ready) {
-    promise.set_error(Status::Error(400, "Can't access the chat"));
+    promise.set_error(400, "Can't access the chat");
     return;
   }
   send_message_impl(secret_api::make_object<secret_api::decryptedMessageService>(
@@ -1700,7 +1700,7 @@ void SecretChatActor::on_outbound_ack(uint64 state_id) {
 
 void SecretChatActor::on_outbound_outer_send_message_promise(uint64 state_id, Promise<> promise) {
   if (close_flag_) {
-    promise.set_error(Status::Error(400, "Chat is closed"));
+    promise.set_error(400, "Chat is closed");
     return;
   }
   auto *state = outbound_message_states_.get(state_id);
diff --git a/td/telegram/SecureManager.cpp b/td/telegram/SecureManager.cpp
index e774073bb..9d53b7483 100644
--- a/td/telegram/SecureManager.cpp
+++ b/td/telegram/SecureManager.cpp
@@ -164,7 +164,7 @@ class SetSecureValueErrorsQuery final : public Td::ResultHandler {
     if (status.code() != 0) {
       promise_.set_error(std::move(status));
     } else {
-      promise_.set_error(Status::Error(400, status.message()));
+      promise_.set_error(400, status.message());
     }
   }
 };
@@ -181,7 +181,7 @@ void GetSecureValue::on_error(Status error) {
   if (error.code() > 0) {
     promise_.set_error(std::move(error));
   } else {
-    promise_.set_error(Status::Error(400, error.message()));
+    promise_.set_error(400, error.message());
   }
   stop();
 }
@@ -260,7 +260,7 @@ void GetAllSecureValues::on_error(Status error) {
   if (error.code() > 0) {
     promise_.set_error(std::move(error));
   } else {
-    promise_.set_error(Status::Error(400, error.message()));
+    promise_.set_error(400, error.message());
   }
   stop();
 }
@@ -395,7 +395,7 @@ void SetSecureValue::on_error(Status error) {
   if (error.code() > 0) {
     promise_.set_error(std::move(error));
   } else {
-    promise_.set_error(Status::Error(400, error.message()));
+    promise_.set_error(400, error.message());
   }
   stop();
 }
@@ -708,7 +708,7 @@ class GetPassportAuthorizationForm final : public NetQueryCallback {
     if (error.code() > 0) {
       promise_.set_error(std::move(error));
     } else {
-      promise_.set_error(Status::Error(400, error.message()));
+      promise_.set_error(400, error.message());
     }
     stop();
   }
@@ -785,7 +785,7 @@ class GetPassportConfig final : public NetQueryCallback {
     auto config = r_result.move_as_ok();
     switch (config->get_id()) {
       case telegram_api::help_passportConfigNotModified::ID:
-        promise_.set_error(Status::Error(500, "Wrong server response"));
+        promise_.set_error(500, "Wrong server response");
         break;
       case telegram_api::help_passportConfig::ID: {
         const string &data =
@@ -799,7 +799,7 @@ class GetPassportConfig final : public NetQueryCallback {
         begin_pos += 4 + country_code_.size();
         auto end_pos = data.find('"', begin_pos);
         if (end_pos == string::npos) {
-          return promise_.set_error(Status::Error(500, "Wrong server response"));
+          return promise_.set_error(500, "Wrong server response");
         }
         promise_.set_value(td_api::make_object<td_api::text>(data.substr(begin_pos, end_pos - begin_pos)));
         break;
@@ -834,7 +834,7 @@ void SecureManager::set_secure_value(string password, SecureValue secure_value,
         auto r_passport_element = get_passport_element_object(file_manager, r_secure_value.move_as_ok().value);
         if (r_passport_element.is_error()) {
           LOG(ERROR) << "Failed to get passport element object: " << r_passport_element.error();
-          return promise.set_error(Status::Error(500, "Failed to get passport element object"));
+          return promise.set_error(500, "Failed to get passport element object");
         }
         promise.set_value(r_passport_element.move_as_ok());
       });
@@ -868,16 +868,16 @@ void SecureManager::set_secure_value_errors(Td *td, tl_object_ptr<telegram_api::
   vector<tl_object_ptr<telegram_api::SecureValueError>> input_errors;
   for (auto &error : errors) {
     if (error == nullptr) {
-      return promise.set_error(Status::Error(400, "Error must be non-empty"));
+      return promise.set_error(400, "Error must be non-empty");
     }
     if (error->type_ == nullptr) {
-      return promise.set_error(Status::Error(400, "Type must be non-empty"));
+      return promise.set_error(400, "Type must be non-empty");
     }
     if (!clean_input_string(error->message_)) {
-      return promise.set_error(Status::Error(400, "Error message must be encoded in UTF-8"));
+      return promise.set_error(400, "Error message must be encoded in UTF-8");
     }
     if (error->source_ == nullptr) {
-      return promise.set_error(Status::Error(400, "Error source must be non-empty"));
+      return promise.set_error(400, "Error source must be non-empty");
     }
 
     auto type = get_input_secure_value_type(get_secure_value_type_td_api(error->type_));
@@ -891,7 +891,7 @@ void SecureManager::set_secure_value_errors(Td *td, tl_object_ptr<telegram_api::
       case td_api::inputPassportElementErrorSourceDataField::ID: {
         auto source = td_api::move_object_as<td_api::inputPassportElementErrorSourceDataField>(error->source_);
         if (!clean_input_string(source->field_name_)) {
-          return promise.set_error(Status::Error(400, "Field name must be encoded in UTF-8"));
+          return promise.set_error(400, "Field name must be encoded in UTF-8");
         }
 
         input_errors.push_back(make_tl_object<telegram_api::secureValueErrorData>(
@@ -925,7 +925,7 @@ void SecureManager::set_secure_value_errors(Td *td, tl_object_ptr<telegram_api::
       case td_api::inputPassportElementErrorSourceTranslationFiles::ID: {
         auto source = td_api::move_object_as<td_api::inputPassportElementErrorSourceTranslationFiles>(error->source_);
         if (source->file_hashes_.empty()) {
-          return promise.set_error(Status::Error(400, "File hashes must be non-empty"));
+          return promise.set_error(400, "File hashes must be non-empty");
         }
         auto file_hashes = transform(source->file_hashes_, [](Slice hash) { return BufferSlice(hash); });
         input_errors.push_back(make_tl_object<telegram_api::secureValueErrorTranslationFiles>(
@@ -941,7 +941,7 @@ void SecureManager::set_secure_value_errors(Td *td, tl_object_ptr<telegram_api::
       case td_api::inputPassportElementErrorSourceFiles::ID: {
         auto source = td_api::move_object_as<td_api::inputPassportElementErrorSourceFiles>(error->source_);
         if (source->file_hashes_.empty()) {
-          return promise.set_error(Status::Error(400, "File hashes must be non-empty"));
+          return promise.set_error(400, "File hashes must be non-empty");
         }
         auto file_hashes = transform(source->file_hashes_, [](Slice hash) { return BufferSlice(hash); });
         input_errors.push_back(make_tl_object<telegram_api::secureValueErrorFiles>(
@@ -1045,11 +1045,11 @@ void SecureManager::get_passport_authorization_form_available_elements(int32 aut
                                                                        Promise<TdApiSecureValuesWithErrors> promise) {
   auto it = authorization_forms_.find(authorization_form_id);
   if (it == authorization_forms_.end()) {
-    return promise.set_error(Status::Error(400, "Unknown authorization_form_id"));
+    return promise.set_error(400, "Unknown authorization_form_id");
   }
   CHECK(it->second != nullptr);
   if (!it->second->is_received) {
-    return promise.set_error(Status::Error(400, "Authorization form isn't received yet"));
+    return promise.set_error(400, "Authorization form isn't received yet");
   }
 
   refcnt_++;
@@ -1066,12 +1066,12 @@ void SecureManager::on_get_passport_authorization_form_secret(int32 authorizatio
                                                               Result<secure_storage::Secret> r_secret) {
   auto it = authorization_forms_.find(authorization_form_id);
   if (it == authorization_forms_.end()) {
-    return promise.set_error(Status::Error(400, "Authorization form has already been sent"));
+    return promise.set_error(400, "Authorization form has already been sent");
   }
   CHECK(it->second != nullptr);
   CHECK(it->second->is_received);
   if (it->second->is_decrypted) {
-    return promise.set_error(Status::Error(400, "Authorization form has already been decrypted"));
+    return promise.set_error(400, "Authorization form has already been decrypted");
   }
 
   if (r_secret.is_error()) {
@@ -1236,15 +1236,15 @@ void SecureManager::send_passport_authorization_form(int32 authorization_form_id
                                                      Promise<> promise) {
   auto it = authorization_forms_.find(authorization_form_id);
   if (it == authorization_forms_.end()) {
-    return promise.set_error(Status::Error(400, "Unknown authorization_form_id"));
+    return promise.set_error(400, "Unknown authorization_form_id");
   }
   CHECK(it->second != nullptr);
   if (!it->second->is_received) {
-    return promise.set_error(Status::Error(400, "Authorization form isn't received yet"));
+    return promise.set_error(400, "Authorization form isn't received yet");
   }
   // there is no need to check for is_decrypted
   if (types.empty()) {
-    return promise.set_error(Status::Error(400, "Types must be non-empty"));
+    return promise.set_error(400, "Types must be non-empty");
   }
 
   std::vector<SecureValueCredentials> credentials;
@@ -1252,7 +1252,7 @@ void SecureManager::send_passport_authorization_form(int32 authorization_form_id
   for (auto type : types) {
     auto value_it = secure_value_cache_.find(type);
     if (value_it == secure_value_cache_.end()) {
-      return promise.set_error(Status::Error(400, "Passport Element with the specified type is not found"));
+      return promise.set_error(400, "Passport Element with the specified type is not found");
     }
     credentials.push_back(value_it->second.credentials);
   }
@@ -1263,7 +1263,7 @@ void SecureManager::send_passport_authorization_form(int32 authorization_form_id
                                                                               BufferSlice(c.hash)));
     auto options_it = it->second->options.find(c.type);
     if (options_it == it->second->options.end()) {
-      return promise.set_error(Status::Error(400, "Passport Element with the specified type was not requested"));
+      return promise.set_error(400, "Passport Element with the specified type was not requested");
     }
     auto &options = options_it->second;
     if (!options.is_selfie_required) {
diff --git a/td/telegram/SponsoredMessageManager.cpp b/td/telegram/SponsoredMessageManager.cpp
index ab1a8a59c..6e5e9f539 100644
--- a/td/telegram/SponsoredMessageManager.cpp
+++ b/td/telegram/SponsoredMessageManager.cpp
@@ -514,7 +514,7 @@ void SponsoredMessageManager::click_sponsored_message(DialogId dialog_id, Messag
                                                       bool is_media_click, bool from_fullscreen,
                                                       Promise<Unit> &&promise) {
   if (!dialog_id.is_valid() || !sponsored_message_id.is_valid_sponsored()) {
-    return promise.set_error(Status::Error(400, "Invalid message specified"));
+    return promise.set_error(400, "Invalid message specified");
   }
   auto it = dialog_sponsored_messages_.find(dialog_id);
   if (it == dialog_sponsored_messages_.end()) {
@@ -534,7 +534,7 @@ void SponsoredMessageManager::report_sponsored_message(
     DialogId dialog_id, MessageId sponsored_message_id, const string &option_id,
     Promise<td_api::object_ptr<td_api::ReportSponsoredResult>> &&promise) {
   if (!dialog_id.is_valid() || !sponsored_message_id.is_valid_sponsored()) {
-    return promise.set_error(Status::Error(400, "Invalid message specified"));
+    return promise.set_error(400, "Invalid message specified");
   }
   auto it = dialog_sponsored_messages_.find(dialog_id);
   if (it == dialog_sponsored_messages_.end()) {
diff --git a/td/telegram/StarGiftManager.cpp b/td/telegram/StarGiftManager.cpp
index b9f477d52..f3e4be24a 100644
--- a/td/telegram/StarGiftManager.cpp
+++ b/td/telegram/StarGiftManager.cpp
@@ -65,7 +65,7 @@ class GetStarGiftsQuery final : public Td::ResultHandler {
     LOG(INFO) << "Receive result for GetStarGiftsQuery: " << to_string(ptr);
     if (ptr->get_id() != telegram_api::payments_starGifts::ID) {
       LOG(ERROR) << "Receive " << to_string(ptr);
-      return promise_.set_error(Status::Error(500, "Receive unexpected response"));
+      return promise_.set_error(500, "Receive unexpected response");
     }
     auto results = telegram_api::move_object_as<telegram_api::payments_starGifts>(ptr);
     vector<td_api::object_ptr<td_api::availableGift>> options;
@@ -188,7 +188,7 @@ class GetGiftPaymentFormQuery final : public Td::ResultHandler {
       case telegram_api::payments_paymentFormStars::ID:
         LOG(ERROR) << "Receive " << to_string(payment_form_ptr);
         td_->star_manager_->add_pending_owned_star_count(star_count_, false);
-        promise_.set_error(Status::Error(500, "Unsupported"));
+        promise_.set_error(500, "Unsupported");
         break;
       case telegram_api::payments_paymentFormStarGift::ID: {
         auto payment_form = static_cast<const telegram_api::payments_paymentFormStarGift *>(payment_form_ptr.get());
@@ -423,18 +423,18 @@ static Promise<Unit> get_gift_upgrade_promise(Td *td, const telegram_api::object
   vector<std::pair<const telegram_api::Message *, bool>> new_messages = UpdatesManager::get_new_messages(updates.get());
   if (new_messages.size() != 1u || new_messages[0].second ||
       new_messages[0].first->get_id() != telegram_api::messageService::ID) {
-    promise.set_error(Status::Error(500, "Receive invalid server response"));
+    promise.set_error(500, "Receive invalid server response");
     return Auto();
   }
   auto message = static_cast<const telegram_api::messageService *>(new_messages[0].first);
   if (message->action_->get_id() != telegram_api::messageActionStarGiftUnique::ID) {
-    promise.set_error(Status::Error(500, "Receive invalid server response"));
+    promise.set_error(500, "Receive invalid server response");
     return Auto();
   }
   auto action = static_cast<const telegram_api::messageActionStarGiftUnique *>(message->action_.get());
   if (!action->upgrade_ || action->transferred_ || action->refunded_ ||
       action->gift_->get_id() != telegram_api::starGiftUnique::ID) {
-    promise.set_error(Status::Error(500, "Receive invalid server response"));
+    promise.set_error(500, "Receive invalid server response");
     return Auto();
   }
   auto message_full_id = MessageFullId::get_message_full_id(new_messages[0].first, false);
@@ -573,14 +573,14 @@ class GetGiftUpgradePaymentFormQuery final : public Td::ResultHandler {
       case telegram_api::payments_paymentFormStars::ID:
         LOG(ERROR) << "Receive " << to_string(payment_form_ptr);
         td_->star_manager_->add_pending_owned_star_count(star_count_, false);
-        promise_.set_error(Status::Error(500, "Unsupported"));
+        promise_.set_error(500, "Unsupported");
         break;
       case telegram_api::payments_paymentFormStarGift::ID: {
         auto payment_form = static_cast<const telegram_api::payments_paymentFormStarGift *>(payment_form_ptr.get());
         if (payment_form->invoice_->prices_.size() != 1u ||
             payment_form->invoice_->prices_[0]->amount_ != star_count_) {
           td_->star_manager_->add_pending_owned_star_count(star_count_, false);
-          return promise_.set_error(Status::Error(400, "Wrong upgrade price specified"));
+          return promise_.set_error(400, "Wrong upgrade price specified");
         }
         td_->create_handler<UpgradeGiftQuery>(std::move(promise_))
             ->send(business_connection_id_, std::move(upgrade_input_invoice_), payment_form->form_id_, star_count_);
@@ -720,14 +720,14 @@ class GetGiftTransferPaymentFormQuery final : public Td::ResultHandler {
       case telegram_api::payments_paymentFormStars::ID:
         LOG(ERROR) << "Receive " << to_string(payment_form_ptr);
         td_->star_manager_->add_pending_owned_star_count(star_count_, false);
-        promise_.set_error(Status::Error(500, "Unsupported"));
+        promise_.set_error(500, "Unsupported");
         break;
       case telegram_api::payments_paymentFormStarGift::ID: {
         auto payment_form = static_cast<const telegram_api::payments_paymentFormStarGift *>(payment_form_ptr.get());
         if (payment_form->invoice_->prices_.size() != 1u ||
             payment_form->invoice_->prices_[0]->amount_ != star_count_) {
           td_->star_manager_->add_pending_owned_star_count(star_count_, false);
-          return promise_.set_error(Status::Error(400, "Wrong transfer price specified"));
+          return promise_.set_error(400, "Wrong transfer price specified");
         }
         td_->create_handler<TransferGiftQuery>(std::move(promise_))
             ->send(business_connection_id_, std::move(transfer_input_invoice_), payment_form->form_id_, star_count_);
@@ -824,14 +824,14 @@ class GetGiftResalePaymentFormQuery final : public Td::ResultHandler {
       case telegram_api::payments_paymentFormStars::ID:
         LOG(ERROR) << "Receive " << to_string(payment_form_ptr);
         td_->star_manager_->add_pending_owned_star_count(star_count_, false);
-        promise_.set_error(Status::Error(500, "Unsupported"));
+        promise_.set_error(500, "Unsupported");
         break;
       case telegram_api::payments_paymentFormStarGift::ID: {
         auto payment_form = static_cast<const telegram_api::payments_paymentFormStarGift *>(payment_form_ptr.get());
         if (payment_form->invoice_->prices_.size() != 1u ||
             payment_form->invoice_->prices_[0]->amount_ != star_count_) {
           td_->star_manager_->add_pending_owned_star_count(star_count_, false);
-          return promise_.set_error(Status::Error(400, "Wrong resale price specified"));
+          return promise_.set_error(400, "Wrong resale price specified");
         }
         td_->create_handler<ResaleGiftQuery>(std::move(promise_))
             ->send(std::move(resale_input_invoice_), payment_form->form_id_, star_count_);
@@ -959,7 +959,7 @@ class GetSavedStarGiftQuery final : public Td::ResultHandler {
       }
       return promise_.set_value(user_gift.get_received_gift_object(td_));
     }
-    promise_.set_error(Status::Error(400, "Gift not found"));
+    promise_.set_error(400, "Gift not found");
   }
 
   void on_error(Status status) final {
@@ -993,7 +993,7 @@ class GetUniqueStarGiftQuery final : public Td::ResultHandler {
     StarGift star_gift(td_, std::move(ptr->gift_), true);
     if (!star_gift.is_valid() || !star_gift.is_unique()) {
       LOG(ERROR) << "Receive invalid user gift";
-      return promise_.set_error(Status::Error(400, "Gift not found"));
+      return promise_.set_error(400, "Gift not found");
     }
     promise_.set_value(star_gift.get_upgraded_gift_object(td_));
   }
@@ -1264,20 +1264,20 @@ void StarGiftManager::send_gift(int64 gift_id, DialogId dialog_id, td_api::objec
   if (!td_->auth_manager_->is_bot()) {
     auto it = gift_prices_.find(gift_id);
     if (it == gift_prices_.end()) {
-      return promise.set_error(Status::Error(400, "Gift not found"));
+      return promise.set_error(400, "Gift not found");
     }
     star_count = it->second.first;
     if (pay_for_upgrade) {
       star_count += it->second.second;
     }
     if (!td_->star_manager_->has_owned_star_count(star_count)) {
-      return promise.set_error(Status::Error(400, "Have not enough Telegram Stars"));
+      return promise.set_error(400, "Have not enough Telegram Stars");
     }
   }
   auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
   auto send_input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
   if (input_peer == nullptr || send_input_peer == nullptr) {
-    return promise.set_error(Status::Error(400, "Have no access to the gift receiver"));
+    return promise.set_error(400, "Have no access to the gift receiver");
   }
   TRY_RESULT_PROMISE(
       promise, message,
@@ -1305,7 +1305,7 @@ void StarGiftManager::convert_gift(BusinessConnectionId business_connection_id,
     TRY_STATUS_PROMISE(promise, td_->business_connection_manager_->check_business_connection(business_connection_id));
   }
   if (star_gift_id.get_input_saved_star_gift(td_) == nullptr) {
-    return promise.set_error(Status::Error(400, "Invalid gift identifier specified"));
+    return promise.set_error(400, "Invalid gift identifier specified");
   }
   auto dialog_id =
       business_connection_id.is_valid()
@@ -1325,7 +1325,7 @@ void StarGiftManager::convert_gift(BusinessConnectionId business_connection_id,
 
 void StarGiftManager::save_gift(StarGiftId star_gift_id, bool is_saved, Promise<Unit> &&promise) {
   if (star_gift_id.get_input_saved_star_gift(td_) == nullptr) {
-    return promise.set_error(Status::Error(400, "Invalid gift identifier specified"));
+    return promise.set_error(400, "Invalid gift identifier specified");
   }
   td_->create_handler<SaveStarGiftQuery>(std::move(promise))->send(star_gift_id, is_saved);
 }
@@ -1334,10 +1334,10 @@ void StarGiftManager::set_dialog_pinned_gifts(DialogId dialog_id, const vector<S
                                               Promise<Unit> &&promise) {
   for (const auto &star_gift_id : star_gift_ids) {
     if (star_gift_id.get_input_saved_star_gift(td_) == nullptr) {
-      return promise.set_error(Status::Error(400, "Invalid gift identifier specified"));
+      return promise.set_error(400, "Invalid gift identifier specified");
     }
     if (star_gift_id.get_dialog_id(td_) != dialog_id) {
-      return promise.set_error(Status::Error(400, "The gift is not from the chat"));
+      return promise.set_error(400, "The gift is not from the chat");
     }
   }
   td_->create_handler<ToggleStarGiftsPinnedToTopQuery>(std::move(promise))->send(dialog_id, star_gift_ids);
@@ -1349,7 +1349,7 @@ void StarGiftManager::toggle_chat_star_gift_notifications(DialogId dialog_id, bo
                                                                         "toggle_chat_star_gift_notifications"));
   if (!td_->dialog_manager_->is_broadcast_channel(dialog_id) ||
       !td_->chat_manager_->get_channel_status(dialog_id.get_channel_id()).can_post_messages()) {
-    return promise.set_error(Status::Error(400, "Wrong chat specified"));
+    return promise.set_error(400, "Wrong chat specified");
   }
   td_->create_handler<ToggleChatStarGiftNotificationsQuery>(std::move(promise))->send(dialog_id, are_enabled);
 }
@@ -1368,14 +1368,14 @@ void StarGiftManager::upgrade_gift(BusinessConnectionId business_connection_id,
   }
   auto input_saved_star_gift = star_gift_id.get_input_saved_star_gift(td_);
   if (input_saved_star_gift == nullptr) {
-    return promise.set_error(Status::Error(400, "Invalid gift identifier specified"));
+    return promise.set_error(400, "Invalid gift identifier specified");
   }
   if (star_count < 0) {
-    return promise.set_error(Status::Error(400, "Invalid amount of Telegram Stars specified"));
+    return promise.set_error(400, "Invalid amount of Telegram Stars specified");
   }
   if (star_count != 0) {
     if (!as_business && !td_->star_manager_->has_owned_star_count(star_count)) {
-      return promise.set_error(Status::Error(400, "Have not enough Telegram Stars"));
+      return promise.set_error(400, "Have not enough Telegram Stars");
     }
     auto input_invoice = telegram_api::make_object<telegram_api::inputInvoiceStarGiftUpgrade>(
         0, keep_original_details, std::move(input_saved_star_gift));
@@ -1399,14 +1399,14 @@ void StarGiftManager::transfer_gift(BusinessConnectionId business_connection_id,
   auto input_peer = td_->dialog_manager_->get_input_peer(receiver_dialog_id, access_rights);
   auto transfer_input_peer = td_->dialog_manager_->get_input_peer(receiver_dialog_id, access_rights);
   if (input_peer == nullptr || transfer_input_peer == nullptr) {
-    return promise.set_error(Status::Error(400, "Have no access to the new gift owner"));
+    return promise.set_error(400, "Have no access to the new gift owner");
   }
   auto input_saved_star_gift = star_gift_id.get_input_saved_star_gift(td_);
   if (input_saved_star_gift == nullptr) {
-    return promise.set_error(Status::Error(400, "Invalid gift identifier specified"));
+    return promise.set_error(400, "Invalid gift identifier specified");
   }
   if (star_count < 0) {
-    return promise.set_error(Status::Error(400, "Invalid amount of Telegram Stars specified"));
+    return promise.set_error(400, "Invalid amount of Telegram Stars specified");
   }
   auto dialog_id =
       as_business ? DialogId(td_->business_connection_manager_->get_business_connection_user_id(business_connection_id))
@@ -1421,7 +1421,7 @@ void StarGiftManager::transfer_gift(BusinessConnectionId business_connection_id,
   });
   if (star_count != 0) {
     if (!as_business && !td_->star_manager_->has_owned_star_count(star_count)) {
-      return query_promise.set_error(Status::Error(400, "Have not enough Telegram Stars"));
+      return query_promise.set_error(400, "Have not enough Telegram Stars");
     }
     auto input_invoice = telegram_api::make_object<telegram_api::inputInvoiceStarGiftTransfer>(
         std::move(input_saved_star_gift), std::move(input_peer));
@@ -1457,13 +1457,13 @@ void StarGiftManager::send_resold_gift(const string &gift_name, DialogId receive
   auto input_peer = td_->dialog_manager_->get_input_peer(receiver_dialog_id, AccessRights::Read);
   auto resale_input_peer = td_->dialog_manager_->get_input_peer(receiver_dialog_id, AccessRights::Read);
   if (input_peer == nullptr || resale_input_peer == nullptr) {
-    return promise.set_error(Status::Error(400, "Have no access to the new gift owner"));
+    return promise.set_error(400, "Have no access to the new gift owner");
   }
   if (star_count < 0) {
-    return promise.set_error(Status::Error(400, "Invalid amount of Telegram Stars specified"));
+    return promise.set_error(400, "Invalid amount of Telegram Stars specified");
   }
   if (!td_->star_manager_->has_owned_star_count(star_count)) {
-    return promise.set_error(Status::Error(400, "Have not enough Telegram Stars"));
+    return promise.set_error(400, "Have not enough Telegram Stars");
   }
   auto input_invoice =
       telegram_api::make_object<telegram_api::inputInvoiceStarGiftResale>(gift_name, std::move(input_peer));
@@ -1479,7 +1479,7 @@ void StarGiftManager::get_saved_star_gifts(BusinessConnectionId business_connect
                                            const string &offset, int32 limit,
                                            Promise<td_api::object_ptr<td_api::receivedGifts>> &&promise) {
   if (limit < 0) {
-    return promise.set_error(Status::Error(400, "Limit must be non-negative"));
+    return promise.set_error(400, "Limit must be non-negative");
   }
   if (business_connection_id.is_valid()) {
     TRY_STATUS_PROMISE(promise, td_->business_connection_manager_->check_business_connection(business_connection_id));
@@ -1492,7 +1492,7 @@ void StarGiftManager::get_saved_star_gifts(BusinessConnectionId business_connect
 void StarGiftManager::get_saved_star_gift(StarGiftId star_gift_id,
                                           Promise<td_api::object_ptr<td_api::receivedGift>> &&promise) {
   if (!star_gift_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid gift identifier specified"));
+    return promise.set_error(400, "Invalid gift identifier specified");
   }
   td_->create_handler<GetSavedStarGiftQuery>(std::move(promise))->send(star_gift_id);
 }
@@ -1505,10 +1505,10 @@ void StarGiftManager::get_upgraded_gift(const string &name,
 void StarGiftManager::get_star_gift_withdrawal_url(StarGiftId star_gift_id, const string &password,
                                                    Promise<string> &&promise) {
   if (!star_gift_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid gift identifier specified"));
+    return promise.set_error(400, "Invalid gift identifier specified");
   }
   if (password.empty()) {
-    return promise.set_error(Status::Error(400, "PASSWORD_HASH_INVALID"));
+    return promise.set_error(400, "PASSWORD_HASH_INVALID");
   }
   send_closure(
       td_->password_manager_, &PasswordManager::get_input_check_password_srp, password,
@@ -1533,12 +1533,12 @@ void StarGiftManager::send_get_star_gift_withdrawal_url_query(
 
 void StarGiftManager::set_star_gift_price(StarGiftId star_gift_id, int64 resale_star_count, Promise<Unit> &&promise) {
   if (!star_gift_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid gift identifier specified"));
+    return promise.set_error(400, "Invalid gift identifier specified");
   }
   if ((resale_star_count != 0 &&
        resale_star_count < td_->option_manager_->get_option_integer("gift_resale_star_count_min")) ||
       resale_star_count > td_->option_manager_->get_option_integer("gift_resale_star_count_max")) {
-    return promise.set_error(Status::Error(400, "Invalid resale price specified"));
+    return promise.set_error(400, "Invalid resale price specified");
   }
 
   td_->create_handler<UpdateStarGiftPriceQuery>(std::move(promise))->send(star_gift_id, resale_star_count);
@@ -1549,10 +1549,10 @@ void StarGiftManager::get_resale_star_gifts(
     const vector<td_api::object_ptr<td_api::UpgradedGiftAttributeId>> &attributes, const string &offset, int32 limit,
     Promise<td_api::object_ptr<td_api::giftsForResale>> &&promise) {
   if (limit < 0) {
-    return promise.set_error(Status::Error(400, "Limit must be non-negative"));
+    return promise.set_error(400, "Limit must be non-negative");
   }
   if (order == nullptr) {
-    return promise.set_error(Status::Error(400, "Gift sort order must be non-empty"));
+    return promise.set_error(400, "Gift sort order must be non-empty");
   }
   TRY_RESULT_PROMISE(promise, attribute_ids, StarGiftAttributeId::get_star_gift_attribute_ids(attributes));
 
diff --git a/td/telegram/StarManager.cpp b/td/telegram/StarManager.cpp
index a99e6475d..a67bfcbe3 100644
--- a/td/telegram/StarManager.cpp
+++ b/td/telegram/StarManager.cpp
@@ -1182,7 +1182,7 @@ void StarManager::get_star_transactions(td_api::object_ptr<td_api::MessageSender
   TRY_RESULT_PROMISE(promise, dialog_id, get_message_sender_dialog_id(td_, owner_id, true, false));
   TRY_STATUS_PROMISE(promise, can_manage_stars(dialog_id, true));
   if (limit < 0) {
-    return promise.set_error(Status::Error(400, "Limit must be non-negative"));
+    return promise.set_error(400, "Limit must be non-negative");
   }
   td_->stickers_manager_->load_premium_gift_sticker_set(PromiseCreator::lambda(
       [actor_id = actor_id(this), dialog_id, subscription_id, offset, limit, direction = std::move(direction),
@@ -1246,7 +1246,7 @@ void StarManager::get_star_withdrawal_url(const td_api::object_ptr<td_api::Messa
   TRY_RESULT_PROMISE(promise, dialog_id, get_message_sender_dialog_id(td_, owner_id, true, false));
   TRY_STATUS_PROMISE(promise, can_manage_stars(dialog_id, true));
   if (password.empty()) {
-    return promise.set_error(Status::Error(400, "PASSWORD_HASH_INVALID"));
+    return promise.set_error(400, "PASSWORD_HASH_INVALID");
   }
   send_closure(
       td_->password_manager_, &PasswordManager::get_input_check_password_srp, password,
diff --git a/td/telegram/StatisticsManager.cpp b/td/telegram/StatisticsManager.cpp
index 912236065..6cc77534a 100644
--- a/td/telegram/StatisticsManager.cpp
+++ b/td/telegram/StatisticsManager.cpp
@@ -460,7 +460,7 @@ class GetMessageStatsQuery final : public Td::ResultHandler {
 
     auto input_channel = td_->chat_manager_->get_input_channel(channel_id);
     if (input_channel == nullptr) {
-      return promise_.set_error(Status::Error(400, "Supergroup not found"));
+      return promise_.set_error(400, "Supergroup not found");
     }
 
     send_query(
@@ -504,7 +504,7 @@ class GetStoryStatsQuery final : public Td::ResultHandler {
 
     auto input_peer = td_->dialog_manager_->get_input_peer(DialogId(channel_id), AccessRights::Read);
     if (input_peer == nullptr) {
-      return promise_.set_error(Status::Error(400, "Chat not found"));
+      return promise_.set_error(400, "Chat not found");
     }
 
     send_query(G()->net_query_creator().create(
@@ -692,7 +692,7 @@ void StatisticsManager::get_dialog_revenue_withdrawal_url(DialogId dialog_id, co
   TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Write,
                                                                         "get_dialog_revenue_withdrawal_url"));
   if (password.empty()) {
-    return promise.set_error(Status::Error(400, "PASSWORD_HASH_INVALID"));
+    return promise.set_error(400, "PASSWORD_HASH_INVALID");
   }
   send_closure(
       td_->password_manager_, &PasswordManager::get_input_check_password_srp, password,
@@ -742,10 +742,10 @@ void StatisticsManager::send_get_channel_message_stats_query(
 
   auto dialog_id = message_full_id.get_dialog_id();
   if (!td_->messages_manager_->have_message_force(message_full_id, "send_get_channel_message_stats_query")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!td_->messages_manager_->can_get_message_statistics(message_full_id)) {
-    return promise.set_error(Status::Error(400, "Message statistics are inaccessible"));
+    return promise.set_error(400, "Message statistics are inaccessible");
   }
   CHECK(dialog_id.get_type() == DialogType::Channel);
   td_->create_handler<GetMessageStatsQuery>(std::move(promise))
@@ -772,10 +772,10 @@ void StatisticsManager::send_get_channel_story_stats_query(
 
   auto dialog_id = story_full_id.get_dialog_id();
   if (!td_->story_manager_->have_story_force(story_full_id)) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (!td_->story_manager_->can_get_story_statistics(story_full_id)) {
-    return promise.set_error(Status::Error(400, "Story statistics are inaccessible"));
+    return promise.set_error(400, "Story statistics are inaccessible");
   }
   CHECK(dialog_id.get_type() == DialogType::Channel);
   td_->create_handler<GetStoryStatsQuery>(std::move(promise))
@@ -805,7 +805,7 @@ void StatisticsManager::send_load_async_graph_query(DcId dc_id, string token, in
 void StatisticsManager::get_message_public_forwards(MessageFullId message_full_id, string offset, int32 limit,
                                                     Promise<td_api::object_ptr<td_api::publicForwards>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
 
   auto dc_id_promise = PromiseCreator::lambda([actor_id = actor_id(this), message_full_id, offset = std::move(offset),
@@ -823,10 +823,10 @@ void StatisticsManager::send_get_message_public_forwards_query(
     DcId dc_id, MessageFullId message_full_id, string offset, int32 limit,
     Promise<td_api::object_ptr<td_api::publicForwards>> &&promise) {
   if (!td_->messages_manager_->have_message_force(message_full_id, "send_get_message_public_forwards_query")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
   if (!td_->messages_manager_->can_get_message_statistics(message_full_id)) {
-    return promise.set_error(Status::Error(400, "Message forwards are inaccessible"));
+    return promise.set_error(400, "Message forwards are inaccessible");
   }
 
   static constexpr int32 MAX_MESSAGE_FORWARDS = 100;  // server-side limit
@@ -840,12 +840,12 @@ void StatisticsManager::send_get_message_public_forwards_query(
 void StatisticsManager::get_story_public_forwards(StoryFullId story_full_id, string offset, int32 limit,
                                                   Promise<td_api::object_ptr<td_api::publicForwards>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   auto dialog_id = story_full_id.get_dialog_id();
   if (dialog_id.get_type() == DialogType::User) {
     if (dialog_id != td_->dialog_manager_->get_my_dialog_id()) {
-      return promise.set_error(Status::Error(400, "Have no access to story statistics"));
+      return promise.set_error(400, "Have no access to story statistics");
     }
     return send_get_story_public_forwards_query(DcId::main(), story_full_id, std::move(offset), limit,
                                                 std::move(promise));
@@ -866,11 +866,11 @@ void StatisticsManager::send_get_story_public_forwards_query(
     DcId dc_id, StoryFullId story_full_id, string offset, int32 limit,
     Promise<td_api::object_ptr<td_api::publicForwards>> &&promise) {
   if (!td_->story_manager_->have_story_force(story_full_id)) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (!td_->story_manager_->can_get_story_statistics(story_full_id) &&
       story_full_id.get_dialog_id() != td_->dialog_manager_->get_my_dialog_id()) {
-    return promise.set_error(Status::Error(400, "Story forwards are inaccessible"));
+    return promise.set_error(400, "Story forwards are inaccessible");
   }
 
   static constexpr int32 MAX_STORY_FORWARDS = 100;  // server-side limit
diff --git a/td/telegram/StickersManager.cpp b/td/telegram/StickersManager.cpp
index 83961b592..af95f9b16 100644
--- a/td/telegram/StickersManager.cpp
+++ b/td/telegram/StickersManager.cpp
@@ -455,7 +455,7 @@ class GetAttachedStickerSetsQuery final : public Td::ResultHandler {
           file_id_,
           PromiseCreator::lambda([file_id = file_id_, promise = std::move(promise_)](Result<Unit> result) mutable {
             if (result.is_error()) {
-              return promise.set_error(Status::Error(400, "Failed to find the file"));
+              return promise.set_error(400, "Failed to find the file");
             }
 
             send_closure(G()->stickers_manager(), &StickersManager::send_get_attached_stickers_query, file_id,
@@ -545,7 +545,7 @@ class SaveRecentStickerQuery final : public Td::ResultHandler {
           file_id_, PromiseCreator::lambda([sticker_id = file_id_, is_attached = is_attached_, unsave = unsave_,
                                             promise = std::move(promise_)](Result<Unit> result) mutable {
             if (result.is_error()) {
-              return promise.set_error(Status::Error(400, "Failed to find the sticker"));
+              return promise.set_error(400, "Failed to find the sticker");
             }
 
             send_closure(G()->stickers_manager(), &StickersManager::send_save_recent_sticker_query, is_attached,
@@ -670,7 +670,7 @@ class FaveStickerQuery final : public Td::ResultHandler {
           file_id_, PromiseCreator::lambda([sticker_id = file_id_, unsave = unsave_,
                                             promise = std::move(promise_)](Result<Unit> result) mutable {
             if (result.is_error()) {
-              return promise.set_error(Status::Error(400, "Failed to find the sticker"));
+              return promise.set_error(400, "Failed to find the sticker");
             }
 
             send_closure(G()->stickers_manager(), &StickersManager::send_fave_sticker_query, sticker_id, unsave,
@@ -4131,7 +4131,7 @@ vector<FileId> StickersManager::get_stickers(StickerType sticker_type, string qu
   }
 
   if (limit <= 0) {
-    promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    promise.set_error(400, "Parameter limit must be positive");
     return {};
   }
 
@@ -4416,13 +4416,13 @@ void StickersManager::search_stickers(StickerType sticker_type, string emoji, co
                                       const vector<string> &input_language_codes, int32 offset, int32 limit,
                                       Promise<td_api::object_ptr<td_api::stickers>> &&promise) {
   if (offset < 0) {
-    return promise.set_error(Status::Error(400, "Parameter offset must be non-negative"));
+    return promise.set_error(400, "Parameter offset must be non-negative");
   }
   if (limit == 0) {
     return promise.set_value(get_stickers_object({}));
   }
   if (limit < 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_FOUND_STICKERS) {
     limit = MAX_FOUND_STICKERS;
@@ -4834,7 +4834,7 @@ StickerSetId StickersManager::get_sticker_set(StickerSetId set_id, Promise<Unit>
       return StickerSetId();
     }
 
-    promise.set_error(Status::Error(400, "Sticker set not found"));
+    promise.set_error(400, "Sticker set not found");
     return StickerSetId();
   }
 
@@ -4854,7 +4854,7 @@ void StickersManager::get_sticker_set_name(StickerSetId set_id, Promise<string>
 
   const StickerSet *sticker_set = get_sticker_set(set_id);
   if (sticker_set == nullptr) {
-    return promise.set_error(Status::Error(400, "Sticker set not found"));
+    return promise.set_error(400, "Sticker set not found");
   }
   if (!sticker_set->short_name_.empty()) {
     return promise.set_value(string(sticker_set->short_name_));
@@ -4892,7 +4892,7 @@ std::pair<int32, vector<StickerSetId>> StickersManager::search_installed_sticker
             << "\" and limit = " << limit;
 
   if (limit < 0) {
-    promise.set_error(Status::Error(400, "Limit must be non-negative"));
+    promise.set_error(400, "Limit must be non-negative");
     return {};
   }
 
@@ -5001,11 +5001,11 @@ void StickersManager::on_find_sticker_sets_fail(StickerType sticker_type, const
 void StickersManager::change_sticker_set(StickerSetId set_id, bool is_installed, bool is_archived,
                                          Promise<Unit> &&promise) {
   if (is_installed && is_archived) {
-    return promise.set_error(Status::Error(400, "Sticker set can't be installed and archived simultaneously"));
+    return promise.set_error(400, "Sticker set can't be installed and archived simultaneously");
   }
   const StickerSet *sticker_set = get_sticker_set(set_id);
   if (sticker_set == nullptr) {
-    return promise.set_error(Status::Error(400, "Sticker set not found"));
+    return promise.set_error(400, "Sticker set not found");
   }
   if (!sticker_set->is_inited_) {
     load_sticker_sets({set_id}, std::move(promise));
@@ -6315,7 +6315,7 @@ void StickersManager::get_custom_emoji_stickers(vector<CustomEmojiId> custom_emo
   TRY_STATUS_PROMISE(promise, G()->close_status());
 
   if (custom_emoji_ids.size() > MAX_GET_CUSTOM_EMOJI_STICKERS) {
-    return promise.set_error(Status::Error(400, "Too many custom emoji identifiers specified"));
+    return promise.set_error(400, "Too many custom emoji identifiers specified");
   }
 
   FlatHashSet<CustomEmojiId, CustomEmojiIdHash> unique_custom_emoji_ids;
@@ -6637,7 +6637,7 @@ void StickersManager::choose_animated_emoji_click_sticker(const StickerSet *stic
   CHECK(sticker_set->was_loaded_);
   remove_emoji_modifiers_in_place(message_text);
   if (message_text.empty()) {
-    return promise.set_error(Status::Error(400, "Message is not an animated emoji message"));
+    return promise.set_error(400, "Message is not an animated emoji message");
   }
 
   if (disable_animated_emojis_ || td_->auth_manager_->is_bot()) {
@@ -6991,7 +6991,7 @@ std::pair<int32, vector<StickerSetId>> StickersManager::get_archived_sticker_set
                                                                                   int32 limit, bool force,
                                                                                   Promise<Unit> &&promise) {
   if (limit <= 0) {
-    promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    promise.set_error(400, "Parameter limit must be positive");
     return {};
   }
 
@@ -7078,12 +7078,12 @@ td_api::object_ptr<td_api::trendingStickerSets> StickersManager::get_featured_st
                                                                                            int32 offset, int32 limit,
                                                                                            Promise<Unit> &&promise) {
   if (offset < 0) {
-    promise.set_error(Status::Error(400, "Parameter offset must be non-negative"));
+    promise.set_error(400, "Parameter offset must be non-negative");
     return {};
   }
 
   if (limit < 0) {
-    promise.set_error(Status::Error(400, "Parameter limit must be non-negative"));
+    promise.set_error(400, "Parameter limit must be non-negative");
     return {};
   }
   if (limit == 0) {
@@ -7130,8 +7130,7 @@ td_api::object_ptr<td_api::trendingStickerSets> StickersManager::get_featured_st
       return get_trending_sticker_sets_object(sticker_type, {begin, begin + limit});
     }
     if (offset > set_count) {
-      promise.set_error(
-          Status::Error(400, "Too big offset specified; trending sticker sets can be received only consequently"));
+      promise.set_error(400, "Too big offset specified; trending sticker sets can be received only consequently");
       return {};
     }
 
@@ -7504,7 +7503,7 @@ void StickersManager::on_load_old_featured_sticker_sets_finished(StickerType sti
 
 vector<StickerSetId> StickersManager::get_attached_sticker_sets(FileId file_id, Promise<Unit> &&promise) {
   if (!file_id.is_valid()) {
-    promise.set_error(Status::Error(400, "Wrong file_id specified"));
+    promise.set_error(400, "Wrong file_id specified");
     return {};
   }
 
@@ -7521,7 +7520,7 @@ vector<StickerSetId> StickersManager::get_attached_sticker_sets(FileId file_id,
 void StickersManager::send_get_attached_stickers_query(FileId file_id, Promise<Unit> &&promise) {
   auto file_view = td_->file_manager_->get_file_view(file_id);
   if (file_view.empty()) {
-    return promise.set_error(Status::Error(400, "File not found"));
+    return promise.set_error(400, "File not found");
   }
   const auto *full_remote_location = file_view.get_full_remote_location();
   if (full_remote_location == nullptr || (!full_remote_location->is_document() && !full_remote_location->is_photo()) ||
@@ -7669,7 +7668,7 @@ void StickersManager::reorder_installed_sticker_sets(StickerType sticker_type,
                                                      Promise<Unit> &&promise) {
   auto result = apply_installed_sticker_sets_order(sticker_type, sticker_set_ids);
   if (result < 0) {
-    return promise.set_error(Status::Error(400, "Wrong sticker set list"));
+    return promise.set_error(400, "Wrong sticker set list");
   }
   if (result > 0) {
     auto type = static_cast<int32>(sticker_type);
@@ -7843,7 +7842,7 @@ void StickersManager::finish_upload_sticker_file(FileId file_id, Promise<td_api:
   FileView file_view = td_->file_manager_->get_file_view(file_id);
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (main_remote_location == nullptr) {
-    return promise.set_error(Status::Error(500, "Failed to upload the file"));
+    return promise.set_error(500, "Failed to upload the file");
   }
 
   promise.set_value(td_->file_manager_->get_file_object(file_id));
@@ -7879,7 +7878,7 @@ Result<telegram_api::object_ptr<telegram_api::inputStickerSetItem>> StickersMana
 void StickersManager::get_suggested_sticker_set_name(string title, Promise<string> &&promise) {
   title = strip_empty_characters(title, MAX_STICKER_SET_TITLE_LENGTH);
   if (title.empty()) {
-    return promise.set_error(Status::Error(400, "Sticker set title must be non-empty"));
+    return promise.set_error(400, "Sticker set title must be non-empty");
   }
 
   td_->create_handler<SuggestStickerSetShortNameQuery>(std::move(promise))->send(title);
@@ -7937,20 +7936,20 @@ void StickersManager::create_new_sticker_set(UserId user_id, string title, strin
 
   title = strip_empty_characters(title, MAX_STICKER_SET_TITLE_LENGTH);
   if (title.empty()) {
-    return promise.set_error(Status::Error(400, "Sticker set title must be non-empty"));
+    return promise.set_error(400, "Sticker set title must be non-empty");
   }
 
   short_name = strip_empty_characters(short_name, MAX_STICKER_SET_SHORT_NAME_LENGTH);
   if (short_name.empty() && is_bot) {
-    return promise.set_error(Status::Error(400, "Sticker set name must be non-empty"));
+    return promise.set_error(400, "Sticker set name must be non-empty");
   }
 
   if (stickers.empty()) {
-    return promise.set_error(Status::Error(400, "At least 1 sticker must be specified"));
+    return promise.set_error(400, "At least 1 sticker must be specified");
   }
 
   if (has_text_color && sticker_type != StickerType::CustomEmoji) {
-    return promise.set_error(Status::Error(400, "Only custom emoji stickers support repainting"));
+    return promise.set_error(400, "Only custom emoji stickers support repainting");
   }
 
   vector<FileId> file_ids;
@@ -8048,8 +8047,8 @@ void StickersManager::on_upload_sticker_file_error(FileUploadId file_upload_id,
   auto promise = std::move(it->second.second);
   being_uploaded_files_.erase(it);
 
-  promise.set_error(Status::Error(status.code() > 0 ? status.code() : 500,
-                                  status.message()));  // TODO CHECK that status has always a code
+  promise.set_error(status.code() > 0 ? status.code() : 500,
+                    status.message());  // TODO CHECK that status has always a code
 }
 
 void StickersManager::do_upload_sticker_file(UserId user_id, FileUploadId file_upload_id,
@@ -8063,7 +8062,7 @@ void StickersManager::do_upload_sticker_file(UserId user_id, FileUploadId file_u
     if (input_file != nullptr) {
       td_->file_manager_->cancel_upload(file_upload_id);
     }
-    return promise.set_error(Status::Error(400, "Have no access to the user"));
+    return promise.set_error(400, "Have no access to the user");
   }
 
   FileView file_view = td_->file_manager_->get_file_view(file_upload_id.get_file_id());
@@ -8092,7 +8091,7 @@ void StickersManager::on_uploaded_sticker_file(FileUploadId file_upload_id, bool
   LOG(INFO) << "Receive uploaded sticker file " << to_string(media);
   if (media->get_id() != telegram_api::messageMediaDocument::ID) {
     td_->file_manager_->delete_partial_remote_location(file_upload_id);
-    return promise.set_error(Status::Error(400, "Can't upload sticker file: wrong file type"));
+    return promise.set_error(400, "Can't upload sticker file: wrong file type");
   }
 
   auto message_document = move_tl_object_as<telegram_api::messageMediaDocument>(media);
@@ -8100,7 +8099,7 @@ void StickersManager::on_uploaded_sticker_file(FileUploadId file_upload_id, bool
   int32 document_id = document_ptr->get_id();
   if (document_id == telegram_api::documentEmpty::ID) {
     td_->file_manager_->delete_partial_remote_location(file_upload_id);
-    return promise.set_error(Status::Error(400, "Can't upload sticker file: empty file"));
+    return promise.set_error(400, "Can't upload sticker file: empty file");
   }
   CHECK(document_id == telegram_api::document::ID);
 
@@ -8133,7 +8132,7 @@ void StickersManager::on_uploaded_sticker_file(FileUploadId file_upload_id, bool
       return promise.set_value(Unit());
     }
     td_->file_manager_->delete_partial_remote_location(file_upload_id);
-    return promise.set_error(Status::Error(400, "Wrong file type"));
+    return promise.set_error(400, "Wrong file type");
   }
 
   if (parsed_document.file_id != file_id) {
@@ -8211,7 +8210,7 @@ void StickersManager::add_sticker_to_set(UserId user_id, string short_name,
 
   short_name = clean_username(strip_empty_characters(short_name, MAX_STICKER_SET_SHORT_NAME_LENGTH));
   if (short_name.empty()) {
-    return promise.set_error(Status::Error(400, "Sticker set name must be non-empty"));
+    return promise.set_error(400, "Sticker set name must be non-empty");
   }
 
   const StickerSet *sticker_set = get_sticker_set(short_name_to_sticker_set_id_.get(short_name));
@@ -8242,7 +8241,7 @@ void StickersManager::do_add_sticker_to_set(UserId user_id, string short_name,
 
   const StickerSet *sticker_set = get_sticker_set(short_name_to_sticker_set_id_.get(short_name));
   if (sticker_set == nullptr || !sticker_set->was_loaded_) {
-    return promise.set_error(Status::Error(400, "Sticker set not found"));
+    return promise.set_error(400, "Sticker set not found");
   }
   telegram_api::object_ptr<telegram_api::inputDocument> input_document;
   if (old_sticker != nullptr) {
@@ -8324,7 +8323,7 @@ void StickersManager::set_sticker_set_thumbnail(UserId user_id, string short_nam
 
   short_name = clean_username(strip_empty_characters(short_name, MAX_STICKER_SET_SHORT_NAME_LENGTH));
   if (short_name.empty()) {
-    return promise.set_error(Status::Error(400, "Sticker set name must be non-empty"));
+    return promise.set_error(400, "Sticker set name must be non-empty");
   }
 
   const StickerSet *sticker_set = get_sticker_set(short_name_to_sticker_set_id_.get(short_name));
@@ -8353,11 +8352,10 @@ void StickersManager::do_set_sticker_set_thumbnail(UserId user_id, string short_
 
   const StickerSet *sticker_set = get_sticker_set(short_name_to_sticker_set_id_.get(short_name));
   if (sticker_set == nullptr || !sticker_set->was_loaded_) {
-    return promise.set_error(Status::Error(400, "Sticker set not found"));
+    return promise.set_error(400, "Sticker set not found");
   }
   if (sticker_set->sticker_type_ == StickerType::CustomEmoji) {
-    return promise.set_error(
-        Status::Error(400, "The method can't be used to set thumbnail of custom emoji sticker sets"));
+    return promise.set_error(400, "The method can't be used to set thumbnail of custom emoji sticker sets");
   }
   if (format == StickerFormat::Unknown) {
     format = guess_sticker_set_format(sticker_set);
@@ -8419,7 +8417,7 @@ void StickersManager::on_sticker_set_thumbnail_uploaded(int64 random_id, Result<
   FileView file_view = td_->file_manager_->get_file_view(pending_set_sticker_set_thumbnail->file_id_);
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (main_remote_location == nullptr) {
-    return pending_set_sticker_set_thumbnail->promise_.set_error(Status::Error(500, "Failed to upload the file"));
+    return pending_set_sticker_set_thumbnail->promise_.set_error(500, "Failed to upload the file");
   }
 
   td_->create_handler<SetStickerSetThumbnailQuery>(std::move(pending_set_sticker_set_thumbnail->promise_))
@@ -8430,7 +8428,7 @@ void StickersManager::set_custom_emoji_sticker_set_thumbnail(string short_name,
                                                              Promise<Unit> &&promise) {
   short_name = clean_username(strip_empty_characters(short_name, MAX_STICKER_SET_SHORT_NAME_LENGTH));
   if (short_name.empty()) {
-    return promise.set_error(Status::Error(400, "Sticker set name must be non-empty"));
+    return promise.set_error(400, "Sticker set name must be non-empty");
   }
 
   const StickerSet *sticker_set = get_sticker_set(short_name_to_sticker_set_id_.get(short_name));
@@ -8457,11 +8455,10 @@ void StickersManager::do_set_custom_emoji_sticker_set_thumbnail(string short_nam
 
   const StickerSet *sticker_set = get_sticker_set(short_name_to_sticker_set_id_.get(short_name));
   if (sticker_set == nullptr || !sticker_set->was_loaded_) {
-    return promise.set_error(Status::Error(400, "Sticker set not found"));
+    return promise.set_error(400, "Sticker set not found");
   }
   if (sticker_set->sticker_type_ != StickerType::CustomEmoji) {
-    return promise.set_error(
-        Status::Error(400, "The method can be used to set thumbnail only for custom emoji sticker sets"));
+    return promise.set_error(400, "The method can be used to set thumbnail only for custom emoji sticker sets");
   }
 
   td_->create_handler<SetCustomEmojiStickerSetThumbnailQuery>(std::move(promise))->send(short_name, custom_emoji_id);
@@ -8470,12 +8467,12 @@ void StickersManager::do_set_custom_emoji_sticker_set_thumbnail(string short_nam
 void StickersManager::set_sticker_set_title(string short_name, string title, Promise<Unit> &&promise) {
   short_name = clean_username(strip_empty_characters(short_name, MAX_STICKER_SET_SHORT_NAME_LENGTH));
   if (short_name.empty()) {
-    return promise.set_error(Status::Error(400, "Sticker set name must be non-empty"));
+    return promise.set_error(400, "Sticker set name must be non-empty");
   }
 
   title = strip_empty_characters(title, MAX_STICKER_SET_TITLE_LENGTH);
   if (title.empty()) {
-    return promise.set_error(Status::Error(400, "Sticker set title must be non-empty"));
+    return promise.set_error(400, "Sticker set title must be non-empty");
   }
 
   td_->create_handler<SetStickerSetTitleQuery>(std::move(promise))->send(short_name, title);
@@ -8484,7 +8481,7 @@ void StickersManager::set_sticker_set_title(string short_name, string title, Pro
 void StickersManager::delete_sticker_set(string short_name, Promise<Unit> &&promise) {
   short_name = clean_username(strip_empty_characters(short_name, MAX_STICKER_SET_SHORT_NAME_LENGTH));
   if (short_name.empty()) {
-    return promise.set_error(Status::Error(400, "Sticker set name must be non-empty"));
+    return promise.set_error(400, "Sticker set name must be non-empty");
   }
 
   td_->create_handler<DeleteStickerSetQuery>(std::move(promise))->send(short_name);
@@ -8517,7 +8514,7 @@ Result<StickersManager::StickerInputDocument> StickersManager::get_sticker_input
 void StickersManager::set_sticker_position_in_set(const td_api::object_ptr<td_api::InputFile> &sticker, int32 position,
                                                   Promise<Unit> &&promise) {
   if (position < 0) {
-    return promise.set_error(Status::Error(400, "Wrong sticker position specified"));
+    return promise.set_error(400, "Wrong sticker position specified");
   }
 
   TRY_RESULT_PROMISE(promise, input_document, get_sticker_input_document(sticker));
@@ -8571,7 +8568,7 @@ void StickersManager::set_sticker_mask_position(const td_api::object_ptr<td_api:
 void StickersManager::get_created_sticker_sets(StickerSetId offset_sticker_set_id, int32 limit,
                                                Promise<td_api::object_ptr<td_api::stickerSets>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   auto query_promise = PromiseCreator::lambda(
       [actor_id = actor_id(this), promise = std::move(promise)](
@@ -8800,7 +8797,7 @@ void StickersManager::reload_recent_stickers(bool is_attached, bool force) {
 
 void StickersManager::repair_recent_stickers(bool is_attached, Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Bots have no recent stickers"));
+    return promise.set_error(400, "Bots have no recent stickers");
   }
 
   repair_recent_stickers_queries_[is_attached].push_back(std::move(promise));
@@ -9020,26 +9017,26 @@ void StickersManager::add_recent_sticker_impl(bool is_attached, FileId sticker_i
 
   auto sticker = get_sticker(sticker_id);
   if (sticker == nullptr) {
-    return promise.set_error(Status::Error(400, "Sticker not found"));
+    return promise.set_error(400, "Sticker not found");
   }
   if (!sticker->set_id_.is_valid() &&
       (!add_on_server || (sticker->format_ != StickerFormat::Webp && sticker->format_ != StickerFormat::Webm))) {
-    return promise.set_error(Status::Error(400, "The sticker must be from a sticker set"));
+    return promise.set_error(400, "The sticker must be from a sticker set");
   }
   if (sticker->type_ == StickerType::CustomEmoji) {
-    return promise.set_error(Status::Error(400, "Custom emoji stickers can't be added to recent"));
+    return promise.set_error(400, "Custom emoji stickers can't be added to recent");
   }
 
   auto file_view = td_->file_manager_->get_file_view(sticker_id);
   const auto *full_remote_location = file_view.get_full_remote_location();
   if (full_remote_location == nullptr) {
-    return promise.set_error(Status::Error(400, "Can save only sent stickers"));
+    return promise.set_error(400, "Can save only sent stickers");
   }
   if (full_remote_location->is_web()) {
-    return promise.set_error(Status::Error(400, "Can't save web stickers"));
+    return promise.set_error(400, "Can't save web stickers");
   }
   if (!full_remote_location->is_document()) {
-    return promise.set_error(Status::Error(400, "Can't save encrypted stickers"));
+    return promise.set_error(400, "Can't save encrypted stickers");
   }
 
   add_to_top_if(sticker_ids, static_cast<size_t>(recent_stickers_limit_), sticker_id, is_equal);
@@ -9074,7 +9071,7 @@ void StickersManager::remove_recent_sticker(bool is_attached, const tl_object_pt
 
   auto sticker = get_sticker(file_id);
   if (sticker == nullptr) {
-    return promise.set_error(Status::Error(400, "Sticker not found"));
+    return promise.set_error(400, "Sticker not found");
   }
 
   send_save_recent_sticker_query(is_attached, file_id, true, std::move(promise));
@@ -9198,7 +9195,7 @@ void StickersManager::reload_favorite_stickers(bool force) {
 
 void StickersManager::repair_favorite_stickers(Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
-    return promise.set_error(Status::Error(400, "Bots have no favorite stickers"));
+    return promise.set_error(400, "Bots have no favorite stickers");
   }
 
   repair_favorite_stickers_queries_.push_back(std::move(promise));
@@ -9406,26 +9403,26 @@ void StickersManager::add_favorite_sticker_impl(FileId sticker_id, bool add_on_s
 
   auto sticker = get_sticker(sticker_id);
   if (sticker == nullptr) {
-    return promise.set_error(Status::Error(400, "Sticker not found"));
+    return promise.set_error(400, "Sticker not found");
   }
   if (!sticker->set_id_.is_valid() &&
       (!add_on_server || (sticker->format_ != StickerFormat::Webp && sticker->format_ != StickerFormat::Webm))) {
-    return promise.set_error(Status::Error(400, "The sticker must be from a sticker set"));
+    return promise.set_error(400, "The sticker must be from a sticker set");
   }
   if (sticker->type_ == StickerType::CustomEmoji) {
-    return promise.set_error(Status::Error(400, "Custom emoji stickers can't be added to favorite"));
+    return promise.set_error(400, "Custom emoji stickers can't be added to favorite");
   }
 
   auto file_view = td_->file_manager_->get_file_view(sticker_id);
   const auto *full_remote_location = file_view.get_full_remote_location();
   if (full_remote_location == nullptr) {
-    return promise.set_error(Status::Error(400, "Can add to favorites only sent stickers"));
+    return promise.set_error(400, "Can add to favorites only sent stickers");
   }
   if (full_remote_location->is_web()) {
-    return promise.set_error(Status::Error(400, "Can't add to favorites web stickers"));
+    return promise.set_error(400, "Can't add to favorites web stickers");
   }
   if (!full_remote_location->is_document()) {
-    return promise.set_error(Status::Error(400, "Can't add to favorites encrypted stickers"));
+    return promise.set_error(400, "Can't add to favorites encrypted stickers");
   }
 
   add_to_top_if(favorite_sticker_ids_, static_cast<size_t>(favorite_stickers_limit_), sticker_id, is_equal);
@@ -9459,7 +9456,7 @@ void StickersManager::remove_favorite_sticker(const tl_object_ptr<td_api::InputF
 
   auto sticker = get_sticker(file_id);
   if (sticker == nullptr) {
-    return promise.set_error(Status::Error(400, "Sticker not found"));
+    return promise.set_error(400, "Sticker not found");
   }
 
   send_fave_sticker_query(file_id, true, std::move(promise));
diff --git a/td/telegram/StoryManager.cpp b/td/telegram/StoryManager.cpp
index 00f0ecb6c..587285fa1 100644
--- a/td/telegram/StoryManager.cpp
+++ b/td/telegram/StoryManager.cpp
@@ -589,7 +589,7 @@ class EditStoryCoverQuery final : public Td::ResultHandler {
                                             main_frame_timestamp = main_frame_timestamp_,
                                             promise = std::move(promise_)](Result<Unit> result) mutable {
             if (result.is_error()) {
-              return promise.set_error(Status::Error(400, "Failed to edit cover"));
+              return promise.set_error(400, "Failed to edit cover");
             }
 
             send_closure(G()->story_manager(), &StoryManager::edit_story_cover, dialog_id, story_id,
@@ -2178,11 +2178,11 @@ void StoryManager::add_pending_story_dependencies(Dependencies &dependencies, co
 
 void StoryManager::load_active_stories(StoryListId story_list_id, Promise<Unit> &&promise) {
   if (!story_list_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Story list must be non-empty"));
+    return promise.set_error(400, "Story list must be non-empty");
   }
   auto &story_list = get_story_list(story_list_id);
   if (story_list.list_last_story_date_ == MAX_DIALOG_DATE) {
-    return promise.set_error(Status::Error(404, "Not found"));
+    return promise.set_error(404, "Not found");
   }
 
   if (story_list.database_has_more_) {
@@ -2211,7 +2211,7 @@ void StoryManager::load_active_stories(StoryListId story_list_id, Promise<Unit>
       }
       update_story_list_sent_total_count(story_list_id, story_list, "load_active_stories");
     }
-    return promise.set_error(Status::Error(404, "Not found"));
+    return promise.set_error(404, "Not found");
   }
 
   load_active_stories_from_server(story_list_id, story_list, !story_list.state_.empty(), std::move(promise));
@@ -2535,7 +2535,7 @@ void StoryManager::toggle_dialog_stories_hidden(DialogId dialog_id, StoryListId
     return promise.set_value(Unit());
   }
   if (!story_list_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Story list must be non-empty"));
+    return promise.set_error(400, "Story list must be non-empty");
   }
 
   td_->create_handler<ToggleStoriesHiddenQuery>(std::move(promise))
@@ -2545,13 +2545,13 @@ void StoryManager::toggle_dialog_stories_hidden(DialogId dialog_id, StoryListId
 void StoryManager::get_dialog_pinned_stories(DialogId owner_dialog_id, StoryId from_story_id, int32 limit,
                                              Promise<td_api::object_ptr<td_api::stories>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(owner_dialog_id, false, AccessRights::Read,
                                                                         "get_dialog_pinned_stories"));
 
   if (from_story_id != StoryId() && !from_story_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Invalid value of parameter from_story_id specified"));
+    return promise.set_error(400, "Invalid value of parameter from_story_id specified");
   }
   if (!can_have_stories(owner_dialog_id)) {
     return promise.set_value(td_api::make_object<td_api::stories>());
@@ -2585,16 +2585,16 @@ void StoryManager::on_get_dialog_pinned_stories(DialogId owner_dialog_id,
 void StoryManager::get_story_archive(DialogId owner_dialog_id, StoryId from_story_id, int32 limit,
                                      Promise<td_api::object_ptr<td_api::stories>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (from_story_id != StoryId() && !from_story_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Invalid value of parameter from_story_id specified"));
+    return promise.set_error(400, "Invalid value of parameter from_story_id specified");
   }
   if (!td_->dialog_manager_->have_dialog_force(owner_dialog_id, "get_story_archive")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (!can_edit_stories(owner_dialog_id)) {
-    return promise.set_error(Status::Error(400, "Can't get story archive in the chat"));
+    return promise.set_error(400, "Can't get story archive in the chat");
   }
 
   auto query_promise =
@@ -2745,7 +2745,7 @@ void StoryManager::on_get_dialog_expiring_stories(DialogId owner_dialog_id,
 void StoryManager::search_hashtag_posts(DialogId dialog_id, string hashtag, string offset, int32 limit,
                                         Promise<td_api::object_ptr<td_api::foundStories>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_SEARCH_STORIES) {
     limit = MAX_SEARCH_STORIES;
@@ -2773,7 +2773,7 @@ void StoryManager::search_hashtag_posts(DialogId dialog_id, string hashtag, stri
 void StoryManager::search_location_posts(td_api::object_ptr<td_api::locationAddress> &&address, string offset,
                                          int32 limit, Promise<td_api::object_ptr<td_api::foundStories>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_SEARCH_STORIES) {
     limit = MAX_SEARCH_STORIES;
@@ -2785,7 +2785,7 @@ void StoryManager::search_location_posts(td_api::object_ptr<td_api::locationAddr
 void StoryManager::search_venue_posts(string venue_provider, string venue_id, string offset, int32 limit,
                                       Promise<td_api::object_ptr<td_api::foundStories>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_SEARCH_STORIES) {
     limit = MAX_SEARCH_STORIES;
@@ -2798,19 +2798,19 @@ void StoryManager::set_pinned_stories(DialogId owner_dialog_id, vector<StoryId>
   TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(owner_dialog_id, false, AccessRights::Write,
                                                                         "set_pinned_stories"));
   if (!can_edit_stories(owner_dialog_id)) {
-    return promise.set_error(Status::Error(400, "Can't change pinned stories in the chat"));
+    return promise.set_error(400, "Can't change pinned stories in the chat");
   }
   for (const auto &story_id : story_ids) {
     StoryFullId story_full_id{owner_dialog_id, story_id};
     const Story *story = get_story(story_full_id);
     if (story == nullptr) {
-      return promise.set_error(Status::Error(400, "Story not found"));
+      return promise.set_error(400, "Story not found");
     }
     if (!story->is_pinned_) {
-      return promise.set_error(Status::Error(400, "The story must be posted to the chat page first"));
+      return promise.set_error(400, "The story must be posted to the chat page first");
     }
     if (!story_id.is_server()) {
-      return promise.set_error(Status::Error(400, "Story must be sent first"));
+      return promise.set_error(400, "Story must be sent first");
     }
   }
   td_->create_handler<TogglePinnedStoriesToTopQuery>(std::move(promise))->send(owner_dialog_id, std::move(story_ids));
@@ -2820,7 +2820,7 @@ void StoryManager::open_story(DialogId owner_dialog_id, StoryId story_id, Promis
   TRY_STATUS_PROMISE(
       promise, td_->dialog_manager_->check_dialog_access(owner_dialog_id, false, AccessRights::Read, "open_story"));
   if (!story_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid story identifier specified"));
+    return promise.set_error(400, "Invalid story identifier specified");
   }
 
   StoryFullId story_full_id{owner_dialog_id, story_id};
@@ -2879,14 +2879,14 @@ void StoryManager::close_story(DialogId owner_dialog_id, StoryId story_id, Promi
   TRY_STATUS_PROMISE(
       promise, td_->dialog_manager_->check_dialog_access(owner_dialog_id, false, AccessRights::Read, "close_story"));
   if (!story_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid story identifier specified"));
+    return promise.set_error(400, "Invalid story identifier specified");
   }
 
   StoryFullId story_full_id{owner_dialog_id, story_id};
   if (can_get_story_view_count(owner_dialog_id) && story_id.is_server()) {
     auto &open_count = opened_stories_with_view_count_[story_full_id];
     if (open_count == 0) {
-      return promise.set_error(Status::Error(400, "The story wasn't opened"));
+      return promise.set_error(400, "The story wasn't opened");
     }
     if (--open_count == 0) {
       opened_stories_with_view_count_.erase(story_full_id);
@@ -2990,19 +2990,19 @@ void StoryManager::set_story_reaction(StoryFullId story_full_id, ReactionType re
   TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(owner_dialog_id, false, AccessRights::Read,
                                                                         "set_story_reaction"));
   if (!story_full_id.get_story_id().is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid story identifier specified"));
+    return promise.set_error(400, "Invalid story identifier specified");
   }
   if (!story_full_id.get_story_id().is_server()) {
-    return promise.set_error(Status::Error(400, "Can't react to the story"));
+    return promise.set_error(400, "Can't react to the story");
   }
 
   Story *story = get_story_force(story_full_id, "set_story_reaction");
   if (story == nullptr) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
 
   if (!can_use_story_reaction(story, reaction_type)) {
-    return promise.set_error(Status::Error(400, "The reaction isn't available for the story"));
+    return promise.set_error(400, "The reaction isn't available for the story");
   }
 
   if (story->chosen_reaction_type_ == reaction_type) {
@@ -3216,10 +3216,10 @@ void StoryManager::get_story_interactions(StoryId story_id, const string &query,
   StoryFullId story_full_id{owner_dialog_id, story_id};
   const Story *story = get_story(story_full_id);
   if (story == nullptr) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (!story_id.is_server()) {
     return promise.set_value(td_api::make_object<td_api::storyInteractions>());
@@ -3320,16 +3320,16 @@ void StoryManager::get_dialog_story_interactions(StoryFullId story_full_id, Reac
                                                  Promise<td_api::object_ptr<td_api::storyInteractions>> &&promise) {
   const Story *story = get_story(story_full_id);
   if (story == nullptr) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (!story_full_id.get_story_id().is_server()) {
     return promise.set_value(td_api::make_object<td_api::storyInteractions>());
   }
   if (reaction_type.is_paid_reaction()) {
-    return promise.set_error(Status::Error(400, "Stories can't have paid reactions"));
+    return promise.set_error(400, "Stories can't have paid reactions");
   }
 
   auto query_promise = PromiseCreator::lambda(
@@ -3374,10 +3374,10 @@ void StoryManager::on_get_dialog_story_interactions(
 void StoryManager::report_story(StoryFullId story_full_id, const string &option_id, const string &text,
                                 Promise<td_api::object_ptr<td_api::ReportStoryResult>> &&promise) {
   if (!have_story_force(story_full_id)) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (!story_full_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Story can't be reported"));
+    return promise.set_error(400, "Story can't be reported");
   }
 
   td_->create_handler<ReportStoryQuery>(std::move(promise))->send(story_full_id, option_id, text);
@@ -4950,7 +4950,7 @@ void StoryManager::reload_story(StoryFullId story_full_id, Promise<Unit> &&promi
   auto dialog_id = story_full_id.get_dialog_id();
   auto story_id = story_full_id.get_story_id();
   if (!story_id.is_server()) {
-    return promise.set_error(Status::Error(400, "Invalid story identifier"));
+    return promise.set_error(400, "Invalid story identifier");
   }
 
   auto &queries = reload_story_queries_[story_full_id];
@@ -4991,7 +4991,7 @@ void StoryManager::get_story(DialogId owner_dialog_id, StoryId story_id, bool on
   TRY_STATUS_PROMISE(
       promise, td_->dialog_manager_->check_dialog_access(owner_dialog_id, false, AccessRights::Read, "get_story"));
   if (!story_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid story identifier specified"));
+    return promise.set_error(400, "Invalid story identifier specified");
   }
 
   StoryFullId story_full_id{owner_dialog_id, story_id};
@@ -5173,10 +5173,10 @@ void StoryManager::save_channels_to_send_stories() {
 void StoryManager::can_send_story(DialogId dialog_id,
                                   Promise<td_api::object_ptr<td_api::CanPostStoryResult>> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "can_send_story")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (!can_post_stories(dialog_id)) {
-    return promise.set_error(Status::Error(400, "Not enough rights to post stories in the chat"));
+    return promise.set_error(400, "Not enough rights to post stories in the chat");
   }
   td_->create_handler<CanSendStoryQuery>(std::move(promise))->send(dialog_id);
 }
@@ -5188,10 +5188,10 @@ void StoryManager::send_story(DialogId dialog_id, td_api::object_ptr<td_api::Inp
                               td_api::object_ptr<td_api::storyFullId> &&from_story_full_id, bool is_pinned,
                               bool protect_content, Promise<td_api::object_ptr<td_api::story>> &&promise) {
   if (!td_->dialog_manager_->have_dialog_force(dialog_id, "send_story")) {
-    return promise.set_error(Status::Error(400, "Chat not found"));
+    return promise.set_error(400, "Chat not found");
   }
   if (!can_post_stories(dialog_id)) {
-    return promise.set_error(Status::Error(400, "Not enough rights to post stories in the chat"));
+    return promise.set_error(400, "Not enough rights to post stories in the chat");
   }
 
   bool is_bot = td_->auth_manager_->is_bot();
@@ -5207,16 +5207,16 @@ void StoryManager::send_story(DialogId dialog_id, td_api::object_ptr<td_api::Inp
   StoryFullId forward_from_story_full_id;
   if (from_story_full_id != nullptr) {
     if (is_bot) {
-      return promise.set_error(Status::Error(400, "Bots can't repost stories"));
+      return promise.set_error(400, "Bots can't repost stories");
     }
     forward_from_story_full_id =
         StoryFullId(DialogId(from_story_full_id->poster_chat_id_), StoryId(from_story_full_id->story_id_));
     const Story *story = get_story(forward_from_story_full_id);
     if (story == nullptr || story->content_ == nullptr) {
-      return promise.set_error(Status::Error(400, "Story to repost not found"));
+      return promise.set_error(400, "Story to repost not found");
     }
     if (story->noforwards_) {
-      return promise.set_error(Status::Error(400, "Story can't be reposted"));
+      return promise.set_error(400, "Story can't be reposted");
     }
     if (story->forward_info_ != nullptr) {
       forward_info = make_unique<StoryForwardInfo>(*story->forward_info_);
@@ -5228,7 +5228,7 @@ void StoryManager::send_story(DialogId dialog_id, td_api::object_ptr<td_api::Inp
   if (active_period != 86400 && !(G()->is_test_dc() && (active_period == 60 || active_period == 300))) {
     bool is_premium = td_->option_manager_->get_option_boolean("is_premium") || is_bot;
     if (!is_premium || !td::contains(vector<int32>{6 * 3600, 12 * 3600, 2 * 86400}, active_period)) {
-      return promise.set_error(Status::Error(400, "Invalid story active period specified"));
+      return promise.set_error(400, "Invalid story active period specified");
     }
   }
   TRY_RESULT_PROMISE(promise, story_id, get_next_yet_unsent_story_id(dialog_id));
@@ -5548,10 +5548,10 @@ void StoryManager::edit_story(DialogId owner_dialog_id, StoryId story_id,
   StoryFullId story_full_id{owner_dialog_id, story_id};
   const Story *story = get_story(story_full_id);
   if (story == nullptr || story->content_ == nullptr) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (!can_edit_story(story_full_id, story)) {
-    return promise.set_error(Status::Error(400, "Story can't be edited"));
+    return promise.set_error(400, "Story can't be edited");
   }
 
   bool is_bot = td_->auth_manager_->is_bot();
@@ -5579,7 +5579,7 @@ void StoryManager::edit_story(DialogId owner_dialog_id, StoryId story_id,
     if (*current_areas == areas) {
       are_media_areas_edited = false;
     } else if (content == nullptr) {
-      return promise.set_error(Status::Error(400, "Can't edit story areas without content"));
+      return promise.set_error(400, "Can't edit story areas without content");
     }
   }
   if (is_caption_edited) {
@@ -5661,7 +5661,7 @@ void StoryManager::edit_business_story(DialogId owner_dialog_id, StoryId story_i
   CHECK(td_->auth_manager_->is_bot());
   StoryFullId story_full_id{owner_dialog_id, story_id};
   if (!can_edit_story(story_full_id, nullptr)) {
-    return promise.set_error(Status::Error(400, "Story can't be edited"));
+    return promise.set_error(400, "Story can't be edited");
   }
 
   bool is_bot = true;
@@ -5720,12 +5720,12 @@ void StoryManager::on_edit_business_story(unique_ptr<PendingStory> &&pending_sto
   auto story = UpdatesManager::extract_story(updates.get(), pending_story->dialog_id_);
   if (story == nullptr) {
     LOG(ERROR) << "Receive unexpected edit story result: " << to_string(updates);
-    promise.set_error(Status::Error(400, "Failed to edit story"));
+    promise.set_error(400, "Failed to edit story");
   } else {
     auto story_id = on_get_story(pending_story->dialog_id_, std::move(story));
     if (story_id != pending_story->story_id_) {
       LOG(ERROR) << "Receive unexpected " << story_id << " instead of " << pending_story->story_id_;
-      promise.set_error(Status::Error(400, "Failed to edit story"));
+      promise.set_error(400, "Failed to edit story");
     } else {
       promise.set_value(get_story_object({pending_story->dialog_id_, story_id}));
     }
@@ -5760,23 +5760,23 @@ void StoryManager::edit_story_cover(DialogId owner_dialog_id, StoryId story_id,
   StoryFullId story_full_id{owner_dialog_id, story_id};
   const Story *story = get_story(story_full_id);
   if (story == nullptr || story->content_ == nullptr) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (!can_edit_story(story_full_id, story)) {
-    return promise.set_error(Status::Error(400, "Story can't be edited"));
+    return promise.set_error(400, "Story can't be edited");
   }
   if (being_edited_stories_.count(story_full_id) > 0) {
-    return promise.set_error(Status::Error(400, "Story is being edited"));
+    return promise.set_error(400, "Story is being edited");
   }
   if (main_frame_timestamp < 0.0) {
-    return promise.set_error(Status::Error(400, "Wrong cover timestamp specified"));
+    return promise.set_error(400, "Wrong cover timestamp specified");
   }
   if (story->content_->get_type() != StoryContentType::Video) {
-    return promise.set_error(Status::Error(400, "Cover timestamp can't be edited for the story"));
+    return promise.set_error(400, "Cover timestamp can't be edited for the story");
   }
   auto input_media = get_story_content_document_input_media(td_, story->content_.get(), main_frame_timestamp);
   if (input_media == nullptr) {
-    return promise.set_error(Status::Error(400, "Can't edit story cover"));
+    return promise.set_error(400, "Can't edit story cover");
   }
 
   td_->create_handler<EditStoryCoverQuery>(std::move(promise))
@@ -5877,10 +5877,10 @@ void StoryManager::set_story_privacy_settings(StoryId story_id,
   StoryFullId story_full_id{owner_dialog_id, story_id};
   const Story *story = get_story(story_full_id);
   if (story == nullptr || story->content_ == nullptr) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (!can_edit_story(story_full_id, story)) {
-    return promise.set_error(Status::Error(400, "Story privacy settings can't be edited"));
+    return promise.set_error(400, "Story privacy settings can't be edited");
   }
   TRY_RESULT_PROMISE(promise, privacy_rules,
                      UserPrivacySettingRules::get_user_privacy_setting_rules(td_, std::move(settings)));
@@ -5893,10 +5893,10 @@ void StoryManager::toggle_story_is_pinned(DialogId owner_dialog_id, StoryId stor
   StoryFullId story_full_id{owner_dialog_id, story_id};
   const Story *story = get_story(story_full_id);
   if (story == nullptr || story->content_ == nullptr) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (!can_toggle_story_is_pinned(story_full_id, story)) {
-    return promise.set_error(Status::Error(400, "Story can't be pinned/unpinned"));
+    return promise.set_error(400, "Story can't be pinned/unpinned");
   }
   auto query_promise = PromiseCreator::lambda([actor_id = actor_id(this), story_full_id, is_pinned,
                                                promise = std::move(promise)](Result<Unit> &&result) mutable {
@@ -5923,20 +5923,20 @@ void StoryManager::delete_story(DialogId owner_dialog_id, StoryId story_id, Prom
   StoryFullId story_full_id{owner_dialog_id, story_id};
   const Story *story = get_story(story_full_id);
   if (story == nullptr) {
-    return promise.set_error(Status::Error(400, "Story not found"));
+    return promise.set_error(400, "Story not found");
   }
   if (!can_delete_story(story_full_id, story)) {
-    return promise.set_error(Status::Error(400, "Story can't be deleted"));
+    return promise.set_error(400, "Story can't be deleted");
   }
   if (!story_id.is_server()) {
     auto file_upload_id_it = being_uploaded_file_upload_ids_.find(story_full_id);
     if (file_upload_id_it == being_uploaded_file_upload_ids_.end()) {
-      return promise.set_error(Status::Error(400, "Story upload has been already completed"));
+      return promise.set_error(400, "Story upload has been already completed");
     }
     auto file_upload_id = file_upload_id_it->second;
     auto random_id_it = being_sent_story_random_ids_.find(story_full_id);
     if (random_id_it == being_sent_story_random_ids_.end()) {
-      return promise.set_error(Status::Error(400, "Story not found"));
+      return promise.set_error(400, "Story not found");
     }
     int64 random_id = random_id_it->second;
     CHECK(random_id != 0);
diff --git a/td/telegram/SuggestedAction.cpp b/td/telegram/SuggestedAction.cpp
index 85e6c6f70..2ebb2c9b3 100644
--- a/td/telegram/SuggestedAction.cpp
+++ b/td/telegram/SuggestedAction.cpp
@@ -283,7 +283,7 @@ bool remove_suggested_action(const UserManager *user_manager, vector<SuggestedAc
 void dismiss_suggested_action(SuggestedAction action, Promise<Unit> &&promise) {
   switch (action.type_) {
     case SuggestedAction::Type::Empty:
-      return promise.set_error(Status::Error(400, "Action must be non-empty"));
+      return promise.set_error(400, "Action must be non-empty");
     case SuggestedAction::Type::EnableArchiveAndMuteNewChats:
     case SuggestedAction::Type::CheckPassword:
     case SuggestedAction::Type::CheckPhoneNumber:
@@ -302,7 +302,7 @@ void dismiss_suggested_action(SuggestedAction action, Promise<Unit> &&promise) {
                                 std::move(action), std::move(promise));
     case SuggestedAction::Type::SetPassword: {
       if (action.otherwise_relogin_days_ < 0) {
-        return promise.set_error(Status::Error(400, "Invalid authorization_delay specified"));
+        return promise.set_error(400, "Invalid authorization_delay specified");
       }
       if (action.otherwise_relogin_days_ == 0) {
         return send_closure_later(G()->suggested_action_manager(), &SuggestedActionManager::dismiss_suggested_action,
diff --git a/td/telegram/TdDb.cpp b/td/telegram/TdDb.cpp
index b1439572f..6a2082ca4 100644
--- a/td/telegram/TdDb.cpp
+++ b/td/telegram/TdDb.cpp
@@ -563,7 +563,7 @@ void TdDb::open_impl(Parameters parameters, Promise<OpenedDatabase> &&promise) {
     SqliteDb::destroy(get_sqlite_path(parameters)).ignore();
     init_sqlite_status = db->init_sqlite(parameters, new_sqlite_key, old_sqlite_key, *binlog_pmc);
     if (init_sqlite_status.is_error()) {
-      return promise.set_error(Status::Error(400, init_sqlite_status.message()));
+      return promise.set_error(400, init_sqlite_status.message());
     }
   }
   if (drop_sqlite_key) {
diff --git a/td/telegram/TopDialogManager.cpp b/td/telegram/TopDialogManager.cpp
index f0d6feb7c..dcfdfc94e 100644
--- a/td/telegram/TopDialogManager.cpp
+++ b/td/telegram/TopDialogManager.cpp
@@ -229,7 +229,7 @@ void TopDialogManager::on_dialog_used(TopDialogCategory category, DialogId dialo
 
 void TopDialogManager::remove_dialog(TopDialogCategory category, DialogId dialog_id, Promise<Unit> &&promise) {
   if (category == TopDialogCategory::Size) {
-    return promise.set_error(Status::Error(400, "Top chat category must be non-empty"));
+    return promise.set_error(400, "Top chat category must be non-empty");
   }
   TRY_STATUS_PROMISE(promise,
                      td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Read, "remove_dialog"));
@@ -266,13 +266,13 @@ void TopDialogManager::remove_dialog(TopDialogCategory category, DialogId dialog
 void TopDialogManager::get_top_dialogs(TopDialogCategory category, int32 limit,
                                        Promise<td_api::object_ptr<td_api::chats>> &&promise) {
   if (category == TopDialogCategory::Size) {
-    return promise.set_error(Status::Error(400, "Top chat category must be non-empty"));
+    return promise.set_error(400, "Top chat category must be non-empty");
   }
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Limit must be positive"));
+    return promise.set_error(400, "Limit must be positive");
   }
   if (!is_enabled_) {
-    return promise.set_error(Status::Error(400, "Top chat computation is disabled"));
+    return promise.set_error(400, "Top chat computation is disabled");
   }
 
   GetTopDialogsQuery query;
diff --git a/td/telegram/TranscriptionManager.cpp b/td/telegram/TranscriptionManager.cpp
index 66e9fb7f4..19b11d2da 100644
--- a/td/telegram/TranscriptionManager.cpp
+++ b/td/telegram/TranscriptionManager.cpp
@@ -263,12 +263,12 @@ TranscriptionInfo *TranscriptionManager::get_transcription_info(const FileInfo &
 
 void TranscriptionManager::recognize_speech(MessageFullId message_full_id, Promise<Unit> &&promise) {
   if (!td_->messages_manager_->have_message_force(message_full_id, "recognize_speech")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   auto it = message_file_ids_.find(message_full_id);
   if (it == message_file_ids_.end()) {
-    return promise.set_error(Status::Error(400, "Message can't be transcribed"));
+    return promise.set_error(400, "Message can't be transcribed");
   }
 
   auto *transcription_info = get_transcription_info(it->second, true);
@@ -374,12 +374,12 @@ void TranscriptionManager::on_transcription_completed(FileId file_id) {
 void TranscriptionManager::rate_speech_recognition(MessageFullId message_full_id, bool is_good,
                                                    Promise<Unit> &&promise) {
   if (!td_->messages_manager_->have_message_force(message_full_id, "rate_speech_recognition")) {
-    return promise.set_error(Status::Error(400, "Message not found"));
+    return promise.set_error(400, "Message not found");
   }
 
   auto it = message_file_ids_.find(message_full_id);
   if (it == message_file_ids_.end()) {
-    return promise.set_error(Status::Error(400, "Message can't be transcribed"));
+    return promise.set_error(400, "Message can't be transcribed");
   }
 
   const auto *transcription_info = get_transcription_info(it->second, false);
diff --git a/td/telegram/TranslationManager.cpp b/td/telegram/TranslationManager.cpp
index 06ade88a9..a7062f78a 100644
--- a/td/telegram/TranslationManager.cpp
+++ b/td/telegram/TranslationManager.cpp
@@ -80,7 +80,7 @@ void TranslationManager::translate_text(td_api::object_ptr<td_api::formattedText
                                         const string &to_language_code,
                                         Promise<td_api::object_ptr<td_api::formattedText>> &&promise) {
   if (text == nullptr) {
-    return promise.set_error(Status::Error(400, "Text must be non-empty"));
+    return promise.set_error(400, "Text must be non-empty");
   }
   bool skip_bot_commands = true;
   int32 max_media_timestamp = -1;
@@ -137,9 +137,9 @@ void TranslationManager::on_get_translated_texts(vector<telegram_api::object_ptr
   TRY_STATUS_PROMISE(promise, G()->close_status());
   if (texts.size() != 1u) {
     if (texts.empty()) {
-      return promise.set_error(Status::Error(500, "Translation failed"));
+      return promise.set_error(500, "Translation failed");
     }
-    return promise.set_error(Status::Error(500, "Receive invalid number of results"));
+    return promise.set_error(500, "Receive invalid number of results");
   }
   auto formatted_text = get_formatted_text(td_->user_manager_.get(), std::move(texts[0]), max_media_timestamp == -1,
                                            true, "on_get_translated_texts");
diff --git a/td/telegram/UserManager.cpp b/td/telegram/UserManager.cpp
index 6a3602f41..11367ec5f 100644
--- a/td/telegram/UserManager.cpp
+++ b/td/telegram/UserManager.cpp
@@ -658,7 +658,7 @@ class UpdateProfilePhotoQuery final : public Td::ResultHandler {
                                               old_photo_id = old_photo_id_,
                                               promise = std::move(promise_)](Result<Unit> result) mutable {
               if (result.is_error()) {
-                return promise.set_error(Status::Error(400, "Can't find the photo"));
+                return promise.set_error(400, "Can't find the photo");
               }
 
               send_closure(G()->user_manager(), &UserManager::send_update_profile_photo_query, user_id, file_id,
@@ -917,7 +917,7 @@ class UpdateUserEmojiStatusQuery final : public Td::ResultHandler {
 
   void on_error(Status status) final {
     if (status.message() == "USER_PERMISSION_DENIED") {
-      return promise_.set_error(Status::Error(403, "Not enough rights to change the user's emoji status"));
+      return promise_.set_error(403, "Not enough rights to change the user's emoji status");
     }
     promise_.set_error(std::move(status));
   }
@@ -1144,7 +1144,7 @@ class UpdateBirthdayQuery final : public Td::ResultHandler {
     if (result_ptr.ok()) {
       promise_.set_value(Unit());
     } else {
-      promise_.set_error(Status::Error(400, "Failed to change birthdate"));
+      promise_.set_error(400, "Failed to change birthdate");
     }
   }
 
@@ -1184,7 +1184,7 @@ class UpdatePersonalChannelQuery final : public Td::ResultHandler {
     if (result_ptr.ok()) {
       promise_.set_value(Unit());
     } else {
-      promise_.set_error(Status::Error(400, "Failed to change personal chat"));
+      promise_.set_error(400, "Failed to change personal chat");
     }
   }
 
@@ -1218,7 +1218,7 @@ class UpdateEmojiStatusQuery final : public Td::ResultHandler {
     if (result_ptr.ok()) {
       promise_.set_value(Unit());
     } else {
-      promise_.set_error(Status::Error(400, "Failed to change Premium badge"));
+      promise_.set_error(400, "Failed to change Premium badge");
     }
   }
 
@@ -4389,7 +4389,7 @@ UserId UserManager::get_me(Promise<Unit> &&promise) {
 
 bool UserManager::get_user(UserId user_id, int left_tries, Promise<Unit> &&promise) {
   if (!user_id.is_valid()) {
-    promise.set_error(Status::Error(400, "Invalid user identifier"));
+    promise.set_error(400, "Invalid user identifier");
     return false;
   }
 
@@ -4409,7 +4409,7 @@ bool UserManager::get_user(UserId user_id, int left_tries, Promise<Unit> &&promi
       if (r_input_user.is_error()) {
         promise.set_error(r_input_user.move_as_error());
       } else {
-        promise.set_error(Status::Error(400, "User not found"));
+        promise.set_error(400, "User not found");
       }
       return false;
     }
@@ -4424,7 +4424,7 @@ bool UserManager::get_user(UserId user_id, int left_tries, Promise<Unit> &&promi
 
 void UserManager::reload_user(UserId user_id, Promise<Unit> &&promise, const char *source) {
   if (!user_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid user identifier"));
+    return promise.set_error(400, "Invalid user identifier");
   }
 
   have_user_force(user_id, source);
@@ -5028,7 +5028,7 @@ void UserManager::set_name(const string &first_name, const string &last_name, Pr
   auto new_first_name = clean_name(first_name, MAX_NAME_LENGTH);
   auto new_last_name = clean_name(last_name, MAX_NAME_LENGTH);
   if (new_first_name.empty()) {
-    return promise.set_error(Status::Error(400, "First name must be non-empty"));
+    return promise.set_error(400, "First name must be non-empty");
   }
 
   const User *u = get_user(get_my_id());
@@ -5110,13 +5110,13 @@ void UserManager::set_bot_profile_photo(UserId bot_user_id,
                                         Promise<Unit> &&promise) {
   if (td_->auth_manager_->is_bot()) {
     if (bot_user_id != UserId() && bot_user_id != get_my_id()) {
-      return promise.set_error(Status::Error(400, "Invalid bot user identifier specified"));
+      return promise.set_error(400, "Invalid bot user identifier specified");
     }
     bot_user_id = get_my_id();
   } else {
     TRY_RESULT_PROMISE(promise, bot_data, get_bot_data(bot_user_id));
     if (!bot_data.can_be_edited) {
-      return promise.set_error(Status::Error(400, "The bot can't be edited"));
+      return promise.set_error(400, "The bot can't be edited");
     }
   }
   if (input_photo == nullptr) {
@@ -5136,7 +5136,7 @@ void UserManager::set_business_profile_photo(BusinessConnectionId business_conne
     return;
   }
   if (input_photo->get_id() == td_api::inputChatPhotoPrevious::ID) {
-    return promise.set_error(Status::Error(400, "Unsupported"));
+    return promise.set_error(400, "Unsupported");
   }
   auto user_id = td_->business_connection_manager_->get_business_connection_user_id(business_connection_id);
   set_profile_photo_impl(user_id, input_photo, is_fallback, false, std::move(promise));
@@ -5151,7 +5151,7 @@ void UserManager::set_profile_photo(const td_api::object_ptr<td_api::InputChatPh
 void UserManager::set_profile_photo_impl(UserId user_id, const td_api::object_ptr<td_api::InputChatPhoto> &input_photo,
                                          bool is_fallback, bool only_suggest, Promise<Unit> &&promise) {
   if (input_photo == nullptr) {
-    return promise.set_error(Status::Error(400, "New profile photo must be non-empty"));
+    return promise.set_error(400, "New profile photo must be non-empty");
   }
 
   const td_api::object_ptr<td_api::InputFile> *input_file = nullptr;
@@ -5160,7 +5160,7 @@ void UserManager::set_profile_photo_impl(UserId user_id, const td_api::object_pt
   switch (input_photo->get_id()) {
     case td_api::inputChatPhotoPrevious::ID: {
       if (user_id != get_my_id() || td_->auth_manager_->is_bot()) {
-        return promise.set_error(Status::Error(400, "Can't use inputChatPhotoPrevious"));
+        return promise.set_error(400, "Can't use inputChatPhotoPrevious");
       }
       auto photo = static_cast<const td_api::inputChatPhotoPrevious *>(input_photo.get());
       auto photo_id = photo->chat_photo_id_;
@@ -5172,7 +5172,7 @@ void UserManager::set_profile_photo_impl(UserId user_id, const td_api::object_pt
 
       auto file_id = get_profile_photo_file_id(photo_id);
       if (!file_id.is_valid()) {
-        return promise.set_error(Status::Error(400, "Unknown profile photo ID specified"));
+        return promise.set_error(400, "Unknown profile photo ID specified");
       }
       return send_update_profile_photo_query(user_id, file_id, photo_id, is_fallback, std::move(promise));
     }
@@ -5203,7 +5203,7 @@ void UserManager::set_profile_photo_impl(UserId user_id, const td_api::object_pt
 
   const double MAX_ANIMATION_DURATION = 10.0;
   if (main_frame_timestamp < 0.0 || main_frame_timestamp > MAX_ANIMATION_DURATION) {
-    return promise.set_error(Status::Error(400, "Wrong main frame timestamp specified"));
+    return promise.set_error(400, "Wrong main frame timestamp specified");
   }
 
   auto file_type = is_animation ? FileType::Animation : FileType::Photo;
@@ -5218,13 +5218,13 @@ void UserManager::set_user_profile_photo(UserId user_id, const td_api::object_pt
                                          bool only_suggest, Promise<Unit> &&promise) {
   TRY_RESULT_PROMISE(promise, input_user, get_input_user(user_id));
   if (!only_suggest && !is_user_contact(user_id)) {
-    return promise.set_error(Status::Error(400, "User isn't a contact"));
+    return promise.set_error(400, "User isn't a contact");
   }
   if (user_id == get_my_id()) {
-    return promise.set_error(Status::Error(400, "Can't set personal or suggest photo to self"));
+    return promise.set_error(400, "Can't set personal or suggest photo to self");
   }
   if (is_user_bot(user_id)) {
-    return promise.set_error(Status::Error(400, "Can't set personal or suggest photo to bots"));
+    return promise.set_error(400, "Can't set personal or suggest photo to bots");
   }
   if (input_photo == nullptr) {
     td_->create_handler<DeleteContactProfilePhotoQuery>(std::move(promise))->send(user_id, std::move(input_user));
@@ -5240,7 +5240,7 @@ void UserManager::send_update_profile_photo_query(UserId user_id, FileId file_id
   FileView file_view = td_->file_manager_->get_file_view(file_id);
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (main_remote_location == nullptr) {
-    return promise.set_error(Status::Error(500, "Failed to upload the file"));
+    return promise.set_error(500, "Failed to upload the file");
   }
   td_->create_handler<UpdateProfilePhotoQuery>(std::move(promise))
       ->send(user_id, file_id, old_photo_id, is_fallback, main_remote_location->as_input_photo());
@@ -5281,10 +5281,10 @@ void UserManager::on_upload_profile_photo(FileUploadId file_upload_id,
   const auto *main_remote_location = file_view.get_main_remote_location();
   if (main_remote_location != nullptr && input_file == nullptr) {
     if (main_remote_location->is_web()) {
-      return promise.set_error(Status::Error(400, "Can't use web photo as profile photo"));
+      return promise.set_error(400, "Can't use web photo as profile photo");
     }
     if (reupload_count == 3) {  // upload, ForceReupload repair file reference, reupload
-      return promise.set_error(Status::Error(400, "Failed to reupload the file"));
+      return promise.set_error(400, "Failed to reupload the file");
     }
 
     // delete file reference and forcely reupload the file
@@ -5524,7 +5524,7 @@ void UserManager::delete_profile_photo(int64 profile_photo_id, bool is_recursive
   if (user_full == nullptr) {
     // must load UserFull first, because fallback photo can't be deleted via DeleteProfilePhotoQuery
     if (is_recursive) {
-      return promise.set_error(Status::Error(500, "Failed to load UserFullInfo"));
+      return promise.set_error(500, "Failed to load UserFullInfo");
     }
     auto reload_promise = PromiseCreator::lambda(
         [actor_id = actor_id(this), profile_photo_id, promise = std::move(promise)](Result<Unit> result) mutable {
@@ -5559,7 +5559,7 @@ void UserManager::toggle_user_can_manage_emoji_status(UserId user_id, bool can_m
                                                       Promise<Unit> &&promise) {
   TRY_RESULT_PROMISE(promise, input_user, get_input_user(user_id));
   if (!is_user_bot(user_id)) {
-    return promise.set_error(Status::Error(400, "The user must be a bot"));
+    return promise.set_error(400, "The user must be a bot");
   }
   td_->create_handler<ToggleUserEmojiStatusPermissionQuery>(std::move(promise))
       ->send(user_id, std::move(input_user), can_manage_emoji_status);
@@ -5584,7 +5584,7 @@ void UserManager::on_set_user_emoji_status(UserId user_id, unique_ptr<EmojiStatu
 
 void UserManager::set_username(const string &username, Promise<Unit> &&promise) {
   if (!username.empty() && !is_allowed_username(username)) {
-    return promise.set_error(Status::Error(400, "Username is invalid"));
+    return promise.set_error(400, "Username is invalid");
   }
   td_->create_handler<UpdateUsernameQuery>(std::move(promise))->send(username);
 }
@@ -5606,7 +5606,7 @@ void UserManager::toggle_username_is_active_impl(string &&username, bool is_acti
   const User *u = get_user(get_my_id());
   CHECK(u != nullptr);
   if (!u->usernames.can_toggle(username)) {
-    return promise.set_error(Status::Error(400, "Wrong username specified"));
+    return promise.set_error(400, "Wrong username specified");
   }
   td_->create_handler<ToggleUsernameQuery>(std::move(promise))->send(std::move(username), is_active);
 }
@@ -5627,7 +5627,7 @@ void UserManager::reorder_usernames_impl(vector<string> &&usernames, Promise<Uni
   const User *u = get_user(get_my_id());
   CHECK(u != nullptr);
   if (!u->usernames.can_reorder_to(usernames)) {
-    return promise.set_error(Status::Error(400, "Invalid username order specified"));
+    return promise.set_error(400, "Invalid username order specified");
   }
   if (usernames.size() <= 1) {
     return promise.set_value(Unit());
@@ -5663,12 +5663,12 @@ void UserManager::toggle_bot_username_is_active(UserId bot_user_id, string &&use
                                                 Promise<Unit> &&promise) {
   TRY_RESULT_PROMISE(promise, bot_data, get_bot_data(bot_user_id));
   if (!bot_data.can_be_edited) {
-    return promise.set_error(Status::Error(400, "The bot can't be edited"));
+    return promise.set_error(400, "The bot can't be edited");
   }
   const User *u = get_user(bot_user_id);
   CHECK(u != nullptr);
   if (!u->usernames.can_toggle(username)) {
-    return promise.set_error(Status::Error(400, "Wrong username specified"));
+    return promise.set_error(400, "Wrong username specified");
   }
   td_->create_handler<ToggleBotUsernameQuery>(std::move(promise))->send(bot_user_id, std::move(username), is_active);
 }
@@ -5676,12 +5676,12 @@ void UserManager::toggle_bot_username_is_active(UserId bot_user_id, string &&use
 void UserManager::reorder_bot_usernames(UserId bot_user_id, vector<string> &&usernames, Promise<Unit> &&promise) {
   TRY_RESULT_PROMISE(promise, bot_data, get_bot_data(bot_user_id));
   if (!bot_data.can_be_edited) {
-    return promise.set_error(Status::Error(400, "The bot can't be edited"));
+    return promise.set_error(400, "The bot can't be edited");
   }
   const User *u = get_user(bot_user_id);
   CHECK(u != nullptr);
   if (!u->usernames.can_reorder_to(usernames)) {
-    return promise.set_error(Status::Error(400, "Invalid username order specified"));
+    return promise.set_error(400, "Invalid username order specified");
   }
   if (usernames.size() <= 1) {
     return promise.set_value(Unit());
@@ -5692,7 +5692,7 @@ void UserManager::reorder_bot_usernames(UserId bot_user_id, vector<string> &&use
 void UserManager::set_accent_color(AccentColorId accent_color_id, CustomEmojiId background_custom_emoji_id,
                                    Promise<Unit> &&promise) {
   if (!accent_color_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid accent color identifier specified"));
+    return promise.set_error(400, "Invalid accent color identifier specified");
   }
   if (accent_color_id == AccentColorId(get_my_id())) {
     accent_color_id = AccentColorId();
@@ -5751,10 +5751,10 @@ void UserManager::set_personal_channel(DialogId dialog_id, Promise<Unit> &&promi
   ChannelId channel_id;
   if (dialog_id != DialogId()) {
     if (!td_->dialog_manager_->have_dialog_force(dialog_id, "set_personal_channel")) {
-      return promise.set_error(Status::Error(400, "Chat not found"));
+      return promise.set_error(400, "Chat not found");
     }
     if (!td_->dialog_manager_->is_broadcast_channel(dialog_id)) {
-      return promise.set_error(Status::Error(400, "Chat can't be set as a personal chat"));
+      return promise.set_error(400, "Chat can't be set as a personal chat");
     }
     channel_id = dialog_id.get_channel_id();
   }
@@ -5782,7 +5782,7 @@ void UserManager::on_set_personal_channel(ChannelId channel_id, Promise<Unit> &&
 
 void UserManager::set_emoji_status(const unique_ptr<EmojiStatus> &emoji_status, Promise<Unit> &&promise) {
   if (!td_->option_manager_->get_option_boolean("is_premium")) {
-    return promise.set_error(Status::Error(400, "The method is available only to Telegram Premium users"));
+    return promise.set_error(400, "The method is available only to Telegram Premium users");
   }
   if (emoji_status != nullptr) {
     add_recent_emoji_status(td_, *emoji_status);
@@ -5853,7 +5853,7 @@ void UserManager::on_get_support_user(UserId user_id, Promise<td_api::object_ptr
 
   const User *u = get_user(user_id);
   if (u == nullptr) {
-    return promise.set_error(Status::Error(500, "Can't find support user"));
+    return promise.set_error(500, "Can't find support user");
   }
   if (!u->is_support) {
     LOG(ERROR) << "Receive non-support " << user_id << ", but expected a support user";
@@ -5866,10 +5866,10 @@ void UserManager::on_get_support_user(UserId user_id, Promise<td_api::object_ptr
 void UserManager::get_user_profile_photos(UserId user_id, int32 offset, int32 limit,
                                           Promise<td_api::object_ptr<td_api::chatPhotos>> &&promise) {
   if (offset < 0) {
-    return promise.set_error(Status::Error(400, "Parameter offset must be non-negative"));
+    return promise.set_error(400, "Parameter offset must be non-negative");
   }
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+    return promise.set_error(400, "Parameter limit must be positive");
   }
   if (limit > MAX_GET_PROFILE_PHOTOS) {
     limit = MAX_GET_PROFILE_PHOTOS;
@@ -5879,7 +5879,7 @@ void UserManager::get_user_profile_photos(UserId user_id, int32 offset, int32 li
 
   auto *u = get_user(user_id);
   if (u == nullptr) {
-    return promise.set_error(Status::Error(400, "User not found"));
+    return promise.set_error(400, "User not found");
   }
 
   apply_pending_user_photo(u, user_id, "get_user_profile_photos");
@@ -5961,7 +5961,7 @@ void UserManager::on_get_user_profile_photos(UserId user_id, Result<Unit> &&resu
     CHECK(have_user(user_id));
     // received result has just been dropped; resend request
     if (++pending_requests[0].retry_count >= 3) {
-      pending_requests[0].promise.set_error(Status::Error(500, "Failed to return profile photos"));
+      pending_requests[0].promise.set_error(500, "Failed to return profile photos");
       pending_requests.erase(pending_requests.begin());
       if (pending_requests.empty()) {
         return;
@@ -6001,7 +6001,7 @@ void UserManager::on_get_user_profile_photos(UserId user_id, Result<Unit> &&resu
     }
 
     if (request_index == 0 && ++request.retry_count >= 3) {
-      request.promise.set_error(Status::Error(500, "Failed to get profile photos"));
+      request.promise.set_error(500, "Failed to get profile photos");
       continue;
     }
 
@@ -6251,7 +6251,7 @@ void UserManager::on_get_is_premium_required_to_contact_users(
     Promise<Unit> &&promise) {
   if (user_ids.size() != requirements.size()) {
     LOG(ERROR) << "Receive " << requirements.size() << " flags instead of " << user_ids.size();
-    return promise.set_error(Status::Error(500, "Receive invalid response"));
+    return promise.set_error(500, "Receive invalid response");
   }
   for (size_t i = 0; i < user_ids.size(); i++) {
     auto user_id = user_ids[i];
@@ -6917,7 +6917,7 @@ std::pair<vector<UserId>, vector<int32>> UserManager::change_imported_contacts(v
   }
 
   if (are_imported_contacts_changing_) {
-    promise.set_error(Status::Error(400, "ChangeImportedContacts can be called only once at the same time"));
+    promise.set_error(400, "ChangeImportedContacts can be called only once at the same time");
     return {};
   }
 
@@ -7098,7 +7098,7 @@ std::pair<int32, vector<UserId>> UserManager::search_contacts(const string &quer
   LOG(INFO) << "Search contacts with query = \"" << query << "\" and limit = " << limit;
 
   if (limit < 0) {
-    promise.set_error(Status::Error(400, "Limit must be non-negative"));
+    promise.set_error(400, "Limit must be non-negative");
     return {};
   }
 
@@ -7208,7 +7208,7 @@ vector<UserId> UserManager::get_close_friends(Promise<Unit> &&promise) {
 void UserManager::set_close_friends(vector<UserId> user_ids, Promise<Unit> &&promise) {
   for (auto &user_id : user_ids) {
     if (!have_user(user_id)) {
-      return promise.set_error(Status::Error(400, "User not found"));
+      return promise.set_error(400, "User not found");
     }
   }
 
@@ -7234,7 +7234,7 @@ void UserManager::on_set_close_friends(const vector<UserId> &user_ids, Promise<U
 UserId UserManager::search_user_by_phone_number(string phone_number, bool only_local, Promise<Unit> &&promise) {
   clean_phone_number(phone_number);
   if (phone_number.empty()) {
-    promise.set_error(Status::Error(200, "Phone number is invalid"));
+    promise.set_error(200, "Phone number is invalid");
     return UserId();
   }
 
@@ -7323,7 +7323,7 @@ UserManager::UserFull *UserManager::get_user_full_force(UserId user_id, const ch
 void UserManager::load_user_full(UserId user_id, bool force, Promise<Unit> &&promise, const char *source) {
   auto u = get_user(user_id);
   if (u == nullptr) {
-    return promise.set_error(Status::Error(400, "User not found"));
+    return promise.set_error(400, "User not found");
   }
 
   auto user_full = get_user_full_force(user_id, source);
@@ -7354,7 +7354,7 @@ void UserManager::send_get_user_full_query(UserId user_id,
                                            Promise<Unit> &&promise, const char *source) {
   LOG(INFO) << "Get full " << user_id << " from " << source;
   if (!user_id.is_valid()) {
-    return promise.set_error(Status::Error(500, "Invalid user_id"));
+    return promise.set_error(500, "Invalid user_id");
   }
   auto send_query =
       PromiseCreator::lambda([td = td_, input_user = std::move(input_user)](Result<Promise<Unit>> &&promise) mutable {
@@ -7923,7 +7923,7 @@ UserManager::SecretChat *UserManager::get_secret_chat_force(SecretChatId secret_
 
 bool UserManager::get_secret_chat(SecretChatId secret_chat_id, bool force, Promise<Unit> &&promise) {
   if (!secret_chat_id.is_valid()) {
-    promise.set_error(Status::Error(400, "Invalid secret chat identifier"));
+    promise.set_error(400, "Invalid secret chat identifier");
     return false;
   }
 
@@ -7934,7 +7934,7 @@ bool UserManager::get_secret_chat(SecretChatId secret_chat_id, bool force, Promi
       return false;
     }
 
-    promise.set_error(Status::Error(400, "Secret chat not found"));
+    promise.set_error(400, "Secret chat not found");
     return false;
   }
 
@@ -8110,7 +8110,7 @@ void UserManager::on_load_secret_chat_from_database(SecretChatId secret_chat_id,
 void UserManager::create_new_secret_chat(UserId user_id, Promise<td_api::object_ptr<td_api::chat>> &&promise) {
   TRY_RESULT_PROMISE(promise, input_user, get_input_user(user_id));
   if (input_user->get_id() != telegram_api::inputUser::ID) {
-    return promise.set_error(Status::Error(400, "Can't create secret chat with the user"));
+    return promise.set_error(400, "Can't create secret chat with the user");
   }
   auto user = static_cast<const telegram_api::inputUser *>(input_user.get());
 
diff --git a/td/telegram/WebAppManager.cpp b/td/telegram/WebAppManager.cpp
index 30ed900d0..52e075016 100644
--- a/td/telegram/WebAppManager.cpp
+++ b/td/telegram/WebAppManager.cpp
@@ -473,7 +473,7 @@ void WebAppManager::schedule_ping_web_view() {
 void WebAppManager::get_popular_app_bots(const string &offset, int32 limit,
                                          Promise<td_api::object_ptr<td_api::foundUsers>> &&promise) {
   if (limit <= 0) {
-    return promise.set_error(Status::Error(400, "Limit must be positive"));
+    return promise.set_error(400, "Limit must be positive");
   }
   td_->create_handler<GetPopularAppBotsQuery>(std::move(promise))->send(offset, limit);
 }
@@ -502,7 +502,7 @@ void WebAppManager::on_get_web_app(UserId bot_user_id, string web_app_short_name
   if (bot_app->app_->get_id() != telegram_api::botApp::ID) {
     CHECK(bot_app->app_->get_id() != telegram_api::botAppNotModified::ID);
     LOG(ERROR) << "Receive " << to_string(bot_app);
-    return promise.set_error(Status::Error(500, "Receive invalid response"));
+    return promise.set_error(500, "Receive invalid response");
   }
 
   WebApp web_app(td_, telegram_api::move_object_as<telegram_api::botApp>(bot_app->app_), DialogId(bot_user_id));
@@ -554,7 +554,7 @@ void WebAppManager::request_main_web_view(DialogId dialog_id, UserId bot_user_id
   TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(bot_user_id));
   TRY_RESULT_PROMISE(promise, bot_data, td_->user_manager_->get_bot_data(bot_user_id));
   if (!bot_data.has_main_app) {
-    return promise.set_error(Status::Error(400, "The bot has no main Mini App"));
+    return promise.set_error(400, "The bot has no main Mini App");
   }
   on_dialog_used(TopDialogCategory::BotApp, DialogId(bot_user_id), G()->unix_time());
 
@@ -632,7 +632,7 @@ void WebAppManager::check_download_file_params(UserId bot_user_id, const string
   TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(bot_user_id));
   if (file_name.size() >= 256u || url.size() > 32768u || file_name.find('/') != string::npos ||
       file_name.find('\\') != string::npos) {
-    return promise.set_error(Status::Error(400, "The file can't be downloaded"));
+    return promise.set_error(400, "The file can't be downloaded");
   }
   td_->create_handler<CheckDownloadFileParamsQuery>(std::move(promise))->send(std::move(input_user), file_name, url);
 }
diff --git a/td/telegram/WebPagesManager.cpp b/td/telegram/WebPagesManager.cpp
index 47c3bb67b..b5c09b2a5 100644
--- a/td/telegram/WebPagesManager.cpp
+++ b/td/telegram/WebPagesManager.cpp
@@ -989,7 +989,7 @@ void WebPagesManager::on_get_web_page_preview(unique_ptr<GetWebPagePreviewOption
     }
 
     LOG(ERROR) << "Receive " << to_string(message_media_ptr) << " instead of web page";
-    return promise.set_error(Status::Error(500, "Receive not web page in GetWebPagePreview"));
+    return promise.set_error(500, "Receive not web page in GetWebPagePreview");
   }
 
   auto message_media_web_page = move_tl_object_as<telegram_api::messageMediaWebPage>(message_media_ptr);
@@ -2129,7 +2129,7 @@ void WebPagesManager::on_pending_web_page_timeout(WebPageId web_page_id) {
       auto requests = std::move(it->second);
       pending_get_web_pages_.erase(it);
       for (auto &request : requests) {
-        request.second.set_error(Status::Error(500, "Request timeout exceeded"));
+        request.second.set_error(500, "Request timeout exceeded");
         count++;
       }
     }
diff --git a/td/telegram/files/FileGenerateManager.cpp b/td/telegram/files/FileGenerateManager.cpp
index 7ec423bbb..d3e7b5fca 100644
--- a/td/telegram/files/FileGenerateManager.cpp
+++ b/td/telegram/files/FileGenerateManager.cpp
@@ -367,7 +367,7 @@ class FileExternalGenerateActor final : public FileGenerateActor {
       if (status.is_ok() || status.code() == -1) {
         promise.set_value(Unit());
       } else {
-        promise.set_error(Status::Error(400, status.message()));
+        promise.set_error(400, status.message());
       }
     }
 
@@ -465,7 +465,7 @@ void FileGenerateManager::external_file_generate_write_part(QueryId query_id, in
                                                             Promise<> promise) {
   auto it = query_id_to_query_.find(query_id);
   if (it == query_id_to_query_.end()) {
-    return promise.set_error(Status::Error(400, "Unknown generation_id"));
+    return promise.set_error(400, "Unknown generation_id");
   }
   auto safe_promise = SafePromise<>(std::move(promise), Status::Error(400, "Generation has already been finished"));
   send_closure(it->second.worker_, &FileGenerateActor::file_generate_write_part, offset, std::move(data),
@@ -476,7 +476,7 @@ void FileGenerateManager::external_file_generate_progress(QueryId query_id, int6
                                                           int64 local_prefix_size, Promise<> promise) {
   auto it = query_id_to_query_.find(query_id);
   if (it == query_id_to_query_.end()) {
-    return promise.set_error(Status::Error(400, "Unknown generation_id"));
+    return promise.set_error(400, "Unknown generation_id");
   }
   auto safe_promise = SafePromise<>(std::move(promise), Status::Error(400, "Generation has already been finished"));
   send_closure(it->second.worker_, &FileGenerateActor::file_generate_progress, expected_size, local_prefix_size,
@@ -486,7 +486,7 @@ void FileGenerateManager::external_file_generate_progress(QueryId query_id, int6
 void FileGenerateManager::external_file_generate_finish(QueryId query_id, Status status, Promise<> promise) {
   auto it = query_id_to_query_.find(query_id);
   if (it == query_id_to_query_.end()) {
-    return promise.set_error(Status::Error(400, "Unknown generation_id"));
+    return promise.set_error(400, "Unknown generation_id");
   }
   auto safe_promise = SafePromise<>(std::move(promise), Status::Error(400, "Generation has already been finished"));
   send_closure(it->second.worker_, &FileGenerateActor::file_generate_finish, std::move(status),
diff --git a/td/telegram/files/FileManager.cpp b/td/telegram/files/FileManager.cpp
index 217daa624..04612e139 100644
--- a/td/telegram/files/FileManager.cpp
+++ b/td/telegram/files/FileManager.cpp
@@ -2824,14 +2824,14 @@ bool FileManager::set_content(FileId file_id, BufferSlice bytes) {
 void FileManager::get_content(FileId file_id, Promise<BufferSlice> promise) {
   auto node = get_sync_file_node(file_id);
   if (!node) {
-    return promise.set_error(Status::Error("Unknown file_id"));
+    return promise.set_error("Unknown file_id");
   }
   check_local_location(node, true).ignore();
 
   auto file_view = FileView(node);
   const auto *full_local_location = file_view.get_full_local_location();
   if (full_local_location == nullptr) {
-    return promise.set_error(Status::Error("No local location"));
+    return promise.set_error("No local location");
   }
 
   send_closure(file_load_manager_, &FileLoadManager::get_content, full_local_location->path_, std::move(promise));
@@ -2841,17 +2841,17 @@ void FileManager::read_file_part(FileId file_id, int64 offset, int64 count, int
   TRY_STATUS_PROMISE(promise, G()->close_status());
 
   if (!file_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "File identifier is invalid"));
+    return promise.set_error(400, "File identifier is invalid");
   }
   auto node = get_sync_file_node(file_id);
   if (!node) {
-    return promise.set_error(Status::Error(400, "File not found"));
+    return promise.set_error(400, "File not found");
   }
   if (offset < 0) {
-    return promise.set_error(Status::Error(400, "Parameter offset must be non-negative"));
+    return promise.set_error(400, "Parameter offset must be non-negative");
   }
   if (count < 0) {
-    return promise.set_error(Status::Error(400, "Parameter count must be non-negative"));
+    return promise.set_error(400, "Parameter count must be non-negative");
   }
 
   auto file_view = FileView(node);
@@ -2863,10 +2863,10 @@ void FileManager::read_file_part(FileId file_id, int64 offset, int64 count, int
     }
   } else if (file_view.downloaded_prefix(offset) < count) {
     // TODO this check is safer to do in another thread
-    return promise.set_error(Status::Error(400, "There is not enough downloaded bytes in the file to read"));
+    return promise.set_error(400, "There is not enough downloaded bytes in the file to read");
   }
   if (count >= static_cast<int64>(std::numeric_limits<size_t>::max() / 2 - 1)) {
-    return promise.set_error(Status::Error(400, "Part length is too big"));
+    return promise.set_error(400, "Part length is too big");
   }
 
   const string *path = nullptr;
@@ -2875,7 +2875,7 @@ void FileManager::read_file_part(FileId file_id, int64 offset, int64 count, int
   if (full_local_location != nullptr) {
     path = &full_local_location->path_;
     if (!begins_with(*path, get_files_dir(file_view.get_type()))) {
-      return promise.set_error(Status::Error(400, "File is not inside the cache"));
+      return promise.set_error(400, "File is not inside the cache");
     }
   } else {
     CHECK(node->local_.type() == LocalFileLocation::Type::Partial);
@@ -2889,7 +2889,7 @@ void FileManager::read_file_part(FileId file_id, int64 offset, int64 count, int
         if (r_bytes.is_error()) {
           LOG(INFO) << "Failed to read file bytes: " << r_bytes.error();
           if (left_tries == 1 || !is_partial) {
-            return promise.set_error(Status::Error(400, "Failed to read the file"));
+            return promise.set_error(400, "Failed to read the file");
           }
 
           // the temporary file could be moved from temp to persistent directory
@@ -2959,15 +2959,15 @@ void FileManager::download_file(FileId file_id, int32 priority, int64 offset, in
                                 Promise<td_api::object_ptr<td_api::file>> &&promise) {
   TRY_STATUS_PROMISE(promise, check_priority(priority));
   if (offset < 0) {
-    return promise.set_error(Status::Error(400, "Download offset must be non-negative"));
+    return promise.set_error(400, "Download offset must be non-negative");
   }
   if (limit < 0) {
-    return promise.set_error(Status::Error(400, "Download limit must be non-negative"));
+    return promise.set_error(400, "Download limit must be non-negative");
   }
 
   auto file_view = get_file_view(file_id);
   if (file_view.empty()) {
-    return promise.set_error(Status::Error(400, "File not found"));
+    return promise.set_error(400, "File not found");
   }
 
   auto info_it = pending_user_file_downloads_.find(file_id);
@@ -3021,7 +3021,7 @@ void FileManager::on_user_file_download_finished(FileId file_id) {
           download_offset + downloaded_size - offset >= limit))) {
       promise.set_value(std::move(file_object));
     } else {
-      promise.set_error(Status::Error(400, "File download has failed or was canceled"));
+      promise.set_error(400, "File download has failed or was canceled");
     }
   }
 }
@@ -5160,7 +5160,7 @@ void FileManager::preliminary_upload_file(const td_api::object_ptr<td_api::Input
   auto r_file_id =
       get_input_file_id(file_type, input_file, DialogId(), false, is_secret, !is_secure && !is_secret, is_secure);
   if (r_file_id.is_error()) {
-    return promise.set_error(Status::Error(r_file_id.error().code(), r_file_id.error().message()));
+    return promise.set_error(r_file_id.error().code(), r_file_id.error().message());
   }
   auto file_id = r_file_id.ok();
 
diff --git a/td/telegram/net/ConnectionCreator.cpp b/td/telegram/net/ConnectionCreator.cpp
index ee060105f..0935baedd 100644
--- a/td/telegram/net/ConnectionCreator.cpp
+++ b/td/telegram/net/ConnectionCreator.cpp
@@ -155,7 +155,7 @@ void ConnectionCreator::add_proxy(int32 old_proxy_id, string server, int32 port,
   TRY_RESULT_PROMISE(promise, new_proxy, Proxy::create_proxy(std::move(server), port, proxy_type.get()));
   if (old_proxy_id >= 0) {
     if (proxies_.count(old_proxy_id) == 0) {
-      return promise.set_error(Status::Error(400, "Proxy not found"));
+      return promise.set_error(400, "Proxy not found");
     }
     auto &old_proxy = proxies_[old_proxy_id];
     if (old_proxy == new_proxy) {
@@ -175,7 +175,7 @@ void ConnectionCreator::add_proxy(int32 old_proxy_id, string server, int32 port,
     proxy_last_used_saved_date_.erase(old_proxy_id);
   } else {
 #if TD_EMSCRIPTEN || TD_DARWIN_WATCH_OS
-    return promise.set_error(Status::Error(400, "The method is unsupported for the platform"));
+    return promise.set_error(400, "The method is unsupported for the platform");
 #endif
   }
 
@@ -206,7 +206,7 @@ void ConnectionCreator::add_proxy(int32 old_proxy_id, string server, int32 port,
 
 void ConnectionCreator::enable_proxy(int32 proxy_id, Promise<Unit> promise) {
   if (proxies_.count(proxy_id) == 0) {
-    return promise.set_error(Status::Error(400, "Unknown proxy identifier"));
+    return promise.set_error(400, "Unknown proxy identifier");
   }
 
   enable_proxy_impl(proxy_id);
@@ -221,7 +221,7 @@ void ConnectionCreator::disable_proxy(Promise<Unit> promise) {
 
 void ConnectionCreator::remove_proxy(int32 proxy_id, Promise<Unit> promise) {
   if (proxies_.count(proxy_id) == 0) {
-    return promise.set_error(Status::Error(400, "Unknown proxy identifier"));
+    return promise.set_error(400, "Unknown proxy identifier");
   }
 
   if (proxy_id == active_proxy_id_) {
@@ -243,7 +243,7 @@ void ConnectionCreator::get_proxies(Promise<td_api::object_ptr<td_api::proxies>>
 void ConnectionCreator::get_proxy_link(int32 proxy_id, Promise<string> promise) {
   auto it = proxies_.find(proxy_id);
   if (it == proxies_.end()) {
-    return promise.set_error(Status::Error(400, "Unknown proxy identifier"));
+    return promise.set_error(400, "Unknown proxy identifier");
   }
 
   promise.set_result(LinkManager::get_proxy_link(it->second, false));
@@ -281,7 +281,7 @@ void ConnectionCreator::ping_proxy(int32 proxy_id, Promise<double> promise) {
     bool prefer_ipv6 = G()->get_option_boolean("prefer_ipv6");
     auto infos = dc_options_set_.find_all_connections(main_dc_id, false, false, prefer_ipv6, false);
     if (infos.empty()) {
-      return promise.set_error(Status::Error(400, "Can't find valid DC address"));
+      return promise.set_error(400, "Can't find valid DC address");
     }
     const size_t MAX_CONNECTIONS = 10;
     if (infos.size() > MAX_CONNECTIONS) {
@@ -322,7 +322,7 @@ void ConnectionCreator::ping_proxy(int32 proxy_id, Promise<double> promise) {
 
   auto it = proxies_.find(proxy_id);
   if (it == proxies_.end()) {
-    return promise.set_error(Status::Error(400, "Unknown proxy identifier"));
+    return promise.set_error(400, "Unknown proxy identifier");
   }
   const Proxy &proxy = it->second;
   bool prefer_ipv6 = G()->get_option_boolean("prefer_ipv6");
@@ -330,7 +330,7 @@ void ConnectionCreator::ping_proxy(int32 proxy_id, Promise<double> promise) {
                PromiseCreator::lambda([actor_id = actor_id(this), promise = std::move(promise),
                                        proxy_id](Result<IPAddress> result) mutable {
                  if (result.is_error()) {
-                   return promise.set_error(Status::Error(400, result.error().public_message()));
+                   return promise.set_error(400, result.error().public_message());
                  }
                  send_closure(actor_id, &ConnectionCreator::ping_proxy_resolved, proxy_id, result.move_as_ok(),
                               std::move(promise));
@@ -340,14 +340,14 @@ void ConnectionCreator::ping_proxy(int32 proxy_id, Promise<double> promise) {
 void ConnectionCreator::ping_proxy_resolved(int32 proxy_id, IPAddress ip_address, Promise<double> promise) {
   auto it = proxies_.find(proxy_id);
   if (it == proxies_.end()) {
-    return promise.set_error(Status::Error(400, "Unknown proxy identifier"));
+    return promise.set_error(400, "Unknown proxy identifier");
   }
   const Proxy &proxy = it->second;
   auto main_dc_id = G()->net_query_dispatcher().get_main_dc_id();
   FindConnectionExtra extra;
   auto r_socket_fd = find_connection(proxy, ip_address, main_dc_id, false, extra);
   if (r_socket_fd.is_error()) {
-    return promise.set_error(Status::Error(400, r_socket_fd.error().public_message()));
+    return promise.set_error(400, r_socket_fd.error().public_message());
   }
   auto socket_fd = r_socket_fd.move_as_ok();
 
@@ -355,7 +355,7 @@ void ConnectionCreator::ping_proxy_resolved(int32 proxy_id, IPAddress ip_address
       [actor_id = actor_id(this), ip_address, promise = std::move(promise), transport_type = extra.transport_type,
        debug_str = extra.debug_str](Result<ConnectionData> r_connection_data) mutable {
         if (r_connection_data.is_error()) {
-          return promise.set_error(Status::Error(400, r_connection_data.error().public_message()));
+          return promise.set_error(400, r_connection_data.error().public_message());
         }
         auto connection_data = r_connection_data.move_as_ok();
         send_closure(actor_id, &ConnectionCreator::ping_proxy_buffered_socket_fd, ip_address,
@@ -383,7 +383,7 @@ void ConnectionCreator::ping_proxy_buffered_socket_fd(IPAddress ip_address, Buff
                                PromiseCreator::lambda([promise = std::move(promise)](
                                                           Result<unique_ptr<mtproto::RawConnection>> result) mutable {
                                  if (result.is_error()) {
-                                   return promise.set_error(Status::Error(400, result.error().public_message()));
+                                   return promise.set_error(400, result.error().public_message());
                                  }
                                  auto ping_time = result.ok()->extra().rtt;
                                  promise.set_value(std::move(ping_time));
@@ -397,11 +397,11 @@ void ConnectionCreator::test_proxy(Proxy &&proxy, int32 dc_id, double timeout, P
   IPAddress ip_address;
   auto status = ip_address.init_host_port(proxy.server(), proxy.port());
   if (status.is_error()) {
-    return promise.set_error(Status::Error(400, status.public_message()));
+    return promise.set_error(400, status.public_message());
   }
   auto r_socket_fd = SocketFd::open(ip_address);
   if (r_socket_fd.is_error()) {
-    return promise.set_error(Status::Error(400, r_socket_fd.error().public_message()));
+    return promise.set_error(400, r_socket_fd.error().public_message());
   }
 
   auto dc_options = get_default_dc_options(false);
@@ -413,7 +413,7 @@ void ConnectionCreator::test_proxy(Proxy &&proxy, int32 dc_id, double timeout, P
     }
   }
   if (!mtproto_ip_address.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid datacenter identifier specified"));
+    return promise.set_error(400, "Invalid datacenter identifier specified");
   }
 
   auto request_id = ++test_proxy_request_id_;
@@ -489,7 +489,7 @@ void ConnectionCreator::on_test_proxy_handshake_connection(
     }
     auto promise = std::move(it->second->promise_);
     test_proxy_requests_.erase(it);
-    return promise.set_error(Status::Error(400, r_raw_connection.move_as_error().public_message()));
+    return promise.set_error(400, r_raw_connection.move_as_error().public_message());
   }
 }
 
@@ -503,11 +503,11 @@ void ConnectionCreator::on_test_proxy_handshake(uint64 request_id,
   test_proxy_requests_.erase(it);
 
   if (r_handshake.is_error()) {
-    return promise.set_error(Status::Error(400, r_handshake.move_as_error().public_message()));
+    return promise.set_error(400, r_handshake.move_as_error().public_message());
   }
   auto handshake = r_handshake.move_as_ok();
   if (!handshake->is_ready_for_finish()) {
-    return promise.set_error(Status::Error(400, "Handshake is not ready"));
+    return promise.set_error(400, "Handshake is not ready");
   }
   promise.set_value(Unit());
 }
@@ -520,7 +520,7 @@ void ConnectionCreator::on_test_proxy_timeout(uint64 request_id) {
   auto promise = std::move(it->second->promise_);
   test_proxy_requests_.erase(it);
 
-  promise.set_error(Status::Error(400, "Timeout expired"));
+  promise.set_error(400, "Timeout expired");
 }
 
 void ConnectionCreator::set_active_proxy_id(int32 proxy_id, bool from_binlog) {
@@ -760,7 +760,7 @@ void ConnectionCreator::request_raw_connection_by_ip(IPAddress ip_address, mtpro
                                                     transport_type, network_generation = network_generation_,
                                                     ip_address](Result<ConnectionData> r_connection_data) mutable {
     if (r_connection_data.is_error()) {
-      return promise.set_error(Status::Error(400, r_connection_data.error().public_message()));
+      return promise.set_error(400, r_connection_data.error().public_message());
     }
     auto connection_data = r_connection_data.move_as_ok();
     auto raw_connection = mtproto::RawConnection::create(ip_address, std::move(connection_data.buffered_socket_fd),
@@ -873,7 +873,7 @@ ActorOwn<> ConnectionCreator::prepare_connection(IPAddress ip_address, SocketFd
           if (was_connected_ && stats_callback_) {
             stats_callback_->on_error();
           }
-          promise_.set_error(Status::Error(400, r_buffered_socket_fd.error().public_message()));
+          promise_.set_error(400, r_buffered_socket_fd.error().public_message());
         } else {
           ConnectionData data;
           data.ip_address = ip_address_;
@@ -1204,7 +1204,7 @@ void ConnectionCreator::add_dc_options(DcOptions &&new_dc_options) {
 
 void ConnectionCreator::on_dc_update(DcId dc_id, string ip_port, Promise<> promise) {
   if (!dc_id.is_exact()) {
-    return promise.set_error(Status::Error("Invalid dc_id"));
+    return promise.set_error("Invalid dc_id");
   }
 
   IPAddress ip_address;
@@ -1495,7 +1495,7 @@ void ConnectionCreator::on_ping_main_dc_result(uint64 token, Result<double> resu
 
   if (--request.left_queries == 0) {
     if (request.result.is_error()) {
-      request.promise.set_error(Status::Error(400, request.result.error().public_message()));
+      request.promise.set_error(400, request.result.error().public_message());
     } else {
       request.promise.set_value(request.result.move_as_ok());
     }
diff --git a/td/telegram/net/NetQueryDispatcher.cpp b/td/telegram/net/NetQueryDispatcher.cpp
index e53d83c5d..e190adeb7 100644
--- a/td/telegram/net/NetQueryDispatcher.cpp
+++ b/td/telegram/net/NetQueryDispatcher.cpp
@@ -443,7 +443,7 @@ void NetQueryDispatcher::check_authorization_is_ok() {
 
 void NetQueryDispatcher::set_verification_token(int64 verification_id, string &&token, Promise<Unit> &&promise) {
   if (verifier_.empty()) {
-    return promise.set_error(Status::Error(400, "Application verification not allowed"));
+    return promise.set_error(400, "Application verification not allowed");
   }
   send_closure_later(verifier_, &NetQueryVerifier::set_verification_token, verification_id, std::move(token),
                      std::move(promise));
diff --git a/td/telegram/net/NetQueryVerifier.cpp b/td/telegram/net/NetQueryVerifier.cpp
index 63ee23192..68f651719 100644
--- a/td/telegram/net/NetQueryVerifier.cpp
+++ b/td/telegram/net/NetQueryVerifier.cpp
@@ -87,7 +87,7 @@ void NetQueryVerifier::check_recaptcha(NetQueryPtr query, string action, string
 void NetQueryVerifier::set_verification_token(int64 query_id, string &&token, Promise<Unit> &&promise) {
   auto it = queries_.find(query_id);
   if (it == queries_.end()) {
-    return promise.set_error(Status::Error(400, "Verification not found"));
+    return promise.set_error(400, "Verification not found");
   }
   auto query = std::move(it->second.first);
   auto verification_query = std::move(it->second.second);
diff --git a/td/telegram/net/Session.cpp b/td/telegram/net/Session.cpp
index 0ab8e3201..22e72cb1d 100644
--- a/td/telegram/net/Session.cpp
+++ b/td/telegram/net/Session.cpp
@@ -182,10 +182,10 @@ class GenAuthKeyActor final : public Actor {
 
   void hangup() final {
     if (connection_promise_) {
-      connection_promise_.set_error(Status::Error(1, "Canceled"));
+      connection_promise_.set_error(1, "Canceled");
     }
     if (handshake_promise_) {
-      handshake_promise_.set_error(Status::Error(1, "Canceled"));
+      handshake_promise_.set_error(1, "Canceled");
     }
     stop();
   }
diff --git a/tdnet/td/net/DarwinHttp.mm b/tdnet/td/net/DarwinHttp.mm
index 0d56cffde..3288bdfdc 100644
--- a/tdnet/td/net/DarwinHttp.mm
+++ b/tdnet/td/net/DarwinHttp.mm
@@ -62,7 +62,7 @@ void http_send(NSURLRequest *request, Promise<BufferSlice> promise) {
           if (error == nil) {
             callback.set_value(BufferSlice(Slice((const char *)([data bytes]), [data length])));
           } else {
-            callback.set_error(Status::Error(static_cast<int32>([error code]), "HTTP request failed"));
+            callback.set_error(static_cast<int32>([error code]), "HTTP request failed");
           }
         }];
   [dataTask resume];
diff --git a/tdnet/td/net/GetHostByNameActor.cpp b/tdnet/td/net/GetHostByNameActor.cpp
index 04968632d..ec8c23a3d 100644
--- a/tdnet/td/net/GetHostByNameActor.cpp
+++ b/tdnet/td/net/GetHostByNameActor.cpp
@@ -136,7 +136,7 @@ GetHostByNameActor::GetHostByNameActor(Options options) : options_(std::move(opt
 void GetHostByNameActor::run(string host, int port, bool prefer_ipv6, Promise<IPAddress> promise) {
   TRY_RESULT_PROMISE(promise, ascii_host, idn_to_ascii(host));
   if (ascii_host.empty()) {
-    return promise.set_error(Status::Error("Host is empty"));
+    return promise.set_error("Host is empty");
   }
 
   auto begin_time = Time::now();
diff --git a/tdutils/td/utils/Promise.h b/tdutils/td/utils/Promise.h
index 9d5a34444..8d2eddba9 100644
--- a/tdutils/td/utils/Promise.h
+++ b/tdutils/td/utils/Promise.h
@@ -31,9 +31,11 @@ class PromiseInterface {
   virtual void set_value(T &&value) {
     set_result(std::move(value));
   }
+
   virtual void set_error(Status &&error) {
     set_result(std::move(error));
   }
+
   virtual void set_result(Result<T> &&result) {
     if (result.is_ok()) {
       set_value(result.move_as_ok());
@@ -45,6 +47,7 @@ class PromiseInterface {
   virtual bool is_cancellable() const {
     return false;
   }
+
   virtual bool is_canceled() const {
     return false;
   }
@@ -105,6 +108,7 @@ class LambdaPromise : public PromiseInterface<ValueT> {
       state_ = State::Complete;
     }
   }
+
   LambdaPromise(const LambdaPromise &) = delete;
   LambdaPromise &operator=(const LambdaPromise &) = delete;
   LambdaPromise(LambdaPromise &&) = default;
@@ -201,6 +205,7 @@ class Promise {
     promise_->set_value(std::move(value));
     promise_.reset();
   }
+
   void set_error(Status &&error) {
     if (!promise_) {
       return;
@@ -208,6 +213,15 @@ class Promise {
     promise_->set_error(std::move(error));
     promise_.reset();
   }
+
+  void set_error(int err, Slice message) {
+    set_error(Status::Error(err, message));
+  }
+
+  void set_error(Slice message) {
+    set_error(Status::Error(message));
+  }
+
   void set_result(Result<T> &&result) {
     if (!promise_) {
       return;
@@ -215,21 +229,25 @@ class Promise {
     promise_->set_result(std::move(result));
     promise_.reset();
   }
+
   void reset() {
     promise_.reset();
   }
+
   bool is_cancellable() const {
     if (!promise_) {
       return false;
     }
     return promise_->is_cancellable();
   }
+
   bool is_canceled() const {
     if (!promise_) {
       return false;
     }
     return promise_->is_canceled();
   }
+
   unique_ptr<PromiseInterface<T>> release() {
     return std::move(promise_);
   }
diff --git a/test/online.cpp b/test/online.cpp
index 29cd4ba50..96fa72bfc 100644
--- a/test/online.cpp
+++ b/test/online.cpp
@@ -184,7 +184,7 @@ class Task : public TestClient::Listener {
           TRY_RESULT_PROMISE(callback, obj, std::move(r_obj));
           if (obj->get_id() == td::td_api::error::ID) {
             auto err = move_tl_object_as<td_api::error>(std::move(obj));
-            callback.set_error(Status::Error(err->code_, err->message_));
+            callback.set_error(err->code_, err->message_);
             return;
           }
           callback.set_value(move_tl_object_as<typename ResultT::element_type>(std::move(obj)));
@@ -251,8 +251,7 @@ class InitTask : public Task {
       }
       default:
         LOG(ERROR) << "???";
-        promise_.set_error(
-            Status::Error(PSLICE() << "Unexpected authorization state " << to_string(authorization_state)));
+        promise_.set_error(PSLICE() << "Unexpected authorization state " << to_string(authorization_state));
         stop();
         break;
     }
diff --git a/test/secret.cpp b/test/secret.cpp
index 6580da226..3f0dfae67 100644
--- a/test/secret.cpp
+++ b/test/secret.cpp
@@ -633,7 +633,7 @@ class Master final : public Actor {
     int32 binlog_generation_ = 0;
     void sync_binlog(int32 binlog_generation, Promise<> promise) {
       if (binlog_generation != binlog_generation_) {
-        return promise.set_error(Status::Error("Binlog generation mismatch"));
+        return promise.set_error("Binlog generation mismatch");
       }
       binlog_->force_sync(std::move(promise), "sync_binlog");
     }
@@ -992,10 +992,10 @@ void FakeSecretChatContext::on_delete_messages(std::vector<int64> random_id, Pro
   promise.set_value(Unit());
 }
 void FakeSecretChatContext::on_flush_history(bool, MessageId, Promise<> promise) {
-  promise.set_error(Status::Error("Unsupported"));
+  promise.set_error("Unsupported");
 }
 void FakeSecretChatContext::on_read_message(int64, Promise<> promise) {
-  promise.set_error(Status::Error("Unsupported"));
+  promise.set_error("Unsupported");
 }
 
 TEST(Secret, go) {